Superpowers does not make AI coding faster. The plugin slows the first hour of a task on purpose, spending tokens on questions and a written specification, then hands execution to isolated subagents so your main context window never fills up with file reads.
What the Superpowers Claude Code plugin actually does
Superpowers is a skills-based plugin for agentic coding tools, and it turns a vague feature request into a brainstorm, a written specification, a task plan, and a test-driven execution run. The project lives at obra/superpowers on GitHub and is maintained by Jesse Vincent, who publishes it as a set of Markdown skills rather than as a standalone application.
The plugin does not replace the agent. It supplies instructions that the agent loads before acting, so a request such as "build a topics screen in the admin" triggers a question-and-answer phase instead of immediate file edits. The agent reads your existing code first, then asks about fields, filters, and navigation patterns it found in the repository.
That ordering is the whole product. In the live session, the agent produced a design document, then a task breakdown, then seven files of implementation, and the only backend gap that surfaced was a missing route registration in the API layer, not a missing architectural decision.
The sequence is fixed rather than optional, and each stage gates the next:
- Brainstorm — the agent reads the existing repository and asks about fields, filters, and navigation patterns before writing anything.
- Specify — the answers are committed to a design document that later stages treat as the source of truth.
- Plan — the design is broken into a task breakdown, one task per unit of work.
- Execute — tasks are implemented test-first, so the run ends with seven files of implementation rather than a first draft.
Superpowers works with any tool that reads skill files, and the transcript names Claude Code, OpenCode, and Codex as examples of the class of agentic coding tools it targets. Public repositories that distribute skill files in this format have been widely adopted across the ecosystem since 2024, and the pattern has held steady through 2025 as more agentic tools added skill-loading support. The distinction that matters when choosing a host tool is not which model it calls, but whether it can load an external instruction file before it starts editing:
| Tool | Loads external skill files | Typical host for Superpowers |
|---|---|---|
| Claude Code | Yes | Yes |
| OpenCode | Yes | Yes |
| Codex | Yes | Yes |
| Plain chat agent | No | No |
How brainstorm, spec, and plan turn questions into a design
The brainstorm skill converts a short prompt into a structured interview about decisions the developer has not yet made. In the recorded run, the agent asked whether unanswered and answered topics should use horizontal tabs, a filter component, or a hybrid, then offered a combobox, a plain select, or selectable chips for the forum filter.
Each answer changes the next question. The transcript shows the agent producing a summary of decisions, proposing two competing implementation approaches for the tabs, and waiting for the developer to pick one before writing any specification.
After the brainstorm the agent writes a design document into a specs folder, then derives a task plan from it. Plan tasks are deliberately small, and each one carries the relative file paths, the code context it needs, and explicit verification steps that act as feedback loops.
A plan task is only complete when its own verification passes, which is what keeps a long feature from drifting away from the design document produced at the start. The transcript's equivalent step for a real product was a skill named admin Claude screen in Rocketseat's own repository, holding folder conventions, type locations, listing and filter examples, and API mutation patterns.
Skill files: the mechanism behind the workflow
A skill is a Markdown instruction file that an agent loads before running a task, and Superpowers ships as a package of them. When a skill is activated, its contents are injected as context ahead of the developer's message, so the agent starts with the project's rules already in view.
Skills cover both process and project knowledge. Superpowers provides skills for brainstorming, writing plans, writing new skills, and code review; a team can also write its own, such as a screen generator that encodes naming conventions, shared versus local types, and the exact form library, component library, and query patterns in use.
The plugin's activation rule is permissive by design. If there is even a small chance a skill applies to the request, the agent loads it, so brainstorm may run without being explicitly requested. Developers can also invoke a skill by name when they want a specific path.
Jesse Vincent documents the skill format itself in the Superpowers repository, which means a team can fork the plugin and adjust the workflow instead of adopting it whole.
Loading order in practice
- A skill's Markdown is injected as context before the developer's message, so the rules are in view from the first token.
- The agent applies the permissive activation rule: if there is even a small chance a skill applies, it loads that skill.
- The developer can override the automatic path by invoking a skill by name.
Built-in and team-authored skills compared
| Skill | Who writes it | Typical trigger |
|---|---|---|
| Brainstorm | Superpowers | Any request with a small chance of applying |
| Writing plans | Superpowers | Work that needs a plan before code |
| Writing new skills | Superpowers | A team wants to encode its own rules |
| Code review | Superpowers | A change is ready for review |
| Screen generator | The team | Encoding naming, types, and library choices |
Jesse Vincent maintains the plugin in the Superpowers repository, where the skill format itself is documented (skill format reference).
What Superpowers costs in tokens and wall-clock time
Superpowers increases total token consumption while reducing the tokens spent in the main context window, and those two effects are separate. A developer in the session reported heavy token use with the plugin on Codex, and that matches the design: more files get explored, more questions get asked, and more subagents get spawned.
The value proposition is quality rather than speed. The speaker states plainly that the plugin does not accelerate development, it improves what you ship, and the visible cost is a slower start while the brainstorm and specification are written.
Cost control comes from choosing the execution mode per task. A small plan can run inline; a plan that already consumed tens of thousands of tokens in planning should go to subagents so the parent window does not reach the degradation range during implementation.
The transcript also reports that the plugin's community adoption includes a fork used to integrate design-tool context and semantic design tokens, which is the expected shape for a Markdown-based workflow that teams can modify.
Where the agent still fails without a human in the loop
The agent still makes wrong assumptions that no workflow eliminates, and the recorded session produced two clear examples. The first was a language mismatch: after a single instruction in Portuguese to continue, the agent skipped writing the plan and jumped straight into execution.
The second example is more instructive. The agent decided on its own to configure permissions for the new screen and invented a permission value that did not exist, granting default admin login access without asking. Screens loaded empty until the developer investigated and found the fabricated permission and an unregistered API route.
Both failures share a cause: the human did not review an intermediate artifact. The plan was never read before execution started, and the permission decision was never surfaced as a question.
The practical rule from the session is to read the design document and the plan before approving execution, then test the result before opening a pull request. The workflow produces reviewable checkpoints, and the checkpoints only help if someone reads them.
Superpowers FAQ
- Is the Superpowers Claude Code plugin free and open source? The plugin is published as a public repository of Markdown skill files that you install into an agentic coding tool. Check the obra/superpowers repository for the current license and installation steps, since the project evolves quickly.
- Does Superpowers work with tools other than Claude Code? Yes. It targets agentic coding tools that read skill files, and the transcript names Claude Code, OpenCode, and Codex as compatible hosts. The exact install path differs per tool, so follow the repository's instructions for your editor or CLI.
- Why does Superpowers use more tokens than a normal prompt? It explores more of your codebase and asks clarifying questions before coding, so total token use rises. The separate benefit is that implementation runs in subagents, which keeps the main conversation from accumulating every file read.
- What is subagent-driven development? Each task from the plan is handed to an isolated agent that reads files and reports a short result back. The parent conversation receives conclusions instead of raw file contents, so a long feature does not fill the main context window.
- What is context rot and why does it matter here? Context rot describes the drop in an agent's ability to use information as its input grows, especially content in the middle of a long conversation. It is the reason the transcript recommends moving heavy implementation work out of the planning conversation.
- Can I write my own skills for Superpowers? Yes. The plugin includes a skill for writing skills, and teams can encode their own folder conventions, component patterns, and API rules. Rocketseat's example is a screen-generator skill that preloads its admin conventions for every new screen.
- Does Superpowers slow down development? The first phase is slower because the agent asks questions and writes a specification before coding. Execution then proceeds task by task with verification, and the transcript frames the trade as quality over speed rather than a net time saving.
- Why did the agent create a permission that did not exist? The agent inferred it needed permission configuration and invented a value instead of asking. It is a concrete reason to review the plan and test the result, since the workflow surfaces decisions but does not guarantee a human reads them.
- Should I use Superpowers or Spec Kit for a new project? Spec Kit enforces a more prescriptive sequence and suits teams that want that structure. Superpowers is looser, lets you adopt individual skills, and fits workflows where design decisions emerge during conversation with the agent.
CTA: bring your video walkthrough to Skala Blog
A recorded walkthrough like Superpowers' brainstorm-into-subagent workflow holds the kind of detail that is hard to reconstruct later: the exact questions the agent asks, the token counts at each phase, and the moment the plan gets skipped. Those details are what a written article can preserve and a video cannot pin down for a reader searching for answers months afterward.
If you have similar knowledge inside a YouTube video, Skala Blog turns it into a structured article: paste the video URL, generate the transcription, and edit the draft before you publish. Teams can also explore Crazystack for TypeScript and full-stack training resources.
Fork this article
Start a new branch from the same video, shaped your way. You keep the credit; the original keeps the attribution.
A fork in another language is filed as a translation of this article, so the two pages point at each other. You can unlink it later from the editor.
0/240
You are creating
- Format
- For
- Language
- Source
- Your angle
You will be asked to sign in before it is generated.
Buy credits