Use when deciding how to structure a new skill — whether to use checklists, supporting files, rigid enforcement, etc.
How this skill is triggered — by the user, by Claude, or both
Slash command
/skill-factory-toolkit:sft-skill-comparison-matrixThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Machine-readable reference comparing all 14 superpowers skills (v5.0.6) by structure, enforcement, and design choices. Use this to pick the best structural template for a new skill.
Machine-readable reference comparing all 14 superpowers skills (v5.0.6) by structure, enforcement, and design choices. Use this to pick the best structural template for a new skill.
| Skill | Type | Flow | Enforcement | Supporting Files | Word Count | Dispatches To | CSO Strategy |
|---|---|---|---|---|---|---|---|
| brainstorming | technique | checklist | flexible | 7 (visual companion, scripts, reviewer prompt) | ~1550 | writing-plans | symptoms |
| dispatching-parallel-agents | technique | freeform | flexible | 0 | ~920 | none | symptoms |
| executing-plans | technique | checklist | flexible | 0 | ~360 | finishing-a-development-branch, using-git-worktrees, subagent-driven-development | tools |
| finishing-a-development-branch | technique | checklist | rigid | 0 | ~680 | none (called by others) | symptoms |
| receiving-code-review | discipline | checklist | rigid | 0 | ~930 | none | symptoms |
| requesting-code-review | technique | checklist | flexible | 1 (code-reviewer.md template) | ~400 | code-reviewer subagent | tools |
| subagent-driven-development | technique | hybrid | rigid | 3 (implementer, spec-reviewer, code-quality-reviewer prompts) | ~1530 | finishing-a-development-branch, requesting-code-review, test-driven-development, using-git-worktrees | mixed |
| systematic-debugging | discipline | checklist | rigid | 10 (techniques, tests, scripts) | ~1500 | test-driven-development, verification-before-completion | symptoms |
| test-driven-development | discipline | checklist | rigid | 1 (testing-anti-patterns.md) | ~1500 | none | symptoms |
| using-git-worktrees | technique | checklist | flexible | 0 | ~780 | finishing-a-development-branch | tools |
| using-superpowers | meta | hybrid | rigid | 2 (codex-tools.md, gemini-tools.md) | ~760 | any skill (dispatcher) | mixed |
| verification-before-completion | discipline | checklist | rigid | 0 | ~670 | none | symptoms |
| writing-plans | technique | checklist | flexible | 1 (plan-document-reviewer-prompt.md) | ~910 | subagent-driven-development, executing-plans | tools |
| writing-skills | meta | hybrid | rigid | 6 (testing guide, best practices, persuasion, graphviz, examples, renderer) | ~3210 | test-driven-development | mixed |
| Column | Values | Meaning |
|---|---|---|
| Type | discipline / technique / reference / meta | What category of skill |
| Flow | checklist / freeform / hybrid | How steps are organized |
| Enforcement | rigid / flexible | Must follow exactly vs. adapt to context |
| Supporting Files | count (purpose) | Files beyond SKILL.md |
| Word Count | approximate | Size of SKILL.md only |
| Dispatches To | skill names or "none" | Skills explicitly invoked during execution |
| CSO Strategy | symptoms / tools / error messages / mixed | What keywords the description targets |
Given characteristics of a new skill, pick the closest existing template:
| If your skill... | Model after | Why |
|---|---|---|
| Enforces a process discipline (rules that must not be broken) | test-driven-development | Iron Law + rationalizations table + red flags + verification checklist |
| Guides a creative or exploratory process | brainstorming | Checklist with flexibility, visual companion pattern, user-gated progression |
| Is a reference that Claude looks up (tables, lookup data) | sft-cross-cutting-patterns | Tables as primary format, minimal prose, scan-optimized |
| Dispatches subagents to do work | subagent-driven-development | Prompt templates as supporting files, status handling, review loops |
| Is a meta-skill about skills or tool usage | writing-skills | Self-referential structure, TDD mapping, skill type taxonomy |
| Coordinates a multi-step workflow | executing-plans | Lightweight checklist, integration section, calls other skills |
| Provides a behavioral protocol (how to respond) | receiving-code-review | Response pattern pseudocode, forbidden responses, source-specific handling |
| Offers a diagnostic methodology | systematic-debugging | Phased investigation, supporting technique files, escalation rules |
| Is a lightweight utility process | using-git-worktrees | Priority-ordered decision, safety checks, quick reference table |
digraph skill_type {
rankdir=TB
node [shape=box, style=rounded]
start [label="New skill idea"]
q_failure [label="Does it guard against\na specific failure mode?"]
q_process [label="Is it a repeatable\nstep-by-step process?"]
q_lookup [label="Is the primary content\nlookup/reference data?"]
q_meta [label="Is it about skills,\ntools, or Claude itself?"]
discipline [label="Discipline", shape=doubleoctagon]
technique [label="Technique", shape=doubleoctagon]
reference [label="Reference", shape=doubleoctagon]
meta [label="Meta", shape=doubleoctagon]
start -> q_failure
q_failure -> discipline [label="Yes"]
q_failure -> q_process [label="No"]
q_process -> technique [label="Yes"]
q_process -> q_lookup [label="No"]
q_lookup -> reference [label="Yes"]
q_lookup -> q_meta [label="No"]
q_meta -> meta [label="Yes"]
q_meta -> technique [label="No\n(default)"]
}
Always have:
NO X WITHOUT Y in code block)| Excuse | Reality |)Usually have:
Skills: test-driven-development, systematic-debugging, verification-before-completion, receiving-code-review
Always have:
Usually have:
Skills: brainstorming, dispatching-parallel-agents, executing-plans, finishing-a-development-branch, requesting-code-review, subagent-driven-development, using-git-worktrees, writing-plans
Always have:
Usually have:
Skills: sft-cross-cutting-patterns, sft-skill-comparison-matrix (this skill)
Always have:
Usually have:
Skills: using-superpowers, writing-skills
Does your skill need supporting files?
1. All content < 100 lines?
YES -> Inline everything. No supporting files. (9 of 14 skills do this)
2. Reusable prompt templates for subagents?
YES -> Separate .md files (see subagent-driven-development: 3 prompt files)
3. Heavy reference material (500+ lines)?
YES -> Separate reference files (see writing-skills: 6 files)
4. Interactive tools (scripts, HTML)?
YES -> Separate scripts/ directory (see brainstorming: scripts/)
5. Test scenarios for skill validation?
YES -> Separate test-*.md files (see systematic-debugging: 3 test files)
6. Self-contained subsystem (server, templates, multiple coordinated files)?
YES -> Separate directory (see brainstorming: scripts/)
| Complexity | Word Count | Example |
|---|---|---|
| Minimal (lightweight utility) | 300-400 | executing-plans |
| Standard (single technique) | 600-950 | finishing-a-development-branch, dispatching-parallel-agents, writing-plans |
| Complex (discipline with checklists) | 1400-1600 | test-driven-development, systematic-debugging, brainstorming |
| Comprehensive (meta with taxonomy) | 3000+ | writing-skills |
Rule of thumb: Discipline skills run 2-3x longer than technique skills due to rationalization tables and enforcement language.
Skills that dispatch others (orchestrators):
brainstorming -> writing-planswriting-plans -> subagent-driven-development or executing-plansexecuting-plans -> finishing-a-development-branchsubagent-driven-development -> finishing-a-development-branch, requesting-code-review, test-driven-developmentusing-superpowers -> any skill (meta-dispatcher)Skills that are dispatched (leaves):
test-driven-development (called by subagents)verification-before-completion (called during finishing)using-git-worktrees (called before execution starts)finishing-a-development-branch (called after execution completes)Standalone skills (neither dispatch nor are dispatched as part of a chain):
dispatching-parallel-agentsreceiving-code-reviewnpx claudepluginhub steltz/skill-factory --plugin skill-factory-toolkitGuides users through designing a new PM skill via conversation, from raw idea to compliant SKILL.md draft. Use when you have content or a concept and need help shaping it into the right structure.
Guides designing tightly focused, composable skills as mental models, principles, techniques, and processes at various abstraction levels for dynamic integration like a knowledge graph.
Provides structure templates for four skill archetypes: CLI reference, methodology, safety/security, and orchestration. Use when creating new Claude Code skills.