In one of its authors' test scenarios, the agent skipped the design doc without asking in 24 out of 24 runs; after the change shipped in version 7.0.1 on October 21, 2026, it did so in 3 out of 24. That's the kind of problem Superpowers tackles: the skills collection by Jesse Vincent and Prime Radiant that is now at around 308,700 GitHub stars. It isn't a single skill but a full methodology: the agent asks, designs, plans, writes code test-first and reviews before calling anything done.
What it does and when it kicks in
Superpowers installs as a plugin and, at session start, injects the using-superpowers skill into context, which makes the agent look for an applicable skill before any task. The README is blunt about it: these are mandatory workflows, not suggestions. From there, the basic workflow chains seven steps:
- brainstorming: before building anything, it draws out what you want and why, plays it back for you to correct, and writes a design doc when the work calls for one.
- using-git-worktrees: once the design is approved, it creates a worktree on a new branch and checks the tests pass to begin with.
- writing-plans: it breaks the work into 2-to-5-minute tasks with file paths, code and verification steps.
- subagent-driven-development or executing-plans: either a fresh subagent per task with a review after each (most thorough), or everything inline in the current session with one final review (cheapest).
- test-driven-development: a strict red-green-refactor loop.
- requesting-code-review: reviews against the plan between tasks; critical issues block progress.
- finishing-a-development-branch: verifies the tests and offers to merge, open a PR, keep or discard the branch.
There are also debugging skills (systematic-debugging, verification-before-completion) and one, diagnosing-superpowers, that reads the transcript of a session gone wrong and explains what happened with line-level evidence.
What the 7.x series brings
Version 7.0.0, released on October 9, 2026, rebuilt brainstorming from scratch: it now sizes the work (just do it, agree on it in chat, or write a full design) and adds a subagent that reads the design as the person building it would and lists what they'd still need to ask. Version 7.0.1 fixed what users flagged right away: the questions felt formulaic. It now reads the project and any files you point it at before its first message, and doesn't ask what they already answer.
The most useful change for Claude Code users is a different one. After a compaction, Claude Code re-attaches each skill truncated at 20,000 characters, and anything past that point is gone for the rest of the session. In one reported case, subagent-driven-development lost its five-round limit that way and ran 18 fix rounds on a single task. Version 7.0.1 moved parts of three long skills into references/ files the agent reads only when it needs them, and a test now fails if any SKILL.md reaches 20,000 bytes. That lesson applies to any home-grown skill that keeps growing.
How to install it
In Claude Code it's on the official plugin marketplace:
/plugin install superpowers@claude-plugins-officialThe README covers fifteen other harnesses, including Codex, Cursor, Gemini CLI, GitHub Copilot CLI and OpenCode, each installed separately. To check it works, open a fresh session and ask for something like "Let's make a react todo list": a working install triggers brainstorming before any code gets written.
Risks and limits
- A hook that runs every session. The plugin registers a
SessionStarthook (on startup, after/clearand after compaction) that runs a Bash script. The script only readsusing-superpowers/SKILL.mdand returns it as context, but that text then shapes everything the agent does. - Optional telemetry. The
brainstormingvisual companion loads the Prime Radiant logo from their website, including the installed version. Turn it off withSUPERPOWERS_DISABLE_TELEMETRY; it also honours Claude Code'sDISABLE_TELEMETRYandCLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC. - No-compromise TDD. The TDD skill deletes code written before its tests. In a repo with no tests or a slow suite, that clashes with how the team works.
- Token cost. A subagent per task with a review after each is the most thorough mode and also the most expensive;
executing-plansexists precisely as the cheap alternative.
It's MIT-licensed.
Versus working without it
The natural comparison is the agent as it ships: you ask for a feature and it starts writing code. Superpowers flips that order, and its own numbers show it isn't easy to pull off: even with the skill installed, the agent skipped the design in every run of one scenario until 7.0.1. For small changes, brainstorming itself decides to just do the work; the value shows up in multi-hour tasks, where a reviewed plan and tests first keep the agent from drifting. If your team already works with upfront design, worktrees and TDD, Superpowers encodes that discipline for the agent. If it doesn't, it will impose it.