From skill-creator
Common patterns and architectures for building Claude Code skills. Use when deciding how to structure a skill, choosing between skill patterns, designing multi-step workflows, or when the user asks "what kind of skill should I build" or "how should I structure this skill".
How this skill is triggered — by the user, by Claude, or both
Slash command
/skill-creator:skill-creator-patternsThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Choose the pattern that best fits your skill's purpose. Most skills use one primary pattern, sometimes combining elements from others.
Choose the pattern that best fits your skill's purpose. Most skills use one primary pattern, sometimes combining elements from others.
Use when: Users need multi-step processes executed in a specific order.
Key techniques:
Structure:
## Workflow: [Name]
### Step 1: [Action]
[What to do]
Expected output: [What success looks like]
### Step 2: [Action]
Requires: Output from Step 1
[What to do]
### Step 3: [Action]
[What to do]
## Rollback
If Step 2 fails:
1. [Undo Step 1]
2. [Report error]
Real-world examples: deployment pipelines, onboarding workflows, data migration scripts, release processes.
Use when: Claude needs domain expertise to apply during regular work.
Key techniques:
Structure:
# [Domain] Reference
## Core Principles
1. [Most important rule]
2. [Second rule]
3. [Third rule]
## Decision Guide
| Situation | Approach | Why |
|-----------|----------|-----|
| [Case A] | [Do X] | [Reason] |
| [Case B] | [Do Y] | [Reason] |
## Patterns
### [Pattern Name]
When to use: [condition]
[Code example]
## Anti-Patterns
### [Bad Pattern]
WRONG:
[code]
CORRECT:
[code]
Why: [explanation]
Real-world examples: coding conventions, API design guides, testing standards, architectural patterns.
Use when: Output quality improves with multiple passes.
Key techniques:
Structure:
## Phase 1: Initial Draft
1. [Generate first version]
2. [Save to file]
## Phase 2: Quality Check
Review against these criteria:
- [ ] [Quality criterion 1]
- [ ] [Quality criterion 2]
- [ ] [Quality criterion 3]
## Phase 3: Refinement
For each failing criterion:
1. Identify the specific issue
2. Fix it
3. Re-check
Repeat until all criteria pass or 3 iterations completed.
## Phase 4: Finalization
1. Apply final formatting
2. Generate summary of changes
Real-world examples: code review, report generation, documentation writing, test coverage improvement.
Use when: The same goal requires different approaches depending on context.
Key techniques:
Structure:
## Decision Tree
### Check 1: [Condition]
- If [A]: proceed to Path A
- If [B]: proceed to Path B
- Otherwise: proceed to Default Path
### Path A: [Name]
[Specific instructions for this case]
### Path B: [Name]
[Specific instructions for this case]
### Default Path
[Safe fallback instructions]
## Reporting
Always explain which path was chosen and why.
Real-world examples: file storage routing, environment-specific deployment, language-specific code generation.
Use when: Workflows span multiple tools or MCP servers.
Key techniques:
Structure:
## Phase 1: [Service A]
1. [Action using Service A tools]
2. Capture: [output to pass forward]
## Phase 2: [Service B]
Input: [data from Phase 1]
1. [Action using Service B tools]
2. Capture: [output to pass forward]
## Phase 3: [Service C]
Input: [data from Phase 2]
1. [Action using Service C tools]
## Error Handling
- Phase 1 failure: [recovery steps]
- Phase 2 failure: [recovery steps]
- Phase 3 failure: [recovery steps]
Real-world examples: design-to-development handoff (Figma + Drive + Linear + Slack), CI/CD pipeline orchestration, cross-platform content publishing.
Use when: Heavy exploration that should not pollute the main conversation context.
Key techniques:
context: fork in frontmatteragent: Explore for read-only researchStructure:
---
name: deep-research
context: fork
agent: Explore
---
Research $ARGUMENTS thoroughly:
1. Find relevant files using Glob and Grep
2. Read and analyze the code
3. Identify patterns and relationships
4. Summarize findings with specific file:line references
Real-world examples: codebase exploration, dependency analysis, architecture review, security audit.
| Your skill needs to... | Best pattern |
|---|---|
| Execute steps in order | Sequential Workflow |
| Teach Claude domain knowledge | Reference Knowledge |
| Produce high-quality output | Iterative Refinement |
| Adapt to different inputs | Context-Aware Routing |
| Coordinate multiple tools/services | Multi-Tool Coordination |
| Explore without polluting context | Forked Research |
Many skills combine patterns. A deployment skill might use Sequential Workflow as the primary pattern with Context-Aware Routing to handle different environments, and Iterative Refinement for the validation step.
| Skill Size | Lines in SKILL.md | Supporting Files | Use Case |
|---|---|---|---|
| Small | < 100 | None | Single concept, simple reference |
| Medium | 100-300 | 0-2 | Workflow, moderate reference |
| Large | 300-500 | 2-5 | Complex workflow, extensive reference |
If SKILL.md exceeds 500 lines, split content into supporting files. Keep SKILL.md focused on core instructions and navigation.
npx claudepluginhub ilyagulya/claude-marketplace --plugin skill-creatorGuides designing Claude Code skills with multi-step phases, decision trees, subagent delegation, progressive disclosure. For sequential pipelines, routing, safety gates, task tracking, or refactoring workflows.
Guides designing workflow-based Claude Code skills with numbered phases, decision trees, subagent delegation, and progressive disclosure. For sequential pipelines, routing patterns, safety gates, task tracking, phased execution, or refactoring skills.
Plans architecture for new Claude Code skills via domain discovery, use case decomposition, complexity tier assessment, sub-skill breakdown, and file structure design.