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