Skill Tracer
Skills › Superpowers

Superpowers

Jesse Vincent · 15 skills · MIT · obra/superpowers

Superpowers is a software development method for coding agents. It is a set of composable skills (brainstorming, planning, TDD, debugging, subagent execution, code review, branch finishing) plus a bootstrap skill that makes the agent check for and use them before acting. It is for developers who run agents in Claude Code, Codex, Cursor, Gemini and other harnesses.

Why read it

  • The writing-skills skill shows how to test a skill the way you test code: run a pressure scenario without the skill, record the agent's rationalizations word for word, then write guidance against them, and micro-test the wording against a no-guidance control.
  • The execution skills show how to keep a long autonomous run on track and recoverable: a ledger file that survives compaction, helper scripts for task briefs and review packages, and a short, fixed list of conditions that allow stopping.

How it does it the main ones a model picked out and a program checked, not every technique

Rationalization tables that pre-empt excuses

Nearly every skill ends with an Excuse/Reality table built from things agents were seen telling themselves. Each tempting shortcut gets a short rebuttal. Because the excuse is named ahead of time, the agent can spot the thought in itself as a warning sign. The tables don't need to restate the rule.

Match the guidance form to the failure type

writing-skills sorts failures into types and gives each a matching form. Rule violations get prohibitions plus red flags. Output with the wrong shape gets a positive recipe. A missing element gets a required slot in the template. It reports that prohibitions made shaping problems worse in wording tests, and it warns against nuance clauses, which reopen the rule for negotiation.

Descriptions state triggers, not workflow

Skill descriptions start with "Use when..." and list only the conditions that should trigger the skill. The stated reason is that an agent that reads a summary of the workflow will follow the summary and skip the skill body.

Ledger as memory that survives compaction

The execution skills keep progress in a git-ignored ledger file. Its first line names the plan it belongs to, and each task gets one completion line. After compaction the agent is told to trust the ledger and git log over its own memory. This prevents a costly failure the skill says it saw in real sessions: re-running work that was already finished.

Rulings with stated cost instead of stalling

When the agent hits a conflict or ambiguity, it decides and keeps going. It records each decision in a fixed format that includes the reason and the cost if wrong, and lists every ruling in its final message. The human keeps visibility without being interrupted.

Context-budget discipline for dispatches

Subagents get a task brief extracted to a file and hand their full reports back as files. Pasting session history into dispatches is forbidden, backed by a measured example. The skill also says to set the model explicitly for each role, because an omitted model quietly inherits the most expensive one.

Iron laws and hard gates in code blocks

The core non-negotiable rule is set apart in a fenced block or HARD-GATE tag, along with a line saying that breaking the letter is breaking the spirit. The gate spells out what counts as "building" and names its only exceptions, which leaves little room for reinterpretation.

Evidence requirements per claim type

verification-before-completion pairs each kind of claim with the evidence it needs and the evidence that isn't enough. One example: an agent reporting "success" is not proof; the VCS diff is. diagnosing-superpowers applies the same idea by requiring a path:line citation for every finding.

The skills, in the order they're used 15 skills

Always onLoaded by a hook
Other ways inStart on their own and lead somewhere
Stand aloneCall or hand off to no other skill

How they connect

A model read each skill to find these. Top to bottom is the usual order. Select a box to read the skill, or a line to see the text behind it.

