Superpowers: A Development Methodology for Code Agents

Everything you need to know about obra/superpowers: a library of composable instructions that enforces a design, testing, review, and closure process for coding agents.

---

What is Superpowers?

Superpowers is a framework of skills for code agents, and also a development methodology. It’s not a model, a runtime environment, or a server: the main product is a set of instructions and utilities in a plugin that makes the agent consult a relevant skill before acting.

Its purpose is to replace the improvisation of a session with a repeatable sequence: clarify the problem, agree on the design, plan, implement with tests, review, and decide how to close the branch. The README describes the skills as mandatory when applicable; not as suggestions that the agent can skip.

As of July 31, 2026, the README documents separate installations for Claude Code, Antigravity, Codex App, Codex CLI, Cursor, Factory Droid, Gemini CLI, GitHub Copilot CLI, Kimi Code, OpenCode, and Pi. Compatibility doesn’t imply a single mechanism: it uses the native formats and mechanisms of each environment when available.

The Origin: Leveraging an Anthropic Opening

The repository was created on October 9, 2025, by Jesse Vincent (obra), whose GitHub account identifies Prime Radiant as the company. On the same day, Vincent published the initial announcement, “Superpowers: How I am using coding agents in October 2025.”

The timeline is important: Vincent says he had been converting and systematizing his own process for weeks to better guide his agent, but Anthropic released the Claude Code plugin system that morning. Instead of waiting to complete everything planned, he published Superpowers immediately. The first flow was installed from its own marketplace with /plugin marketplace add obra/superpowers-marketplace and /plugin install superpowers@superpowers-marketplace.

The detail that defines the proposal is a login hook: when opening Claude, the plugin injects an instruction requiring it to read a bootstrap skill. This addresses a tension of native agents: having a library of instructions isn’t enough if the model doesn’t remember or decide to apply it. The response was an activation instruction and a skills consultation policy, not a manual command that the user had to remember.

The announcement also offers a revealing anecdote about the design: initially, Claude gave its sub-agents easy quizzes and achieved perfect scores. Vincent asked for realistic scenarios with pressure, such as an authentication incident that costs money per minute or the bias of confirming a test infrastructure that already works. The project transformed those failures into behavioral tests for the instructions. The text also acknowledges an ethical and technical tension: the skills use framing of authority, commitment, and scarcity to encourage discipline, and Vincent explicitly presents it as a way to improve reliability, not to circumvent controls.

Philosophy and Principles

The README summarizes four verifiable principles:

• Test-driven development: write a failing test first, implement the minimum to make it pass, and refactor.
• Systematic process over improvisation: investigate and plan before modifying code.
• Reduce complexity: YAGNI and DRY appear as practical limits to design.
• Evidence over assertions: don’t declare a task finished without verifying it.

There is an additional idea in the announcement: skills are reusable operational knowledge. Vincent describes that an agent can read documents or a codebase, extract lessons, and turn them into new skills; in turn, those skills are tested with sub-agents. It’s a proposal to improve instructions through use cases, not a guarantee that the agent will learn on its own.

How it Works

The documented basic flow has seven stages:

1. brainstorming formulates questions and presents the design in parts before programming.
2. using-git-worktrees creates an isolated space and checks out a clean test base.
3. writing-plans produces small tasks with specific routes, steps, and checks.
4. subagent-driven-development or executing-plans executes the plan: the first delegates a task per sub-agent and reviews it; the second allows batches with human checkpoints.
5. test-driven-development enforces the red → green → refactoring cycle.
6. requesting-code-review reviews against the plan and blocks progress in case of critical problems.
7. finishing-a-development-branch re-executes checks and proposes merging, opening a pull request, keeping, or discarding the branch.

The available skills are grouped into testing, debugging, collaboration, and meta-process. Among the collaboration skills are dispatching-parallel-agents, using-git-worktrees, writing-plans, requesting-code-review, and subagent-driven-development; the meta-skills include writing-skills and using-superpowers.

Version v6.2.0, released on July 24, 2026, shows that it’s not just static text. It introduced sub-agent-driven plan development workspaces in .superpowers/sdd/<plan-name>/, deleted upon completion of a clean review; it also resumes the implementer to correct findings and uses a new review focused on fixes. The release note declares internal test results of 25 out of 25 in two sets, but those results are from the project and do not constitute an independent evaluation.

Official and Semi-Official Status

Superpowers has official acceptance in several marketplaces, according to its current README:

