Superpowers = expertise on demand
Superpowers is a library of skills for Claude Code. A skill is a small, focused playbook Claude loads only when it is needed: how to debug, how to write a plan, how to build a hand-drawn explainer. Instead of one giant prompt that tries to know everything, Claude reaches for the right skill at the right moment, the same way a craftsman reaches for the right tool.
- A skill = a named, reusable procedure Claude follows exactly.
- Skills load on demand, so the context stays lean and sharp.
- You trigger one by name (/skill) or Claude picks it up itself.
Check for a skill before you act
The core discipline is simple: before doing anything, even answering a quick question, Claude asks 'is there a skill for this?' If there is even a small chance a skill applies, it invokes it first. This stops Claude from improvising when a proven, tested procedure already exists. The skill is rigid where it needs to be and flexible where it can be.
- Even a 1% chance a skill fits means invoke it and check.
- Process skills (brainstorm, debug) decide HOW to approach.
- Your explicit instructions always win over a skill default.
Brainstorm, plan, execute, verify
Real work flows through four stages, each with its own skill. Brainstorm to pin down what you actually want. Write a plan that turns it into concrete steps. Execute the plan task by task. Verify before claiming it is done. Skipping a stage is where things go wrong. The loop is what turns a vague ask into shipped, working software.
- Brainstorming: explore intent and design before any code.
- Writing-plans: lock the approach into bite-sized tasks.
- Execute + verify: build it, then prove it works.
Plans are bite-sized TDD tasks
The writing-plans skill produces a plan a stranger could execute: exact file paths, real code in every step, the commands to run, and what 'done' looks like. Each task is tiny, write the failing test, run it, implement, run it again, commit. They are saved as checklists in docs/superpowers/plans so anyone (or any agent) can pick them up and track progress.
- Every step has real code or a real command, no 'TBD'.
- Tasks are 2 to 5 minutes each, checkbox by checkbox.
- Saved to docs/superpowers/plans as a living checklist.
Run the plan, your choice of gear
Once a plan exists, there are two ways to build it. Subagent-driven development dispatches a fresh agent per task with a clean context and a review between each one, fast and tidy for independent tasks. Inline execution runs the tasks in the current session with checkpoints. Both follow the same plan; you pick the one that fits the job's size and risk.
- Subagent-driven: fresh agent per task, review between, parallel-friendly.
- Executing-plans: inline, batched, with checkpoints to review.
- Same plan file drives either path, so the work stays consistent.
Discipline skills stop the slop
The quality comes from a handful of rigid skills. Test-driven development writes the test first. Systematic-debugging finds the root cause before proposing a fix. Verification-before-completion makes Claude prove a claim with real output, not a hopeful 'it should work.' Requesting and receiving code review add a second set of eyes. These are the rules that keep agents from shipping confident nonsense.
- TDD: red, green, refactor. The test defines done.
- Debugging: reproduce and root-cause before any fix.
- Verify-before-completion: evidence, not assertions, always.
Vague asks become repeatable engineering
Without this, every task is improvised and the quality is a coin flip. With Superpowers, the same proven procedures run every time: scope it, plan it, build it task by task, verify it, review it. You can hand a plan to a fresh agent and trust the output. You scale out to many agents in parallel and keep your sanity. It is the difference between vibe-coding and an engineering system.
- Consistency: the same disciplined path on every build.
- Trust: verified output you do not have to babysit.
- Scale: dispatch parallel agents and worktrees without chaos.