@ssheleg/make-skill 0.7.1 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,139 @@
 # Changelog
 
+## v0.8.1 — 2026-08-03
+
+A file-by-file re-read of everything 0.8.0 touched, and of everything it didn't.
+Fourteen findings, all fixed. The two that would have misled a reader:
+
+### Fixed
+- **The token estimate was asserted, not measured.** The validator's comment
+  claimed dense markdown runs "closer to 3.7 chars/token, so this under-reports";
+  nothing had ever been counted. Tokenizing the bundle gives **3.78–4.47**
+  chars/token (3.9 for `SKILL.md`), so the divisor is now 3.9, measured — and
+  the recalibration immediately failed the body it was checking, which is what a
+  calibrated rule is for. The audit checklist moved to a new
+  **`references/retrofit.md`**, bringing the body to ~4.6k tokens with headroom.
+- **`claude plugin details` and a real tokenizer disagree by ~40%** — the CLI
+  reported ~7.2k on-invoke for a `SKILL.md` that tokenizes at ~5.0k, because its
+  estimator assumes ~2.8 chars/token. Measured across six installed skills and
+  recorded as a gotcha: budget against a tokenizer, expect the CLI to look
+  alarming, and never gut a body that is genuinely inside the budget.
+- **`SECURITY.md` described paths the installers do not write.** It claimed
+  `bin/make-skill.js` and `install.sh` copy into `~/.claude/commands/`; that
+  command file was deleted in 0.6.x and CI asserts its absence on every run. The
+  threat model now matches the code, and states what `test/evals/fixtures/` is —
+  including that the malicious sample is inert data, never installed.
+- **The trigger split could not measure what it claimed.** `train: q01-q12` /
+  `validation: q13-q20` put all ten positives in train and left validation with
+  nothing but negatives, so the held-out half could only detect false-firing.
+  Split is now explicit ids with both classes on both sides, and the validator
+  rejects a half that holds only one class.
+- **`displayName` was required by the canon and absent from the skeletons.**
+  Both manifest templates now seed it, and the validator enforces it in the
+  templates, in `plugin.json`, and in the marketplace entry — where it belongs
+  (the marketplace root takes neither `displayName` nor `homepage`).
+- **`/make-skill` is only half the truth.** As a plugin the command is
+  `/make-skill:make-skill`; the bare form is what a skills-directory install
+  gets. README and canon now state both, and the canon says to write both rather
+  than promise one.
+- `distribution.md`'s table of contents listed a "shadow rule" section that did
+  not exist as a heading — the exact failure a table of contents prevents. It is
+  a real section now.
+- Counts that had drifted: CONTRIBUTING said CI runs "four negative self-tests"
+  (six groups), the issue-template contact link said "the other four skills"
+  (five), the retrofit fixture header claimed eight planted defects (nine, now
+  scored one per line).
+- Dead `EVAL_DIR` variable removed; `test/evals/` added to the Cursor rule's
+  layout tree and to the templates README, both of which still described a repo
+  without it; the PR template now asks for the two `--strict` runs and for an
+  eval re-run when the description changes.
+- Three more negative self-tests (split classes, `displayName` ×2), keeping the
+  rule that no validator rule ships without one.
+
+## v0.8.0 — 2026-08-03
+
+Read Anthropic's four Agent Skills pages end to end (overview, authoring best
+practices, enterprise, the API skills guide) and audited the canon against them.
+The canon had been written against the open standard and the Claude Code plugin
+reference only — so it was correct about the format and blind to everything
+Anthropic's own surfaces enforce, recommend, or forbid. Three new references,
+six new validator rules, and one self-violation fixed.
+
+### Added
+- **`references/surfaces.md`** — the surface a skill runs on is a portability
+  contract, and it was undocumented here. Claude Code has full network and local
+  installs; the **Claude API container has neither**; claude.ai varies. A skill
+  whose script `pip install`s or curls works on one surface and silently fails
+  on the next. Also the whole Skills API — beta headers, `container.skills[]`,
+  **max 8 skills per request**, upload rules (top-level dir must match `name`,
+  `display_title` uniqueness, **< 30 MB**), epoch-timestamp versions,
+  delete-all-versions-before-delete — the claude.ai zip channel (per user, no
+  admin push), and the fact that **nothing syncs between surfaces**.
+- **`references/enterprise.md`** — installing a skill you did not write is
+  installing software, and the canon said so without saying how to check.
+  Anthropic's risk-tier table, the 8-step review checklist, the five approval
+  gates (triggering accuracy, isolation, **coexistence**, instruction following,
+  output quality), lifecycle with separation of duties, registry fields, recall
+  limits, and the production versioning/rollback/integrity rules.
+- **`references/authoring.md`** — the craft that the spec reference had only
+  hinted at: naming conventions (gerund; never `helper`/`utils`/`tools`),
+  **degrees of freedom** matched to task fragility, workflow checklists and
+  feedback loops, the script rules (solve-don't-defer, no voodoo constants,
+  execute-vs-read intent, declare packages), content guidelines, and
+  **evaluation-driven development** — evals before prose, ≥3 scenarios, a
+  no-skill baseline, the Claude-A/Claude-B loop, testing on every target model.
+  The trigger-eval loop moved here from the spec reference.
+- Six validator rules with negative self-tests that assert the *reason* for the
+  failure, not just a non-zero exit: reserved words in `name`, XML tags in
+  `name`/`description`, first/second person in `description`, the body token
+  budget, a `## Contents` list on references past 100 lines, and angle-bracket
+  placeholders in the SKILL template.
+- **`test/evals/`** — make-skill's own evaluation suite, because the canon now
+  requires one from every skill and shipping the rule without obeying it is how
+  a standard becomes decoration. `triggers.json`: 20 queries, 10 that must fire
+  (EN + RU) and 10 near-misses that share the keywords — "add a skills section
+  to my CV", "publish this React library to npm", "implement an MCP server for
+  Postgres". `scenarios.json`: four behavioral evaluations in Anthropic's shape
+  (create, retrofit-with-evidence, surface portability, third-party review),
+  scored line by line, with fixtures under `test/evals/fixtures/` — deliberately
+  broken and deliberately not named `SKILL.md`. The validator proves they exist
+  and are well-formed and cannot run them: that part is a human with an agent
+  (`test/evals/README.md`).
+
+### Fixed
+- **`name` may not contain `anthropic` or `claude`, and neither field may
+  contain XML tags.** The open standard is silent on both; Anthropic's platform
+  enforces them at upload. So `claude-helper` loads happily in Claude Code and
+  is rejected the day someone ships it to the API — a failure that only ever
+  appears on someone else's machine. Canon, spec reference, Cursor rule, README
+  and validator now carry the rule.
+- **Descriptions must be third person.** They are injected into the system
+  prompt, where "I can help you…" / "You can use this to…" measurably degrades
+  selection. Stated in the canon and checked by the validator.
+- **This skill was over its own token budget.** `SKILL.md` was ~5.2k estimated
+  tokens against a stated `< 5000` — a rule the repo enforced on everyone but
+  itself, because only the 500-line half was ever checked. The body budget is
+  now measured (frontmatter excluded as level-1 metadata) and the body was cut
+  by moving the repo layout, the two Claude Code gates, the validator spec and
+  the release checklist into `references/distribution.md`. (The divisor used
+  here was a guess; v0.8.1 measured it and cut further.)
+- **Reference files longer than 100 lines now open with a `## Contents` list.**
+  Agents preview long files with `head`; without a table of contents they act on
+  the first hundred lines and never learn the rest exists. All eight references
+  gained one — five were in violation.
+- **The SKILL template seeded an invalid skill.** Its `name: <skill-name>` and
+  `<angle-bracket>` description placeholders are XML tags in exactly the two
+  fields where Anthropic rejects them. Replaced with plain placeholders, and the
+  validator now checks the skeleton it ships.
+- **MCP tool names: two conventions, both real.** Anthropic's authoring guidance
+  writes `ServerName:tool_name`; Claude Code's runtime names are
+  `mcp__<server>__<tool>`. The canon documented only the second, which reads as
+  wrong against the docs — both are recorded now, with "list and match" still
+  the rule.
+- Retrofit audit gained surface honesty (item 3) and evaluations (item 8);
+  authoring rules gained naming style, prescriptiveness-to-fragility, and the
+  no-time-branching rule with the "Old patterns" escape hatch.
+
 ## v0.7.1 — 2026-07-31
 
 Re-read the plugin reference against what the canon actually says, and against