• Anthropic: it is available in Claude’s official plugin marketplace via superpowers@claude-plugins-official.
• OpenAI: it is available in Codex’s official plugin marketplace, both in the Codex App and the Codex CLI.
• Kimi Code: the README indicates that it is in its plugin marketplace.
• Cursor: it is installed from its marketplace with /add-plugin superpowers or by searching for the name.

This doesn’t mean that Anthropic, OpenAI, Kimi, or Cursor certify the methodology or its results; it means that the package can be installed from their official catalogs. There is also a marketplace maintained by the project, obra/superpowers-marketplace, for Claude Code and other related plugins. In practice, simultaneous presence in vendor marketplaces and integration with eleven environments make it function as a de facto reference for the workflow skills pattern, but there is no formal designation of standard in the sources consulted.

The Ecosystem

Repositories by the author and Prime Radiant

• obra/superpowers-marketplace: curated marketplace of Claude Code plugins; 1,191 stars and 242 forks in the GitHub search consulted.
• obra/superpowers-skills: community-editable skills for the plugin; 734 stars and 164 forks.
• obra/superpowers-lab: experimental skills and tools for Superpowers; 402 stars and 30 forks.
• obra/superpowers-chrome: plugin to control Chrome via the DevTools Protocol, with no dependencies; 336 stars and 51 forks.
• obra/amplifier-bundle-superpowers: adaptation of the workflow system for Amplifier; 70 stars and 14 forks.
• prime-radiant-inc/superpowers-evals: behavioral evaluation lab. It runs command-line interfaces of agents, including Claude, Codex, Gemini, and Kimi, and scores compliance with deterministic scenario criteria; 91 stars and 9 forks.

The README itself links superpowers-evals to test skill behavior using the Drill harness. This is distinguished from the plugin’s infrastructure tests, which live in tests/ and are run with the relevant run-*.sh scripts or with npm test.

Community ports, translations, and extensions

• jnMetaCode/superpowers-zh is a community translation and extension to Chinese: it announces the complete translation and six original skills; 7,383 stars and 713 forks. It is the most visible non-English port found in the search, not a Prime Radiant repository.
• anthonylee991/gemini-superpowers-antigravity adapts the idea to Gemini Antigravity; 815 stars and 107 forks.
• skainguyen1412/antigravity-superpowers ports brainstorming, planning, testing, review, and verification flows to Antigravity; 322 stars and 35 forks.
• K-Dense-AI/science-superpowers presents itself as a reimplementation for scientific research agents, with pre-registration instead of software test-driven development discipline; 276 stars and 26 forks.
• SYZ-Coder/superpowers-openspec-team-skills combines Superpowers and OpenSpec into a skills library for teams with memory and self-learning; 183 stars and 50 forks.
• MakFly/superpowers-symfony extends the pattern to Symfony with specific skills, sub-agents, and commands; 183 stars and 17 forks.

These figures are those returned by the GitHub repository search during this research; they are not an audit of quality, support, or compatibility of each derivative.

The original launch also cites Microsoft Amplifier as a related framework that uses Markdown documentation and tools that the agent can extend. This relationship appears as inspiration from the author, not as affiliation or technical dependence of Superpowers.

Repo Numbers

Measurement: July 31, 2026, GitHub API.

Metric	Value
Stars	264,367
Forks	23,603
Subscribers	998
Commits	680
Open issues indicated by the API	304
Primary language	Shell
License	MIT
Creation	October 9, 2025
Last metadata update	July 31, 2026
Last release	v6.2.0, July 24, 2026

The main contributors returned by the API, by number of contributions, were obra (Jesse Vincent), mhenke, robertjakub, and larsroettig. The count of 680 was obtained from the last page of the commits API pagination link. The GitHub API uses open_issues_count; this field may include open pull requests, so it should not be read as an exclusive count of issues. Likewise, watchers_count from the general response replicates the stars; therefore, the subscribers_count field is reported separately as actual subscribers.

How to Contribute

The documented process is concrete:

1. Create a fork of the repository.
2. Switch to the dev branch.
3. Create a branch for the work.
4. Follow writing-skills to create or modify skills and their tests.
5. Open a pull request and complete the template.

The README warns that they usually don’t accept new skill contributions and that any modification must work in all compatible agents. The Drill harness from superpowers-evals is used for skills; for infrastructure, the tests are in tests/. This multi-environment limitation explains part of the requirement of the process: an instruction that works in one agent may not be triggered in the same way in another.