hands offcallsrequiresalternative
brainstorming mentions: executing-plansbrainstorming mentions: requesting-code-reviewexecuting-plans mentions: using-superpowers (when the harness has no subagent tool)finishing-a-development-branch mentions: using-git-worktreesrequesting-code-review mentions: subagent-driven-developmenttest-driven-development mentions: writing-skillsusing-git-worktrees mentions: executing-plans (when about to execute an implementation plan)using-git-worktrees mentions: finishing-a-development-branch (detached HEAD worktrees)using-git-worktrees mentions: subagent-driven-development (when about to execute an implementation plan)using-superpowers mentions: finishing-a-development-branchusing-superpowers mentions: requesting-code-reviewusing-superpowers mentions: test-driven-developmentusing-superpowers mentions: using-git-worktreesverification-before-completion mentions: test-driven-developmentwriting-plans mentions: test-driven-developmentwriting-skills mentions: subagent-driven-developmentwriting-skills mentions: systematic-debuggingwriting-skills mentions: using-superpowers (on Codex, Copilot CLI or Gemini CLI runtimes)writing-skills mentions: verification-before-completionbrainstorming hands off: writing-plans (after the design doc is approved)executing-plans hands off: finishing-a-development-branchexecuting-plans calls: requesting-code-review (at the final whole-branch review)executing-plans calls: systematic-debugging (when the code is wrong)executing-plans calls: using-git-worktrees (at setup, for an isolated workspace)executing-plans requires: test-driven-developmentexecuting-plans requires: verification-before-completion (before claiming a task complete)executing-plans requires: writing-plans (when the plan came from it)executing-plans and subagent-driven-development are alternativessubagent-driven-development hands off: finishing-a-development-branchsubagent-driven-development calls: requesting-code-review (at the final whole-branch review)subagent-driven-development calls: test-driven-development (when the task specifies TDD)subagent-driven-development requires: using-git-worktrees (before implementation begins)subagent-driven-development alternative: brainstorming (no plan or tightly coupled tasks)systematic-debugging calls: test-driven-development (in Phase 4, when creating a failing test case)systematic-debugging calls: verification-before-completion (in Phase 4, before claiming the fix worked)using-git-worktrees hands off: test-driven-development (after the baseline is clean)using-superpowers calls: subagent-driven-development (only when the human partner asks for cheaper orchestration, and only for a whole plan)using-superpowers requires: brainstorming (before entering plan mode)using-superpowers requires: systematic-debugging (when the request is a bug fix)writing-plans hands off: executing-plans (if Native chosen)writing-plans hands off: subagent-driven-development (if Subagent-driven chosen)writing-plans requires: brainstorming (if the spec covers multiple independent subsystems)writing-plans requires: using-git-worktrees (if working in an isolated worktree)writing-skills requires: test-driven-developmentbrainstorming: You or the agentbrainstormingYou or the agentexecuting-plans: You or the agentexecuting-plansYou or the agentfinishing-a-development-branch: You or the agentfinishing-a-development-branchYou or the agentrequesting-code-review: You or the agentrequesting-code-reviewYou or the agentsubagent-driven-development: You or the agentsubagent-driven-developmentYou or the agentsystematic-debugging: You or the agentsystematic-debuggingYou or the agenttest-driven-development: You or the agenttest-driven-developmentYou or the agentusing-git-worktrees: You or the agentusing-git-worktreesYou or the agentusing-superpowers: Automaticusing-superpowersAutomaticverification-before-completion: You or the agentverification-before-completionYou or the agentwriting-plans: You or the agentwriting-plansYou or the agentwriting-skills: You or the agentwriting-skillsYou or the agent
No calls or hand-offs (3) Close

diagnosing-superpowers, dispatching-parallel-agents, receiving-code-review

All skills 15

Every one is a skill.

SKILLSTARTED BYDESCRIPTIONLINKS
brainstormingYou or the agent
You MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).
3
diagnosing-superpowersYou or the agent
Use when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.
0
dispatching-parallel-agentsYou or the agent
Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
0
executing-plansYou or the agent
Use when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available
9
finishing-a-development-branchYou or the agent
Use when implementation is complete, all tests pass, and you need to decide how to integrate the work
1
receiving-code-reviewYou or the agent
Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation
0
requesting-code-reviewYou or the agent
Use when completing tasks, implementing major features, or before merging to verify work meets requirements
1
subagent-driven-developmentYou or the agent
Use when executing implementation plans with independent tasks in the current session
6
systematic-debuggingYou or the agent
Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes
2
test-driven-developmentYou or the agent
Use when implementing any feature or bugfix, before writing implementation code
1
using-git-worktreesYou or the agent
Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback
4
using-superpowersAutomatic
Use when starting any conversation - establishes how to find and use skills, requiring skill invocation before ANY response including clarifying questions
8
verification-before-completionYou or the agent
Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always
1
writing-plansYou or the agent
Use when you have a spec or requirements for a multi-step task, before touching code
5
writing-skillsYou or the agent
Use when creating new skills, editing existing skills, or verifying skills work before deployment
5

From obra/superpowers at 2ce8aa1, 2026-10-21. Skills read by DeepSeek V4.1 Flash on 2026-11-04. Summary and techniques by Claude Opus 5.5 on 2026-11-06.