What Is Superpowers?
Superpowers is a complete software development methodology for your coding agents, built on top of a set of composable skills and some initial instructions that make sure your agent uses them. It is built by Jesse Vincent and the team at Prime Radiant, licensed under MIT, and the repository had 309,623 stars and 27,550 forks when we checked on October 31, 2026.
The core idea is simple, and it fixes the most common failure of AI coding. Left alone, a coding agent jumps straight into writing code, guesses at what you want, and produces something that sort of works and is hard to change. Superpowers changes the default. From the moment you fire up your agent, it steps back and asks what you are really trying to do, instead of trying to write code first.
Because the skills trigger automatically, you do not need to do anything special once it is installed. Your coding agent just has Superpowers. The skills fire at the right moments: brainstorming before building, planning after design approval, test-driven development during implementation, and code review between tasks. They are mandatory workflows, not suggestions your agent can skip when it feels confident.
Brainstorm First, Then Plan
The workflow starts with brainstorming. The agent draws out what you actually want, and why, through questions that get you describing it, then plays its understanding back for correction. Small changes get agreed in chat. Bigger projects get a written design document that a builder could plan from, shown to you in chunks short enough to actually read and digest.
After you sign off on the design, the agent puts together an implementation plan that is clear enough for an enthusiastic junior engineer with poor taste, no judgment, no project context, and an aversion to testing to follow. That is the project's own bar, and it is deliberately low: if the plan only works when read by an expert, it is not a good plan. Work is broken into bite-sized tasks of 2 to 5 minutes each, and every task has exact file paths, complete code, and verification steps.
Then, once you say go, the agent launches a subagent-driven process. Fresh sub-agents work through each engineering task, with inspection and review of their work as they go. It is not uncommon for an agent to work autonomously for a couple of hours at a time without deviating from the plan you put together, because the plan, not the agent's enthusiasm, is what is driving.
Test-Driven by Default
Superpowers emphasizes true red-green test-driven development, YAGNI, which means you are not gonna need it, and DRY, do not repeat yourself. During implementation, the test-driven-development skill enforces the red-green-refactor cycle: write a failing test, watch it fail, write the minimal code to pass, watch it pass, then refactor. Code written before tests gets deleted.
That sounds strict, and it is meant to be. AI agents are very good at writing plausible code that has never been run, and tests are the cheapest way to catch that. The verification-before-completion skill adds a second guard: the agent must ensure something is actually fixed before declaring it done, instead of claiming success from reading its own output.
Between tasks, the requesting-code-review skill reviews work against the plan and reports issues by severity. Critical issues block progress. When tasks complete, the finishing-a-development-branch skill verifies tests, presents options to merge, open a pull request, keep or discard the branch, and cleans up the worktree. Nothing merges on vibes.
The Skills Inside
Superpowers ships a library of skills grouped by job. Testing has test-driven development with a testing anti-patterns reference. Debugging has systematic debugging, a four-phase root cause process, verification before completion, and diagnosing-superpowers, which works out what went wrong in a session with line-level evidence and can package a scrubbed bundle for a bug report.
Collaboration skills cover the whole lifecycle: brainstorming, writing plans, executing plans inline, dispatching parallel agents, requesting and receiving code review, using git worktrees for isolated branches, finishing a development branch, and subagent-driven development with two-stage review, first for spec compliance, then for code quality. Meta skills cover writing new skills and the using-superpowers bootstrap itself.
The philosophy underneath is four lines: test-driven development, write tests first, always. Systematic over ad-hoc, process over guessing. Complexity reduction, simplicity as the primary goal. Evidence over claims, verify before declaring success. If those sound like rules a good senior engineer would enforce on a team, that is the point. Superpowers is a senior engineer's habits, packaged as skills an agent cannot quietly drop.
Works With Your Agent
Superpowers is not tied to one tool. It installs as a plugin or extension for Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot CLI, and many more, including Antigravity, Devin, Factory Droid, Grok Build, Kimi Code, OpenCode, Pi, Qwen Code, Hermes Agent, and Muse itself. Installation differs by harness, and if you use more than one, you install it separately for each one.
For Claude Code, install it from Anthropic's official plugin marketplace with /plugin install superpowers@claude-plugins-official, or register the Superpowers marketplace and install from there. For Cursor, install from the marketplace in Agent chat. For Codex, find it in the official plugin marketplace. The README lists every harness with its exact command, so pick yours and follow that one.
One detail worth knowing: skills trigger automatically, but the bootstrap that makes them trigger is injected at session start. If a very long session compacts and skills stop firing, start a fresh session. On Hermes Agent, which has no post-compaction hook, the same applies. And if a session misbehaves, ask your agent to figure out what went wrong with Superpowers in that session, and the diagnosing skill will read the transcript and report what happened with evidence.
How to Try It
Pick your coding agent and install the plugin. In Claude Code, run /plugin install superpowers@claude-plugins-official. Then start a fresh session and describe something you want to build. A working install auto-triggers brainstorming before any code is written, so the first thing you should see is questions about what you want, not code.
A good first test is a small project with a real requirement, like a todo app with a specific behavior, or a small feature on a codebase you already have. Watch for the sequence: questions first, a design played back for correction, a plan broken into small tasks with exact files and verification steps, tests before code, and a review after each task. If your agent skips straight to code, the install is not active, and a fresh session usually fixes it.
Updating is often automatic, but it depends on your harness. The project also offers commercial services for enterprises that want support, additional tooling, or managed spending, through Prime Radiant. For everyone else, the open-source version is the whole methodology, free under MIT, and it is what the 309,623 stars are for.
What to Watch Out For
Superpowers changes how it feels to work with an agent, and that takes a session or two to get used to. If you are used to getting code in the first reply, the questions will feel slow. They are the point. The methodology trades a fast first draft for a plan you can trust and code that has been tested and reviewed, and for anything bigger than a toy, that trade wins.
It also costs more tokens than letting an agent freestyle. Sub-agents per task, reviews between tasks, and tests before code all add up. The cheaper executing-plans mode implements every task inline in the current session with one fresh review of the whole branch at the end, instead of a sub-agent per task, if you want to save on that cost.
Finally, Superpowers does not accept agent-written pull requests that fix issues filed by someone else unless a maintainer asked for one, and it does not generally accept contributions of new skills. Skill updates must work across all the coding agents it supports. Those rules keep the methodology consistent, but they mean the project grows carefully rather than fast. For users, that is a feature: the workflow you learn today is the workflow that will still be there tomorrow.