How the Community Received It

The recovered evidence shows adoption and influence, but also clear objections about cost and trust:

• In the Hacker News thread 48140677, user anaq42 presented JDS, a suite for Copilot inspired by Superpowers. He wrote that he liked imposing discipline with a skill-based flow because the agents “drift and lose track,” and attributed to Superpowers the ability to sustain long sessions without losing focus. The submission reached 9 points and 0 comments; it is an example of explicit recognition, not a broad measure of satisfaction.
• In 46864977, dsifry presented Metaswarm and named Superpowers, along with Beads, as an essential basis for disciplined flows of testing, brainstorming, and debugging. The submission had 5 points and 2 comments. It is evidence of reuse in a later tool, not an independent validation of its performance claims.
• User sermakarevich, in 48459609, raised the opposite objection: he doesn’t install foreign skills without reviewing them and cited an evaluation linked that, according to his summary, observed worse performance with more token consumption for Superpowers’ test-driven approach. The thread had 1 point and 0 comments when consulted. Since the external evaluation linked was not directly recovered in this research, that conclusion should be treated as a criticism attributed to that user, not as a confirmed result.
• The release note provides another first-hand reservation: Vincent himself explains that the persuasive framing of the instructions is “fascinating and slightly unsettling.” The strategy seeks to prevent the agent from skipping a procedure under pressure, but it also increases the need for the user to inspect the installed instructions.

No original Superpowers announcement with a broad and verifiable discussion on Hacker News was found during the consultations performed. Therefore, hundreds of comments or a consensus that the sources do not show cannot be inferred.

Superpowers vs. Other Proposals

Proposal	Verifiable match	Verifiable difference
josipmusa/jds	Suite of skills that enforces think → plan → execute for a code agent.	JDS is declared adapted to Copilot and adds a visual graph of tasks; its author says it took inspiration from Superpowers, not that it is a literal port.
andonimichael/arxitect	Claude Code plugin inspired by Superpowers and aimed at improving the agent’s behavior.	Arxitect focuses its skills on principles of architecture, API design, and code quality; Superpowers covers a broader development cycle.
K-Dense-AI/science-superpowers	Reimplements the composed methodology approach based on skills.	It is aimed at scientific research and declares pre-registration instead of software test-driven development discipline.
Microsoft Amplifier	Vincent’s announcement identifies it as a framework that uses Markdown documentation and tools extensible by the agent.	The source does not allow claiming functional equivalence or technical integration; it is presented as conceptual reference.

The most useful comparison is not by popularity: Superpowers stands out when you want to impose a cross-cutting and portable process between agents. A specialized extension may be preferable when the domain, such as architecture or science, requires rules that the general flow does not contain.

Use Cases and Who This Repository Can Help

• Teams developing with Claude Code, Codex, Cursor, or another of the supported environments can adopt the brainstorming → writing-plans → implementation → review journey so that a task doesn’t go directly from an ambiguous request to a change without design or verification.
• People responsible for an incident or a delivery with several changes can use using-git-worktrees, the plan space in .superpowers/sdd/, and per-task review to isolate the agent’s work, preserve the plan state, and decide at the end whether to merge, open a pull request, keep, or discard the branch.
• People who maintain internal instructions for agents can start with writing-skills and the superpowers-evals harness to turn a repeatable procedure into a skill and subject it to behavior scenarios. Before installing or extending the flow, it is advisable to inspect the instructions and measure the cost in tokens and results in your own environment.

Resources

• Repository: https://github.com/obra/superpowers
• Documentation and installation: https://github.com/obra/superpowers#installation
• Launch announcement and context: https://blog.fsck.com/2025/10/09/superpowers/
• Official skills: https://github.com/obra/superpowers/tree/main/skills
• Superpowers marketplace: https://github.com/obra/superpowers-marketplace
• Official evaluations: https://github.com/prime-radiant-inc/superpowers-evals
• Official Claude marketplace: https://claude.com/plugins/superpowers
• Official Codex marketplace: https://github.com/openai/plugins
• Discord community: https://discord.gg/35wsABTejz
• Conversations and references: https://news.ycombinator.com/item?id=48140677, https://news.ycombinator.com/item?id=46864977, https://news.ycombinator.com/item?id=48459609

---

Note: This article combines the README, launch announcements, and release notes of Superpowers, the GitHub API, and Hacker News results consulted on July 31, 2026. The figures change over time.