Use when determining what type of Claude Code extension (command, skill, or agent) a prompt or description should be classified as. This skill should be used when users ask "should this be a command, skill, or agent", when designing new extensions, or when there is ambiguity about the correct extension type for a given use case.
/plugin marketplace add mthalman/superpowers/plugin install superpowers@claude-marketplaceThis skill inherits all available tools. When active, it can use any tool Claude has access to.
references/classification-criteria.mdCorrectly classify prompts and descriptions as commands, skills, or agents in Claude Code. Apply systematic criteria to determine the appropriate extension type, asking clarifying questions when needed to resolve ambiguities.
Use this skill when:
Follow this workflow to determine the correct extension type:
Read references/classification-criteria.md to load the detailed characteristics, decision framework, and examples for each extension type.
Examine the user's description or prompt and identify:
Use the decision tree from the classification criteria:
Before finalizing your classification, check if similar functionality already exists:
How to validate:
Why this matters:
Example:
systematic-debugging exists as a Skill in this codebaseRed flag: Your theoretical classification contradicts existing implementation without clear justification
If no similar functionality exists: Proceed with your classification, but note this is a new pattern
If the classification is unclear, identify what additional information would help:
When ambiguous, use the AskUserQuestion tool to gather missing information:
Question patterns:
Example clarification:
User: "Help me write git commit messages"
Ambiguity: Could be a command (explicit /commit) or skill (auto-activates when committing)
Ask: "How should this be triggered?"
- Option 1: "I type /commit when ready" → Command
- Option 2: "Claude detects when I need commits" → Skill
Once determined, provide:
Output format:
Classification: [Command/Skill/Agent]
Reasoning: [Explanation based on invocation, complexity, context, etc.]
Key factors:
- [Factor 1]
- [Factor 2]
- [Factor 3]
[Optional: Alternative considerations or edge cases]
When multiple valid options exist, add trade-offs:
Trade-offs:
| Approach | Pros | Cons | Best When |
|----------|------|------|-----------|
| [Option 1] | [Benefits] | [Costs] | [Context where appropriate] |
| [Option 2] | [Benefits] | [Costs] | [Context where appropriate] |
| [Option 3] | [Benefits] | [Costs] | [Context where appropriate] |
Include implementation guidance:
For Commands:
/commit, /review)For Skills:
For Agents:
For Hybrid (Skill + Command):
skill: [name]-guidance (auto-activates)
├── Triggers: [specific patterns]
├── Behavior: [what it does]
└── References: [/command] for explicit mode
command: [name] (explicit invocation)
├── Use case: [when to invoke]
├── More structured/invasive approach
└── Shares principles with skill
Command vs Skill:
Skill vs Agent:
Multiple classifications:
When choosing between Skill and Agent, the critical question is: Can this work be delegated?
Work that Claude can complete independently and return results:
Characteristics:
Work that requires ongoing human participation:
Characteristics:
Even if expertise is deep, if the human must be involved throughout, it's a Skill, not an Agent.
Example - Test-Driven Development:
TDD requires ongoing collaboration - the developer writes tests, sees them fail, implements code, and refactors with continuous guidance. This iterative, collaborative nature makes it a Skill, despite being a complex methodology.
Example - Security Audit:
| Type | Invocation | Complexity | Context | Structure |
|---|---|---|---|---|
| Command | User types /command | Simple prompt | Shared | Single .md file |
| Skill | Claude auto-detects | Complex workflow | Shared | Directory with SKILL.md + resources |
| Agent | Delegated by Claude | Specialized expertise | Independent | .md with custom prompt + tools |
Detailed documentation including:
Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.