Superpowers

What it is

Superpowers is a library of "skills" for coding agents like Claude Code, Codex and Cursor. Each skill is a written procedure the agent follows at a certain moment: before building, before writing code, when something breaks, before calling work finished.

The skills switch on by themselves, so after installing it you just talk to your agent as normal. The difference is that the agent stops jumping straight into code.

It's free, MIT-licensed, and built by Jesse Vincent and the team at Prime Radiant. It became one of the most-starred repos in the AI coding world in about a year.

What actually happens when you use it

1. Brainstorming. Before building anything, the agent asks what you want and why, then plays its understanding back so you can correct it. A small change gets agreed in chat; a project gets a written design.
2. A separate workspace. It sets up a git worktree, a clean copy of your project on a new branch, so experiments don't touch your main code.
3. A plan. The approved design becomes a list of small tasks, each with exact files and a way to check it worked.
4. Building. Either a fresh sub-agent handles each task and gets reviewed, which is the most thorough option, or one agent works through the plan with a single review at the end, which is the cheapest.
5. Tests first. It writes a failing test, then the code that makes it pass. Code written before its test gets deleted.
6. Review and finish. Work is checked against the plan between tasks. At the end it runs the tests and asks whether to merge, open a pull request, keep the branch or throw it away.

There are also standalone skills you can lean on directly, like systematic-debugging for tracking down a root cause.

What people like

• It makes the agent plan before touching anything. One long-time user said that alone saves them a lot of mess, even though they skip half the ceremony.
• The tests and review catch real bugs. Some users still run it on the newest models because the enforced testing and adversarial review keep catching bugs the model wrote. One user reported several major blockers in every spec and plan before building.
• It pays off on hard, complex work. A developer building a compiler called it an absolute necessity there, but not for their everyday Rails work. Another said big features come out much higher quality, at a token cost.
• Individual skills are useful on their own. Several people keep just systematic-debugging and receiving-code-review and skip brainstorming.
• It's a good way to learn a process. For people new to building with Claude, it's been described as a guided way to design and build a project that you can grow out of later.

What people run into

• It uses a lot of tokens. The cost comes from the build loop, not the skill files: a fresh sub-agent per task, two reviews per task, and up to five fix rounds. On Codex, one user reported a simple plan using a full 5-hour budget in one run, though that was on an older version.
• Small tasks get slower. Several users say quick edits get pulled into a planning flow they don't need. One stopped when everything came out overspecced, overengineered and slow. A 12-session comparison found it helped on multi-file work but slowed down simple ones, with a sample too small to treat as proof.
• Many say newer models don't need it. In a September thread asking whether it's still needed on Opus 5.5, most replies said no. People reported vanilla Opus feels faster at the same quality, and that the extra context can make the code worse, not better.
• The new brainstorming divides people. Version 7 rebuilt brainstorming to ask more questions up front. There's already an open issue titled "v7's brainstorm questions are rather annoying".
• Plans can be too rigid. A long-running issue says plans over-specify the implementation, leaving the building agent no room to use judgment.

Before you install

• Test it on your own work. Run a few typical tasks with it on and off, and compare how often the first attempt works. That beats anyone's anecdote, which is the advice from one of the thread's most useful replies.
• You can steer it. It announces how big it thinks the job is. Tell it "treat this as bounded" or "skip the plan, implement from the spec" to cut the ceremony.
• Use only the parts you need. Keep brainstorming and plan-writing and run the plan yourself, or keep just the debugging skill. That cuts most of the token cost.
• There's optional telemetry. The optional visual companion loads a logo from Prime Radiant's site that reports which version you run, but nothing about your project. Set SUPERPOWERS_DISABLE_TELEMETRY=1 to switch it off.

The short version

Superpowers turns a coding agent into something closer to a careful junior developer with a checklist. That was a big upgrade a year ago. With today's strongest models, the checklist costs more than it used to and helps less on small jobs. It still earns its keep on large builds, on cheaper models, and for anyone who never reads the code and wants tests and reviews to do it for them.