14 skills that stop AI from coding recklessly, skipping steps, or claiming "done" when it's not — like a pilot's pre-flight checklist.
Sound familiar?
If any of that happened to you, you're not alone.
Superpowers is a set of 14 skills designed to prevent these exact mistakes. It turns AI from an "impulsive coder" into a "disciplined engineer" — working by process, with evidence, with checkpoints, and no skipped steps.
AI assistants are smart, but they have a "design flaw": they want to act immediately. You say "build feature X" → it codes. You say "fix bug Y" → it fixes. The problem: coding fast ≠ coding right.
Superpowers solves this by enforcing a mandatory process: each skill is a step in the development workflow, and "hard gates" ensure AI can't skip steps.
Each skill in Superpowers has a specific role. Here are all 14 skills, organized by phase:
Check for applicable skills before doing anything. Like a pilot's pre-flight checklist — no skipping.
Turn ideas into detailed designs before coding. Clarify requirements, offer 2-3 approaches, write the spec, wait for approval before implementing.
Convert specs into implementation plans with concrete small steps. Each task has clear tests, clear commands, clear expected outcomes. No placeholders, no "similar to previous task".
Isolate feature work from the main branch using git worktrees — keeps the codebase clean, makes rollback easy when things go wrong.
Run the plan sequentially, one task at a time, with checkpoints and proof. Stop immediately on blockers, test failures, or unclear instructions.
RED → GREEN → REFACTOR. Write tests first (they must fail), write minimal code to pass, then clean up. Code written before tests must be deleted and redone — tests written after prove nothing.
Delegate each task to a separate subagent with an independent reviewer. Like a team lead managing a squad — everyone does their own work, someone reviews it.
Run multiple agents simultaneously for independent tasks — saves time when you have multiple tasks that don't depend on each other.
Find the root cause before fixing. Gather evidence → form hypothesis → test → fix. After 3 failed fixes → stop and reconsider the architecture.
Ask an independent reviewer (another AI) to read the code before merging — catches bugs the original coder missed.
Evaluate review feedback technically, don't just agree reflexively. Push back with evidence when needed.
The most important skill. Before saying "done", you must IDENTIFY → RUN → READ → VERIFY. Run new tests, read new output, verify with fresh evidence. No old results, no feelings.
Bring verified work to an integration decision: run final tests, identify base, present options (merge/squash/rebase), wait for user decision. Never self-merge.
Apply TDD to creating and modifying skills — write failing tests first, then write the skill. Ensures skills actually work, not just "paper skills".
What makes Superpowers powerful isn't the 14 skills — it's the hard gates that prevent AI from skipping steps:
| Hard Gate | Purpose |
|---|---|
| Design not approved → no coding | Prevents AI from coding the wrong thing from the start |
| RED before GREEN | Test must fail first → then code passes → proves the test has value |
| No verification → no "done" claim | Prevents AI from saying "done" when it's not actually done |
| 3 failed fixes → stop | Prevents blind fixing, forces architectural reconsideration |
| No self-merging | Always wait for user's final decision |
To have AI use Superpowers, simply call the specific skill by name in your request:
# To design a new feature
"superpowers:brainstorming — design a PDF export feature"
# To debug a bug
"superpowers:systematic-debugging — login test is failing"
# To ensure code is correct before merging
"superpowers:verification-before-completion"AI will automatically read the corresponding SKILL.md and follow the defined process.
Superpowers doesn't make AI smarter — it makes AI more professional. Think of it like:
If you're using an AI assistant to code, Superpowers is the process you should adopt. It's not complicated, it's not slow — in fact, it saves time by preventing AI from going wrong in the first place.
🎯 TL;DR: Superpowers = a checklist for AI. Design → plan → TDD → systematic debugging → review → verify with evidence → complete. No skipped steps. No "done" claims without proof. Code right the first time.