skill-creator: Anthropic's skill for building and testing your own Claude Code skills

skill-creator is the skill in Anthropic's official repository for creating Claude Code skills, testing them and improving them with data instead of gut feeling. You describe a procedure you keep repeating ("quote the orders customers send me on WhatsApp", "review invoices", "prepare Monday's report") and Claude writes the SKILL.md, drafts test prompts, compares results with and without the skill and, finally, rewrites the description so the skill triggers when it should and only then.

In our roundup of Anthropic's 19 official skills we called it the hidden gem of the repo. Here we put it to work on a small-business case: a skill that turns an informal WhatsApp order into a quote with Ecuador's 15% VAT. skill-creator wrote it in 33 seconds for 0.13 USD, the skill passed the test that the no-skill run failed, and along the way we found a bug in its trigger script that can push you to "fix" a skill that already works.

What a skill is and why you should write your own

A skill is a folder with a SKILL.md (name, description and instructions) plus, optionally, scripts, templates or docs. Claude Code only reads each skill's name and description at startup; when a task fits, it loads the rest. If you have never installed one, start with what Claude Code skills are and how to install them.

Other people's skills solve other people's problems. The ones that pay off most are yours: your business's quote format, your commit rules, the steps to publish on your blog. Writing a good skill has two traps you can't see by eye:

1. Does it do what you say? Without a comparison, you don't know whether the skill improves anything or Claude would have done the same without it.
2. Does it trigger? A vague description means Claude never uses it; an overly broad one fires where it shouldn't.

skill-creator tackles both with a method and a set of scripts.

What's inside skill-creator

It lives in skills/skill-creator of anthropics/skills (commit 2c5958e, November 6, 2026) under the Apache-2.0 license: you can use, adapt and redistribute it as long as you keep the license notice. It's 5,654 lines:

You need Python 3 with PyYAML (for quick_validate.py) and the claude CLI: the trigger scripts spawn claude -p as a subprocess, so they only work in Claude Code, not on claude.ai.

Installing skill-creator in Claude Code

With the skills.sh CLI, just this skill:

npx skills add anthropics/skills --skill skill-creator --agent claude-code -y

Or with the example-skills plugin, which ships 12 example skills including skill-creator:

/plugin marketplace add anthropics/skills
/plugin install example-skills@anthropic-agent-skills

We copied skills/skill-creator from the repository into .claude/skills/skill-creator of a test project. Before copying any third-party skill, run it through SkillSpector: this one ships scripts that run claude and write into your project.

The test: a skill that quotes WhatsApp orders

We prepared a precios.csv price list for a coffee shop with 5 products (ground coffee 500 g at 6.50 USD, logo mug at 4.25 USD, French press at 18.90 USD…) and asked Claude Code, on Sonnet 5.5 (prompt translated from Spanish):

Use the skill-creator skill. I want a skill called cotizacion-whatsapp:
when a customer sends me an order on WhatsApp (informal text, with typos),
the skill should turn it into a Markdown quote using the price list in
precios.csv: a table with product, quantity, unit price and line total,
then subtotal, 15% VAT (Ecuador), total, and a line listing the products
it couldn't find. Don't ask me questions: assume what's reasonable and note
your assumptions. Also create evals/evals.json with 3 realistic test prompts.

In 33 seconds and 0.13 USD it had:

• A 54-line SKILL.md with 5 steps (read the CSV every time, extract items, match them against the list, calculate, write), a fixed output format and a worked example.
• Sensible rules we never gave it: understanding "half a dozen" and "a dozen", never substituting a product that doesn't exist ("quoting something the customer didn't ask for is worse than leaving it out"), turning 1 kg into two 500 g bags only when the conversion is exact, and checking the math with Python when there are many items.
• A long, "pushy" description, as the skill itself recommends: besides what it does, it lists user phrases ("quote this", "build the pro forma", "a customer wrote to me") so Claude doesn't under-trigger it.
• An evals.json with 3 misspelled orders and the expected total for each. We checked the math by hand: all 3 were right.

quick_validate.py accepted it on the first try:

python -m scripts.quick_validate path/to/cotizacion-whatsapp
# Skill is valid!

With the skill vs. without it

Comparison is the heart of the method. We ran the second test prompt (a customer asking, with typos, for a French press, 2 packs of paper filters, an Osterizer blender and 1 kg of coffee beans) twice: in a project with the skill and in one without it.

Without the skill, Claude did a decent job but not the one you need: no VAT, and the format changes every time. That's the gap skill-creator makes you look at before calling a skill done. Then we loaded both outputs into the skill's viewer:

python eval-viewer/generate_review.py workspace/iteration-1 \
  --skill-name cotizacion-whatsapp --static review.html

