HavenSkills

Claude Superpowers Skills

Browse selected engineering workflow skills from the Superpowers project.

Skills
6 skills

How to choose

Use brainstorming for open design questions and a written plan for a change that spans several steps.

Filter

All skills in this category

brainstorming

Clarify requirements and design options before starting implementation.

by obra
npx skills add obra/superpowers --skill brainstorming
Author
obra
Repo
GitHub

systematic-debugging

Follow evidence from a reproducible failure to its root cause.

by obra
npx skills add obra/superpowers --skill systematic-debugging
Author
obra
Repo
GitHub

writing-plans

Turn an approved design into an implementation plan with verification steps.

by obra
npx skills add obra/superpowers --skill writing-plans
Author
obra
Repo
GitHub

requesting-code-review

Prepare context and verification results so a reviewer can assess a change.

by obra
npx skills add obra/superpowers --skill requesting-code-review
Author
obra
Repo
GitHub

test-driven-development

Drive application changes with a failing test before implementing the fix.

by obra
npx skills add obra/superpowers --skill test-driven-development
Author
obra
Repo
GitHub

verification-before-completion

Collect fresh verification output before reporting that the work is finished.

by obra
npx skills add obra/superpowers --skill verification-before-completion
Author
obra
Repo
GitHub

What Superpowers skills are for

Superpowers (obra/superpowers) is not a tool collection. It is a discipline for how an agent should behave on engineering work: understand first, plan second, change third, verify last. Every skill on this page enforces one step of that loop.

The reason it matters is boring and specific: an agent that skips the loop does plausible work fast. It writes a fix for a bug it has not reproduced, touches four files nobody asked about, then reports success without running anything. These six skills exist to make each of those failures harder.

The loop, in the order you actually need it

  1. brainstorming — before implementation. It asks what the requirement is and what the options are, and it refuses to accept “just make it work”.
  2. writing-plans — turns an approved design into steps with a verification step attached to each. This is the artifact the rest of the loop reads.
  3. test-driven-development — a failing test first, then the change. The test is the proof that the change does something; without it, “fixed” is an opinion.
  4. systematic-debugging — when a failure is real and unexplained: reproduce, reduce, hypothesise, test the hypothesis. It stops the pattern where each attempt is a fresh guess.
  5. requesting-code-review — assembles the context and the verification output a reviewer needs. The point is that the reviewer should not have to reconstruct your reasoning.
  6. verification-before-completion — the last gate: collect fresh output before claiming the work is finished. Stale test output is not evidence.

Install all six from one repo, or install the ones that match your bottleneck:

npx skills add obra/superpowers --skill systematic-debugging

Where these skills break in practice

  • The plan becomes a ritual. A plan with no verification step per item is a to-do list, and it drifts the moment the code disagrees with it.
  • Tests written after the change. They pass on the first run because they were written to match the implementation — the exact thing TDD prevents.
  • Debugging by editing. Changing code to see what happens is not debugging; if the hypothesis is not written down, nothing was learned from the attempt.
  • Verification with old output. The most common dishonest completion is quoting a test run from before the last edit. Fresh output, or nothing.
  • Review requests with no diff scope. A reviewer given “I changed some stuff” can only comment on style.

The check that catches most of it

  1. For every plan item, point at the command or assertion that proves it is done. If you cannot, the item is not a step.
  2. Run the test suite now, and read the timestamp. A pass from an earlier run proves nothing about the current tree.
  3. Ask what was reproduced before the fix. If the answer is “the user said it fails”, the bug is not understood yet.
  4. Read the diff and count the files. A fix touching more files than the bug requires got scope-creeped.

Which page to read next

Coding skills covers the same work at the level of individual tools — reviews, refactors, test gaps. Agent workflow covers how skill files are written if you want to extend this discipline to your own team's rules.

How to evaluate the result

Gather current test output and compare the implementation with the agreed requirements.

How to check the result

Rerun the tests yourself, paste the output, and compare what changed with the requirements the plan was written against. Output from before the change does not count.

Frequently asked questions

How do I install one of these superpowers skills?

Use the command beside the skill, select a supported agent, then reload the agent and confirm it can see the skill in your project.

Do I need all six or can I install one?

This page lists six skills from obra/superpowers. Start with the individual skill that matches your task. For a full workflow, use brainstorming to define requirements, writing-plans to break down the work, test-driven-development to write tests, and verification-before-completion to check the result.

What if I want to change an installed skill?

After a failing test exists, use it to hold the behaviour of the workspace, then work on the skill file itself with the same loop: reproduce, fix, verify. The same workflow applies to any file you edit.

How do I verify a change someone else made with these skills?

Your own tests plus the plan's acceptance criteria. Ask for the command that was run and its output, and confirm the output is newer than the last edit.

What is the most common mistake when debugging with these skills?

Forgot to reproduce the failure first. Changing code until the symptom disappears leaves the cause in place and the bug usually returns within days.

Where should I start?

systematic-debugging if you fight repeated failed fixes. verification-before-completion if the agent reports success too often. writing-plans if work drifts mid-task.

Does this conflict with other coding skills?

It can. These are workflow instructions, and two workflows telling the agent different things about review or testing produces muddle. Pick one owner per step.

Does test-driven-development slow the agent down?

It adds a step and saves the rework. The measurable difference is how often a “fix” has to be reopened.