architecture/commands/create-capability.md

description, argument-hint

description	argument-hint
Create a new capability (skill, command, agent, or a cohesive set) for the architecture repository.	<description>

Create Capability

@~/.claude/skills/capability-writing/SKILL.md

Create new capabilities following established patterns. A capability may be a single component or a cohesive set (skill + command + agent).

Process

1. Understand the capability: Analyze "$1" to understand what the user wants to build

   • What domain or workflow does this cover?
   • What user need does it address?
   • What existing capabilities might overlap?

2. Determine components needed: Based on the description, recommend which components:

   Pattern	When to Use
   Skill only	Knowledge to apply automatically (reused across commands)
   Command only	User-invoked workflow using existing skills
   Command + Skill	New knowledge + workflow to use it
   Command + Agent	Workflow with isolated worker for complex subtasks
   Full set	New domain expertise + workflow + isolated work

   Present recommendation with reasoning:

   ## Recommended Components for: $1
   
   Based on your description, I recommend:
   - **Skill**: `name` - [why this knowledge is needed]
   - **Command**: `/name` - [what user action this enables]
   - **Agent**: `name` - [why isolation/specialization is needed] (optional)
   
   Reasoning: [explain why this combination fits the need]
   

3. Gather information: For each recommended component, ask:

   For all components:

   • Name (kebab-case, descriptive)
   • Description (one-line summary)

   For Skills:

   • What domain/knowledge does this cover?
   • What are the key concepts to teach?
   • What patterns or templates should it include?

   For Commands:

   • What triggers this workflow?
   • What are the key steps?
   • What approval points are needed?
   • What skills should it reference?

   For Agents:

   • What specialized role does this fill?
   • What skills does it need?
   • Should it be read-only (no Edit/Write)?

4. Select appropriate models:

   Model	Use For
   haiku	Simple fetch/display commands, formatting tasks
   sonnet	Most commands and agents (default)
   opus	Deep reasoning, architectural analysis, complex judgment

   For each component, recommend a model with reasoning.

5. Generate files: Create content using templates from capability-writing skill

   Ensure proper inter-references:

   • Command references skill via @~/.claude/skills/name/SKILL.md
   • Agent lists skills in skills: frontmatter (names only, not paths)
   • Command spawns agent via Task tool if agent is part of the set

6. Present for approval: Show all generated files with their full content:

   ## Generated Files
   
   ### skills/name/SKILL.md
   [full content]
   
   ### commands/name.md
   [full content]
   
   ### agents/name/AGENT.md (if applicable)
   [full content]
   
   Ready to create these files?
   

7. Create files in correct locations after approval:

   • skills/<name>/SKILL.md
   • commands/<name>.md
   • agents/<name>/AGENT.md

8. Report success:

   ## Capability Created: name
   
   Files created:
   - skills/name/SKILL.md
   - commands/name.md
   - agents/name/AGENT.md (if applicable)
   
   Next steps:
   1. Run `make install` to symlink to ~/.claude/
   2. Test with: /name (for commands)
   3. Skills will auto-activate based on context
   

Guidelines

• Follow all conventions from capability-writing skill
• Reference existing skills rather than duplicating knowledge
• Keep components focused - split if scope is too broad
• Commands should have approval checkpoints before significant actions
• Default to sonnet model unless there's a clear reason for haiku/opus
• Skills should have descriptive description fields for auto-activation