Skill Creator

Caution

Auto-activation is best-effort, never guaranteed — Claude Code publishes no activation rate. Trigger keywords, description format, and invocation type (user vs. LLM) determine whether Claude ever picks up the skill; /skill-name is the only lever a user controls directly. A wrong description silently kills auto-activation — and the bug is invisible until you test it.

Tip

Skill Creator encodes every best practice from Anthropic’s official skill docs. It picks the right context mode, writes an activation-optimized description, validates structure, and generates test prompts — so you don’t have to read 1200 lines of agent instructions yourself.

Quick reference

FieldValue
Trigger”create skill”, “improve skill”, “fix activation”
Modelinherit — runs on the session’s model
ToolsRead, Write, Edit, Glob, Grep, Bash, Agent

Scope guard

Skill Creator sizes the task before starting. One bounded unit = one deliverable, roughly 5 files, roughly 10 steps.

SituationWhat the agent does
Brief fits one bounded unitStarts immediately
Brief exceeds ~5 files / ~10 steps, or bundles several independent deliverablesStops before starting, returns a split proposal: 2-N bounded subtasks, each with scope and a suggested owner
Scope grows mid-flightStops at the next clean boundary, reports done / remaining / how to split
Brief is missing GOAL, SCOPE, CONTEXT, CONSUMER or acceptanceStates the assumption explicitly in the report, or asks once — never invents scope

“Build me a plugin with five skills” gets a split proposal — one skill per subtask. One skill, with its references and scripts, is a bounded unit.

Tip

Got a split proposal instead of a SKILL.md? That is the guard working. Pick one skill from the proposal and re-send it, or spawn the subtasks as parallel agents in a single message.

When to use

  • You want a new Claude Code skill and need correct SKILL.md structure from the start
  • An existing skill isn’t auto-invoking and you need description optimization
  • You want to capture a workflow from the current conversation into a reusable skill
  • You need to choose the right context mode (fork vs inline) or invocation type for a new skill
  • A skill’s bash blocks aren’t executing — missing EXECUTE keyword or $ARGUMENTS in bash context

Examples

"Create a skill for database migrations"
"Claude isn't picking up my skill automatically"
"Turn what we just did into a skill"
"My /deploy skill isn't reliable — fix the description"
"new skill: scan for leaked secrets in git history"

Flow

  1. Understand the request

    If the current conversation contains a workflow the user wants to capture, the agent extracts it from history first — tools used, steps taken, input/output formats, edge cases encountered. It cannot ask the user anything — AskUserQuestion is removed from every subagent in CC 2.1.233. A missing purpose, invocation type, or trigger phrase gets the safest reading, stated explicitly in the report, with the open question handed back to the caller unanswered.

  2. Pick context mode and invocation type

    Critical operations (deploy, commit) get disable-model-invocation: true + slash-only. Background knowledge gets user-invocable: false. Standalone tasks with fewer than 4 phases get context: fork. Multi-phase orchestration stays inline. Model choice follows complexity: opus for orchestration, sonnet for analysis, haiku for simple helpers.

  3. Write SKILL.md with activation-optimized description

    Description follows the template: action verb sentence + explicit Triggers: “phrase1”, “phrase2” on a single line under 250 chars. Third-person, no colons (YAML breaks silently). For user-only skills, a plain one-liner is enough — trigger keywords are wasted tokens when LLM never auto-invokes.

  4. Validate structure and run tests

    Runs validate-skill.sh from the brewcode plugin. Checks: valid YAML frontmatter, name ≤ 64 chars, bare with no plugin: prefix and matching the directory name, description ≤ 250 chars single-line, body under 500 lines, bash blocks have EXECUTE keyword, no hardcoded secrets. Then spawns 3–5 realistic test prompts to verify activation and output quality.

  5. Generate README and iterate

    Fills the standard README template with actual examples, then runs brewtools:text-optimize on the SKILL.md. If test runs reveal a repeated helper pattern, bundles it into scripts/ so every future invocation skips the boilerplate.

Full workflow internals — phase breakdown, frontmatter reference, patterns

Activation reliability by configuration

Claude Code publishes no activation percentage — rank the methods, don’t quote a rate.

ConfigurationReliability
Basic description, no triggersLowest
Optimized description + Triggers: lineHigher
/skill-name explicit slash commandHighest — the only lever the user controls directly
disable-model-invocation: true (user-only)n/a — LLM never invoked

Context reattachment after compaction: skills reattach under a bounded budget — 5K tokens per skill, 25K combined — not an unbounded-loss bug. If a skill still gets evicted under load, re-invoke /skill-name.

Invocation type decision

Who invokesConfigurationDescription style
User only (slash command)disable-model-invocation: trueSimple one-liner, no triggers needed
LLM only (background)user-invocable: falseFull triggers for auto-activation
Both (default)(no flags)Full triggers for auto-activation

Rule: If failure is unacceptable (deploy, send-email, delete data) → disable-model-invocation: true + slash command only.

Skill anatomy

skill-name/
├── SKILL.md         # frontmatter + instructions (required)
├── references/      # detailed docs, loaded on demand
├── examples/        # working code examples
├── scripts/         # executable utilities
├── assets/          # templates, images
└── agents/          # subagent prompts (convention, NOT auto-discovered)