package/README.md

@@ -31,11 +31,14 @@ make a skill that turns our incident runbooks into a triage workflow
 …or point it at something that already exists:
 
 ```
-/make-skill audit ./skills/my-skill against the spec
+/make-skill:make-skill audit ./skills/my-skill against the spec
 ```
 
-Inside a skill repo, `/make-skill` with no argument detects the situation and runs
-the audit rather than asking you what you meant.
+With no argument it detects the situation — a `SKILL.md` or `.claude-plugin/` in
+the current directory means it runs the audit rather than asking you what you
+meant. The command is `/make-skill:make-skill` when installed as a plugin and
+`/make-skill` when it sits in a skills directory; both reach the same skill, and
+asking in plain language works either way.
 
 ## What it does
 
@@ -53,11 +56,15 @@ resolvable install — not "should work now".
 
 ## What you get
 
-**Conformance to the open standard, not just a house style.** The
+**Conformance to both rulebooks, not just a house style.** The
 [Agent Skills specification](https://agentskills.io/specification) sets hard
 limits — `name` is 1–64 chars of `a-z0-9` and single hyphens and must match its
 directory, `description` caps at 1024 characters, the body should stay under 500
-lines and 5000 tokens. Local conventions that merely *feel* right drift from those
+lines and 5000 tokens. [Anthropic's platform docs](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview)
+add rules the open standard is silent about and only the Skills API enforces —
+no XML tags in `name`/`description`, and no `anthropic`/`claude` anywhere in the
+name, so `claude-helper` loads fine in Claude Code and is rejected the day
+someone uploads it. Local conventions that merely *feel* right drift from both
 without anyone noticing; here they're checked.
 
 **Plugins Anthropic's own tooling accepts.** The
@@ -70,16 +77,26 @@ both manifests, in CI as its own job. That check is what caught this repo's own
 `marketplace.json` shipping `homepage` and `repository` at a level where Claude
 Code ignores them.
 
+**Evaluations, not vibes.** The canon requires every skill to carry at least
+three behavioral scenarios and a trigger set whose negatives are *near-misses* —
+queries that share the keywords and need something else. make-skill ships its
+own in [`test/evals/`](test/evals/), because a description that also fires on
+"review my pull request" steals turns from every other skill you have installed.
+
 **A validator that can fail.** `test/validate.py` (Python stdlib only, no deps)
-checks spec rules, version sync across every manifest, front-matter on commands
-and Cursor rules, link integrity, and the traps below. CI runs it plus **negative
-self-tests** — deliberately broken copies that must make it exit non-zero. A
-validator nobody has seen fail is decoration.
+checks both rulebooks' front-matter rules, the 500-line **and** 5000-token body
+budgets, a `## Contents` list on every reference past 100 lines, version sync
+across every manifest, front-matter on commands and Cursor rules, link
+integrity, and the traps below. CI runs it plus **negative self-tests** —
+deliberately broken copies that must make it exit non-zero, each asserted to
+fail for the right reason. A validator nobody has seen fail is decoration.
 
 **Every distribution channel, with the flags that actually work.** Claude Code
 plugin, the [vercel `skills` CLI](https://github.com/vercel-labs/skills) (70+
 agents), `npx`, Cursor rules, and umbrella-repo families — including the
-one-channel-per-agent rule that stops them from shadowing each other.
+one-channel-per-agent rule that stops them from shadowing each other — plus
+Anthropic's own surfaces (Skills API upload, claude.ai zip), which sync with
+none of the above and impose their own limits on what a skill may do at runtime.
 
 **The gotchas that each cost a debugging round**, so your first publish works
 instead of your fourth:
@@ -104,9 +121,13 @@ agent opens only when the situation calls for them:
 
 | Reference | Covers |
 |---|---|
-| `agent-skills-spec.md` | the open standard — field limits, optional front-matter, token budgets, the description trigger-eval loop |
+| `agent-skills-spec.md` | the hard rules from both authorities — field limits, where the open standard and Anthropic's platform differ, budgets, which checker says no |
+| `authoring.md` | the craft — naming, third-person descriptions, degrees of freedom, workflows and feedback loops, script rules, evaluation-driven development |
+| `surfaces.md` | Claude Code vs the Claude API vs claude.ai — the Skills API (upload, versions, 8 per request), and the no-network / no-package-install limits that break scripts moved between surfaces |
+| `enterprise.md` | installing a skill you didn't write, and running a fleet — risk tiers, the review checklist, the five approval gates, lifecycle, recall limits, rollback |
+| `retrofit.md` | the audit procedure — the 13-item checklist, what counts as evidence for a PASS, and the short form for a personal skill |
 | `claude-code-plugin.md` | the [Claude Code layer](https://code.claude.com/docs/en/plugins-reference) — `plugin.json` / `marketplace.json` schemas, plugin sources, component locations, host-only front-matter, path variables, cache and symlink rules, the `claude plugin` CLI |
-| `distribution.md` | every install channel, exact CLI flags, npm publishing traps |
+| `distribution.md` | the repo layout, every install channel, exact CLI flags, npm publishing traps, the release checklist |
 | `mcp.md` | [MCP](https://modelcontextprotocol.io) — skill vs server, primitives and methods, transports, consent and untrusted-output rules |
 | `a2a.md` | [A2A](https://a2a-protocol.org) — Agent Cards, task lifecycle, method mapping, v0.x→1.0 wire drift |
 
@@ -197,6 +218,7 @@ cursor/rules/make-skill.mdc           # self-contained Cursor rule
 templates/                            # SKILL.template.md + the two manifest skeletons
 bin/make-skill.js + package.json      # zero-dep npx installer
 test/validate.py                      # structural validator
+test/evals/                           # trigger set + behavioral scenarios (data)
 .github/workflows/{validate,release}.yml
 install.sh  README.md  CHANGELOG.md  CONTRIBUTING.md  SECURITY.md  LICENSE
 docs/superpowers/{specs,plans}/       # historical design records
@@ -212,7 +234,7 @@ install). Security reports: [SECURITY.md](SECURITY.md).
 
 Built by ssheleg — [sshlg.me](https://sshlg.me)
 
-- X / Twitter — [@fuck_this_year](https://x.com/fuck_this_year)
+- X / Twitter — [@sshlg93](https://x.com/sshlg93)
 - Telegram — [@sshlg](https://t.me/sshlg)
 
 Part of the [ssheleg skill family](https://github.com/ssheleg/sshlg-skills):

package/SECURITY.md

@@ -16,12 +16,16 @@ unless you'd prefer otherwise.
 `make-skill` ships Markdown plus two small installers. Knowing exactly what runs
 where is most of the threat model:
 
-- **`bin/make-skill.js`** (run via `npx`) and **`install.sh`** copy files into
-  `~/.claude/skills/make-skill` and `~/.claude/commands/`. They create and
-  overwrite only those paths, never elsewhere in `$HOME`, and overwrite only with
-  `--force`. Both are zero-dependency: no network calls, no postinstall script.
+- **`bin/make-skill.js`** (run via `npx`) and **`install.sh`** copy the skill
+  directory into `~/.claude/skills/make-skill` and nothing else — no command file,
+  no other path in `$HOME` — and overwrite only with `--force`. Both are
+  zero-dependency: no network calls, no postinstall script. CI asserts the
+  absence of `~/.claude/commands/make-skill.md` on every run.
 - **`test/validate.py`** reads repository files and exits with a status. It writes
-  nothing.
+  nothing. `test/evals/` is inert data — text a human feeds to an agent — and
+  `test/evals/fixtures/untrusted-skill.md` is a deliberately malicious *sample*
+  used to score a review; it is never installed or executed, and its endpoints
+  are `example.com` placeholders.
 - The Claude Code plugin and the `skills` CLI channels are handled by those tools,
   not by code in this repo.
 

package/cursor/rules/make-skill.mdc

@@ -1,5 +1,5 @@
 ---
-description: "make-skill: create, retrofit, audit, or publish an agent skill / plugin the proven ssheleg way — the Agent Skills open standard (front-matter limits, progressive-disclosure budgets), the Claude Code plugin reference (manifest schemas, component layout, claude plugin validate --strict), marketplace repo layout, four-way version sync, validator + CI, multi-channel distribution (Claude Code plugin, skills CLI, npx, Cursor), npm gotchas, and the MCP / A2A rules for protocol-connected skills. Apply when creating a new skill, upgrading one to standard, checking one against the spec, or wrapping one into a plugin."
+description: "make-skill: create, retrofit, audit, or publish an agent skill / plugin the proven ssheleg way — the Agent Skills open standard AND Anthropic's platform rules (front-matter limits, disclosure budgets, per-surface runtime limits, evals), the Claude Code plugin reference (manifest schemas, component layout, claude plugin validate --strict), marketplace repo layout, four-way version sync, validator + CI, multi-channel distribution (Claude Code plugin, skills CLI, npx, Cursor, Skills API), npm gotchas, the review checklist for installing someone else's skill, and the MCP / A2A rules for protocol-connected skills. Apply when creating a new skill, upgrading one to standard, checking one against the spec, or wrapping one into a plugin."
 alwaysApply: false
 ---
 
@@ -9,12 +9,20 @@ Self-contained rule: Cursor copies this file into foreign projects, so it carrie
 every contract inline and uses **absolute URLs only — never a relative link**
 (a relative link dangles the moment the file is copied).
 
-## Spec floor — the Agent Skills open standard (non-negotiable)
+## Spec floor — two authorities, both non-negotiable
 
-<https://agentskills.io/specification> — the house canon below only ADDS to it.
+<https://agentskills.io/specification> (the portable format) and
+<https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview>
+(what Anthropic's own surfaces enforce). Write to the intersection; the house
+canon below only ADDS to it.
 
-- `name`: 1–64 chars, `a-z0-9` + single internal hyphens, == directory name.
-- `description`: ≤1024 chars (that cap is on the field, not the whole front-matter).
+- `name`: 1–64 chars, `a-z0-9` + single internal hyphens, == directory name,
+  **no angle brackets and never containing `anthropic`/`claude`** — reserved
+  substrings Claude Code loads happily and the Skills API rejects on upload.
+- `description`: ≤1024 chars (the cap is on the field, not the whole
+  front-matter), no angle brackets, **third person** (it goes into the system
+  prompt; "I can help you…" degrades selection), stating WHAT it does and WHEN
+  to use it.
 - Portable front-matter keys: `name`, `description`, `license`,
   `compatibility` (≤500), `metadata` (string→string map), `allowed-tools`
   (space-separated string — Claude Code also takes a comma-list or YAML list, but
@@ -25,7 +33,14 @@ every contract inline and uses **absolute URLs only — never a relative link**
   load-bearing. Anything outside both sets is a typo.
 - Body < 500 lines and < 5000 tokens. Overflow goes to `references/` (docs),
   `scripts/` (code), `assets/` (templates) INSIDE the skill dir, one level deep,
-  each with a stated load trigger ("read X when Y"). Gotchas stay in SKILL.md.
+  each linked from the body with a stated load trigger ("read X when Y"), and
+  any reference over 100 lines opens with a `## Contents` list (a partial `head`
+  read is what the agent often gets). Gotchas stay in SKILL.md.
+- **Surfaces differ and nothing syncs between them:** the Claude API container
+  has NO network and NO runtime package install, claude.ai varies, only Claude
+  Code has both. A script that `pip install`s or curls is a Claude Code skill —
+  declare it in `compatibility` or drop the dependency. Skills API also caps a
+  request at 8 skills and an upload at 30 MB.
 - Upstream checker: `skills-ref validate <skill dir>` (Python, from the
   `agentskills/agentskills` repo).
 
@@ -33,8 +48,20 @@ every contract inline and uses **absolute URLs only — never a relative link**
 
 - `description` starts "Use when …" with concrete trigger phrases in English AND
   Russian. A skill nobody triggers is dead weight.
+- One naming pattern, preferably gerund (`processing-pdfs`); never `helper`,
+  `utils`, `tools`, `data`.
 - One skill = one job. Multiple concerns → multiple skills + a shared contract file.
-- Body: imperative, procedural, checklists over prose. State non-negotiables as such.
+- Body: imperative, procedural, checklists over prose. State non-negotiables as
+  such. Match prescriptiveness to fragility — exact commands for destructive or
+  order-dependent work, direction only where context decides.
+- **Evals before prose:** run the task with NO skill, record the failures, write
+  ≥3 evaluations (including should-NOT-trigger cases), then write the minimum
+  that passes; re-run on every model you claim. Adding to an existing set → test
+  coexistence, a broad description steals other skills' triggers.
+- Scripts: handle their own errors, justify every constant, declare packages,
+  and say whether the agent should RUN or READ each one.
+- No time-branching text ("before August, use the old API") — superseded
+  material goes under `## Old patterns`; forward slashes in every path.
 - Commands are thin wrappers: front-matter `description` (+ `argument-hint`), body =
   "invoke skill X in mode Y", pass `$ARGUMENTS`.
 - Never overwrite user data: seed only when absent; overwrite only behind `--force`.
@@ -50,6 +77,7 @@ cursor/rules/*.mdc                         # self-contained, NO relative links
 templates/*.md                             # skeletons — NEVER name one SKILL.md
 bin/<name>.js + package.json               # zero-dep npx installer
 test/validate.py                           # stdlib-only consistency validator
+test/evals/                                # triggers.json + scenarios.json (data, run by a human)
 .github/workflows/validate.yml (+ release.yml, off by default)
 install.sh, README.md (English-first), CHANGELOG.md, LICENSE (MIT)
 CONTRIBUTING.md + SECURITY.md              # required once the repo is public
@@ -105,6 +133,15 @@ checker, not a house opinion:
 - **Cursor .mdc:** embed contracts inline (files get copied into foreign projects).
 - **e2e npx from a NON-repo cwd** (inside the repo it resolves the local package →
   false "command not found").
+- **Two token counters, ~40% apart:** `claude plugin details` assumes ~2.8
+  chars/token and shows a far bigger on-invoke cost than a real tokenizer
+  (3.8–4.5 chars/token). Budget the body against a tokenizer; expect the CLI to
+  look alarming for a file that is genuinely inside 5000 tokens.
+- **Installing a skill you did not write is installing software.** Read every
+  file, run scripts sandboxed, grep for network calls and credentials, and check
+  the instructions for "ignore previous rules", hidden actions, or data routed
+  outward. A skill that fetches its instructions from a URL can change after the
+  review that approved it.
 
 ## Protocol-connected skills (MCP / A2A)
 
@@ -132,3 +169,8 @@ Claude Code plugin (`claude plugin marketplace add` → `install <name>@<name>`)
 vercel skills CLI (`npx skills add <owner>/<repo>`, discovers via marketplace.json),
 npx (`npx github:<owner>/<repo>`, or the registry after publish), Cursor (global via
 `npx skills add … --agent cursor --global`, or per-project `.cursor/rules/*.mdc`).
+Anthropic's own surfaces are separate deployments that sync with nothing: the
+Skills API (`POST /v1/skills`, beta headers `skills-2025-10-02` +
+`code-execution-2025-08-25`, workspace-wide, ≤8 skills per request, <30 MB, the
+uploaded top-level directory must match `name`) and claude.ai (zip upload in
+Settings → Features, per user, no admin push).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ssheleg/make-skill",
-  "version": "0.7.1",
-  "description": "Create, retrofit, audit, and ship agent skills & Claude Code plugins the proven ssheleg way — conformance to the Agent Skills open standard (front-matter limits, progressive-disclosure budgets) and the Claude Code plugin reference (manifest schemas, component layout, claude plugin validate --strict), marketplace repo layout, version sync, validator + CI, multi-channel distribution (plugin, vercel skills CLI, npx, Cursor), npm gotchas, and MCP / A2A rules for protocol-connected skills. This package is the installer CLI.",
+  "version": "0.8.1",
+  "description": "Create, retrofit, audit, and ship agent skills & Claude Code plugins the proven ssheleg way — conformance to the Agent Skills open standard AND Anthropic's platform rules (front-matter limits, disclosure budgets, per-surface runtime limits, the Skills API, evals) plus the Claude Code plugin reference (manifest schemas, component layout, claude plugin validate --strict), marketplace repo layout, version sync, validator + CI, multi-channel distribution (plugin, vercel skills CLI, npx, Cursor), npm gotchas, the review checklist for third-party skills, and MCP / A2A rules for protocol-connected skills. This package is the installer CLI.",
   "keywords": [
     "skill",
     "plugin",
@@ -22,7 +22,10 @@
   },
   "repository": "github:ssheleg/make-skill",
   "license": "MIT",
-  "author": "ssheleg",
+  "author": {
+    "name": "ssheleg",
+    "url": "https://x.com/sshlg93"
+  },
   "bin": {
     "make-skill": "bin/make-skill.js"
   },

package/plugins/make-skill/.claude-plugin/plugin.json

@@ -2,10 +2,11 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "make-skill",
   "displayName": "Make Skill",
-  "description": "Create, retrofit, audit, and ship agent skills & Claude Code plugins the proven ssheleg way: conformance to the Agent Skills open standard and the Claude Code plugin reference, marketplace repo layout, version sync, validator + CI, multi-channel distribution (plugin, vercel skills CLI, npx, Cursor), npm gotchas, end-to-end first publish, plus MCP / A2A references for protocol-connected skills.",
-  "version": "0.7.1",
+  "description": "Create, retrofit, audit, and ship agent skills & Claude Code plugins the proven ssheleg way: conformance to the Agent Skills open standard, Anthropic's platform rules (surfaces, Skills API, evals) and the Claude Code plugin reference, marketplace repo layout, version sync, validator + CI, multi-channel distribution (plugin, vercel skills CLI, npx, Cursor), npm gotchas, end-to-end first publish, the review checklist for third-party skills, plus MCP / A2A references for protocol-connected skills.",
+  "version": "0.8.1",
   "author": {
-    "name": "ssheleg"
+    "name": "ssheleg",
+    "url": "https://x.com/sshlg93"
   },
   "homepage": "https://github.com/ssheleg/make-skill",
   "repository": "https://github.com/ssheleg/make-skill",