Capability

Superpowers — disciplined dev skills

Jesse Vincent's Superpowers plugin — 14 skills that put Claude Code through a real engineering workflow.

#skills#workflow#tdd

Superpowers by Jesse Vincent (obra) is a complete software-development methodology shipped as composable skills for Claude Code. Instead of jumping straight to code, an agent with Superpowers refines requirements, gets a design approved, writes a plan, and builds through disciplined, test-first steps. The skills are mandatory workflows that activate automatically from context — not optional suggestions.

You've already seen these at work

This whole Dev Guide was built with Superpowers — brainstorming, writing-plans, subagent-driven-development, using-git-worktrees, and finishing-a-development-branch all shaped how the work was scoped, executed, and merged.
Brainstormdesign + approval
Worktreeisolated baseline
Planbite-sized, TDD
Buildsubagents · TDD
Reviewagainst the plan
Finishmerge / PR
The core loop. Each stage is its own skill; together they turn a vague idea into reviewed, merged work.

The principles

Test-driven by default

Write the failing test first. Code exists to make a test pass, not the other way around.

Systematic over ad-hoc

Follow the process — brainstorm, plan, execute, review — instead of improvising each step.

Reduce complexity

Smaller, focused units; the simplest thing that works; delete before you add.

Evidence before claims

Never say “done” or “fixed” without running the check and showing the output.

Install

Install from Anthropic's official marketplace, or from obra's own marketplace for the latest:

  1. 1

    From the official marketplace

    bash
    /plugin install superpowers@claude-plugins-official
  2. 2

    …or from obra's marketplace

    bash
    /plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace
  3. 3

    Reload — then it runs itself

    On reload, the using-superpowers skill loads at session start and the rest activate as your task calls for them.

Related repos

superpowers-skills is the community-editable skills library; superpowers-lab holds experimental ones.

How the skills fire

You rarely invoke these by hand. Each skill carries a description of exactly when it applies, and Claude loads it the moment the situation matches — “build a feature” pulls in brainstorming first, a failing test pulls in systematic-debugging, finishing up pulls in verification-before-completion. They are treated as non-negotiable: the discipline is the point.

Auto-activates from contextMandatory, not optionalComposable

All 14 skills

Grouped by role. Each name links to its source. (9 workflow + 3 discipline + 2 meta = 14.)

Workflow & process

The build loop, from idea to merged branch.

SkillWhat it does
brainstormingRefine an idea into a validated design before any code — questions one at a time, 2–3 approaches, a design you approve.
writing-plansTurn a spec into a bite-sized, TDD-structured plan with exact file paths, real code, and verification steps.
executing-plansExecute a written plan in a separate session with batch checkpoints for review.
subagent-driven-developmentExecute a plan in this session by dispatching a fresh subagent per task, each gated by two-stage review (spec, then quality).
dispatching-parallel-agentsRun 2+ independent tasks concurrently when there is no shared state or ordering between them.
using-git-worktreesSet up an isolated workspace (native tool or git worktree) with a clean test baseline before starting.
requesting-code-reviewReview completed work against the plan and requirements before merging; critical issues block progress.
receiving-code-reviewHandle review feedback with rigor — verify before implementing, never agree performatively.
finishing-a-development-branchWhen work is done and tests pass, choose how to integrate: merge, PR, keep, or discard.

Testing & discipline

The habits that keep the work honest.

SkillWhat it does
test-driven-developmentRED → GREEN → REFACTOR: write the failing test first, minimal code to pass, refactor, then commit.
systematic-debuggingInvestigate any bug, test failure, or surprise methodically — reproduce, isolate, root-cause — before proposing a fix.
verification-before-completionBefore claiming done, fixed, or passing, run the checks and confirm the output. Evidence before assertions.

Meta

Skills about the skills.

SkillWhat it does
using-superpowersThe entry skill: how to find and use skills, and to invoke the right one before responding.
writing-skillsCreate, edit, and verify skills — including the trigger descriptions that make them fire.

A run through the workflow

  1. 1

    Shape the idea

    brainstorming turns a request into a design you sign off on — no code until then.
  2. 2

    Isolate the workspace

    using-git-worktrees branches into a clean workspace with a green test baseline.
  3. 3

    Plan in small steps

    writing-plans breaks the work into 2–5 minute, test-first tasks with exact files and commands.
  4. 4

    Build with discipline

    subagent-driven-development (or executing-plans) runs each task, test-driven-development drives the code, and dispatching-parallel-agents parallelizes independent work. systematic-debugging handles anything that breaks.
  5. 5

    Review and verify

    requesting-code-review / receiving-code-review check the work against the plan, and verification-before-completion confirms the tests actually pass before any “done.”
  6. 6

    Finish

    finishing-a-development-branch verifies tests once more and offers merge / PR / keep / discard.

Extend it

When you outgrow the built-ins, writing-skills guides you through authoring your own — including the trigger description that makes Claude reach for it at the right moment.

Learn more