Key design patterns

PatternWhen to use
Progressive DisclosureAlways — L1 name+desc in context, L2 SKILL.md on trigger, L3 references on demand
Reference Splitting2+ modes, >50 lines/mode, >300 lines total — detect mode → load only matching references/{mode}.md
Agents-as-ReferencesOrchestrator with multi-step workflow — pass file path to subagent, subagent reads itself. 0 tokens in orchestrator context
Context ForkStandalone task, no history needed, <4 phases — context: fork + isolated subagent
Executable Bash**EXECUTE** using Bash tool: keyword + && echo "✅" || echo "❌" + > STOP if ❌
Pushy DescriptionLLM-invocable skills — action verb + Triggers: "exact user phrases". Raises rate 20% → 50-72%

Description format

# LLM-invocable — action verb + Triggers on single line ≤250 chars
description: "Creates conventional git commits with proper format. Triggers: commit, git commit, save changes."

# User-only — simple one-liner, no triggers needed
description: "Deploy application to production environment."

Common mistakes: multiline | (truncated at 250 chars since v2.1.84), missing Triggers: (stays at 20%), starts with “Use this skill when” (should start with action verb), colon in description (YAML parse failure), setting permissionMode: bypassPermissions on production skills — this is equivalent to --dangerously-skip-permissions and skips all safety prompts. Only appropriate in sandboxed CI; never the right default for local skills.

Frontmatter quick reference

FieldLimitsNotes
name≤64 chars, bare lowercase-hyphens, must equal directory nameNo plugin: prefix — Claude Code adds the plugin name itself; a baked prefix renders /brewcode:brewcode:e2e. Directory name used if omitted
description≤250 chars, single line, always quotedALWAYS in double quotes — em dashes, colons break YAML silently
disable-model-invocationtrue/falsetrue = 100% reliable, slash-only
user-invocabletrue/falsefalse = hide from menu, Claude-only
contextforkIsolated subagent, fresh context
agentExplore, Plan, general-purpose, or a project agentWith context: fork
modelopus, sonnet, haiku, claude-fable-5Based on complexity; Fable 5 (Mythos-class) available since CC 2.1.170 — above Opus tier
effortlow, medium, high, max, autov2.1.80+
allowed-toolstool listMinimal set
disallowed-toolstool listRemoves tools while the skill is active (CC 2.1.152)
argument-hintstringAutocomplete hint
oncetrue/falseFire once per session

$ARGUMENTS in bash blocks

$ARGUMENTS inside ```bash ``` blocks is a shell variable (empty/undefined), NOT Claude Code substitution. Claude Code replaces $ARGUMENTS only in markdown text.

# WRONG
` ```bash
bash script.sh "$ARGUMENTS"
` ```

# CORRECT — $ARGUMENTS in text, placeholder in bash
**Skill arguments received:** `$ARGUMENTS`
**EXECUTE** using Bash tool:
` ```bash
bash script.sh "ARGS_HERE"
` ```
Replace ARGS_HERE with the actual value from above.

Context fork memory behavior

ModePhasesBehavior
Inline (default)AnyFull conversation access
context: fork1–4Works well, context isolated
context: fork5+Memory loss — forgets task structure, skips phases

Additional skill facts (CC 2.1.142+)

Root-level SKILL.md: a plugin with a SKILL.md at the plugin root (no skills/ subdirectory) is surfaced as a skill automatically since CC 2.1.142. Useful for single-skill plugins.

/reload-skills re-scans skill directories without restarting the session (CC 2.1.152). Use this after editing or adding a SKILL.md — no session restart needed.

Known bugs

IssueImpactWorkaround
#22345Plugin skills ignore disable-model-invocationCopy skill to .claude/skills/
#17688Skill-scoped hooks don’t fire in pluginsUse plugin hooks.json
#17417skill.md (lowercase) silently ignoredUse SKILL.md (uppercase)
#10768 / #15136Auto-activation unreliable, sometimes skipped despite instructions (both closed NOT PLANNED)Optimize description or use /name

Subagent spawn constraint

CC allows nested subagent spawning, but prefer spawning from the main conversation so the orchestrator can integrate each agent’s result directly. Brewcode agents are stateless and resolve plugin paths via ${CLAUDE_PLUGIN_ROOT}.

Return Contract

Verdict first, <=30 lines, path:line. No SKILL.md body, no reference contents, no validator transcripts, no eval logs, no preamble. Returns: skill dir path, one line per artifact written (SKILL.md, each references/*, scripts, tests, README), validate-skill.sh verdict (pass, or the failing check), Quick Eval result (triggered / missed, N of M), and whether text-optimizer ran. Eval transcripts, full validator output, and draft bodies go to .claude/reports/<YYYYMMDD-HHMMSS>_skill-creator/, path only.

/brewtools:agent-return-setup enforces this at ~1000 / ~2500 est-tokens when installed; the contract itself ships unconditionally.

🤖

Agent Creator

Same workflow for creating agents instead of skills.

🔗

GitHub source

Full agent instructions — frontmatter reference, patterns, known bugs.

🚀

Brewcode overview

All brewcode agents, skills, and hooks in one place.

Updating plugins

Use /brewtools:plugin-update to check and update the brewcode plugin suite in one command. See the FAQ for details.