/guides/skills

Skills

Tour the 14 skills that make up Superpowers, organized by category and use case.

Superpowers includes 14 skills organized into four categories: Collaboration, Testing, Debugging, and Meta. Each skill triggers automatically when your agent detects the right conditions—you don’t invoke them manually.

Collaboration skills

These skills handle the software development lifecycle from idea to shipping.

brainstorming

When it triggers: When you start work without an approved design document.

What it does: Uses Socratic questioning to refine rough ideas. Explores alternatives and edge cases. Presents design in digestible chunks for validation. Saves the approved design to a design document.

Why it matters: Prevents the agent from immediately writing code before understanding the problem.

using-git-worktrees

When it triggers: After design approval, before implementation starts.

What it does: Creates an isolated workspace on a new branch. Runs project setup. Verifies clean test baseline.

Why it matters: Keeps experimental work isolated from your main branch.

writing-plans

When it triggers: When you have an approved design and are ready to implement.

What it does: Breaks work into bite-sized tasks (2-5 minutes each). Every task includes exact file paths, complete code, and verification steps.

Why it matters: Creates a clear implementation plan an enthusiastic junior engineer could follow.

subagent-driven-development

When it triggers: When you have a written plan and want to execute.

What it does: Dispatches fresh subagent per task with two-stage review: spec compliance first, then code quality. Critical issues block progress.

Why it matters: Enables autonomous work for hours at a time without deviating from the plan.

executing-plans

When it triggers: When you have a written plan but your platform doesn’t support subagents.

What it does: Batch execution with human checkpoints. Executes tasks sequentially with review points.

Why it matters: Fallback for platforms without subagent support.

requesting-code-review

When it triggers: Between tasks, when completing work.

What it does: Reviews against the original plan. Reports issues by severity. Critical issues block progress.

Why it matters: Catches deviations from the plan before they compound.

receiving-code-review

When it triggers: When you receive feedback on submitted work.

What it does: Provides systematic response to feedback. Uses thread API for inline comments rather than top-level responses.

Why it matters: Keeps review responses organized and actionable.

finishing-a-development-branch

When it triggers: When tasks are complete.

What it does: Verifies tests pass. Presents options: merge, PR, keep, or discard. Cleans up worktree.

Why it matters: Clean finish with proper git hygiene.

dispatching-parallel-agents

When it triggers: When you have 2+ independent tasks without shared state.

What it does: Launches concurrent subagent workflows. Isolates context so subagents don’t inherit parent session history.

Why it matters: Speeds up work that can be parallelized.

Testing skills

test-driven-development

When it triggers: During implementation, before writing feature code.

What it does: Enforces RED-GREEN-REFACTOR: write failing test, watch it fail, write minimal code, watch it pass, commit. Includes testing anti-patterns reference. Deletes code written before tests.

Why it matters: True TDD with evidence at every step.

verification-before-completion

When it triggers: Before declaring a fix complete.

What it does: Ensures the fix actually works. Requires evidence, not just claims.

Why it matters: Prevents “I think this is fixed” without verification.

Debugging skills

systematic-debugging

When it triggers: When encountering bugs before proposing fixes.

What it does: 4-phase root cause process: observe, hypothesize, test, conclude. Includes root-cause-tracing, defense-in-depth, and condition-based-waiting techniques.

Why it matters: Process over guessing. Evidence over claims.

Meta skills

using-superpowers

When it triggers: On first use or when the user asks about the system.

What it does: Introduction to the skills system. Explains how automatic triggering works.

Why it matters: Onboarding for new users.

writing-skills

When it triggers: When you want to create or modify skills.

What it does: Best practices for skill creation. Testing methodology for skills. Cross-platform compatibility guidelines.

Why it matters: Maintains quality when extending the system.

How skills trigger

You don’t manually invoke skills with commands. Instead:

  1. The agent analyzes the current state (what you’re doing, what’s in context)
  2. Skills declare their trigger conditions in their frontmatter
  3. When conditions match, the skill’s instructions are injected into the agent’s context
  4. The agent follows the skill’s workflow automatically

This is the core innovation: mandatory workflows, not suggestions. The agent checks for relevant skills before any task and follows them.

Learn more