The viewer has two tabs: Outputs, to step through each prompt and write what's wrong, and Benchmark, with pass rate, time and tokens per version. "Submit All Reviews" saves a feedback.json that Claude reads for the next iteration. With --static it writes a standalone HTML file; without it, it starts a local server on port 3117.

Tuning triggering (and the bug we found)

The last phase measures whether the description makes Claude use the skill. You write queries that should trigger it and similar ones that shouldn't (raising prices in the CSV, writing a payment reminder, asking how much VAT you owe), and run_eval.py runs each one with claude -p to see whether Claude calls the skill:

python -m scripts.run_eval --eval-set trigger-evals.json \
  --skill-path path/to/cotizacion-whatsapp \
  --runs-per-query 2 --num-workers 1 --model claude-sonnet-5-5 --verbose

We used 6 queries (3 positive, 3 near-misses), 2 runs each. The result depends on a parameter you wouldn't expect:

Same skill, same description. The cause is how run_eval.py measures: for each query it writes a temporary copy of the skill into .claude/commands/ with a random suffix, and only counts a hit if Claude calls its own copy. In parallel there are several near-identical copies in the same folder at once; Claude picks any of them, and if it picks another process's copy, that's scored as a miss. We confirmed it by hand: with a single copy, Claude called the skill as its first action.

The default is --num-workers 10, and run_loop.py (the loop that rewrites the description) uses the same default. With it, the loop would "improve" a description that already works by chasing misses that don't exist. Use --num-workers 1: it's slower, but it measures for real.

Two more details about the script:

• It writes to the .claude/commands/ of the nearest folder that has a .claude/, starting from the current one. Run it from your real project and the temporary files land there (they're deleted at the end, but can linger if you kill the process).
• If your skill is already installed in that project, Claude may use the installed one instead of the temporary copy, which also counts as a miss. Test triggering in a separate folder.

How much it costs to build a skill with skill-creator

Our whole test, including the reruns to confirm the bug, cost about 1.60 USD. The expensive part is description optimization, and you rarely need the full run.

Our advice to spend as little as possible: use skill-creator for the draft and 2 or 3 test prompts with and without the skill, which is where you learn the most. For triggering, start with 6-10 queries and --runs-per-query 1, run serially; only if they fail, launch run_loop.py with --max-iterations 2. And test with Sonnet or Haiku: triggering depends on the description, not on the most expensive model.

Common mistakes

Claude can't write the skill into .claude/skills/. In non-interactive mode (claude -p), Claude Code protects the .claude/ folder: it refused the write even with --permission-mode acceptEdits and an explicit Write permission on that path. Ask it to write elsewhere (draft/my-skill/) and copy it yourself. In an interactive session it will ask for permission.

The skill works in your tests but doesn't trigger day to day. Your test prompts were too simple. The skill itself explains it: Claude only consults a skill when the task isn't trivial, so "read this PDF" won't trigger it even if the description matches. Write queries with real context: names, quantities, typos, the customer's backstory.

The optimization loop makes the description worse. You're running it in parallel (see above) or with near-misses that are too easy. The useful ones share words with the skill but need something else.

package_skill.py leaves out your tests. That's on purpose: it excludes the evals/ folder at the skill root. Keep it in your repository if you want to rerun the tests.

Writing "ALWAYS" and "NEVER" in caps. skill-creator advises against it: explaining why a rule matters ("a made-up price becomes a promise to the customer") works better than shouting it.

FAQ

Do I need to code to use skill-creator?

Not to create the skill: you describe it in plain language and Claude writes the SKILL.md. It helps for the quantitative tests, which use JSON and Python scripts. The skill tells Claude to match your vocabulary and explain terms like "assertion" if you don't know them.

Does it work on claude.ai or only in Claude Code?

Both, with limits. On claude.ai you can create the skill and test it by hand, but without subagents there's no with/without comparison, and without the claude CLI there's no description optimization. The full method is for Claude Code.

Can I sell skills I build with skill-creator?

The skill you write is yours. skill-creator is Apache-2.0: if you copy its scripts or parts of its text into your skill, keep the license and copyright notice and state what you changed.

Can it improve a skill I already have?

Yes. In that case it compares the new version against a snapshot of the old one instead of "no skill", and it has a blind comparison mode (agents/comparator.md) to pick the better one without knowing which is which.

Which model should I test with?

The one you'll use day to day. We used Sonnet 5.5. The skill recommends passing run_loop.py the same model as your session so the trigger test reflects what you'll actually see.

Conclusion

skill-creator turns "I think this skill works" into a comparison with numbers: what Claude does with the skill, what it does without it, and when it triggers it. For a procedure you repeat every week, the draft plus three tests cost under half a dollar and tell you whether it's worth it. Run it serially, test triggering in a separate folder, and don't pay for the full optimization until a small test fails.

Next step: if your skill will connect Claude to your data, see how to build an MCP server with mcp-builder, and if it generates web pages, how to test them with webapp-testing.