Superpowers for Claude Code: The #1 Skills Framework That Makes AI Actually Ship Production Code

Point a vanilla Claude Code instance at a complex project, and you will get a predictable outcome: the agent jumps straight into writing code, skips tests, mixes responsibilities, and eventually produces a fragile prototype that needs to be rewritten. The problem is not the model's intelligence. It is the absence of discipline.

Experienced developers know this instinctively. Software quality does not come from the ability to write code fast. It comes from process. Specification, task breakdown, unit tests before implementation, code review, branch isolation. These practices, forged over decades of software engineering, are precisely what AI agents ignore when left to their own devices.

This is exactly what Superpowers solves. Created by Jesse Vincent (known as obra on GitHub), this agentic skills framework and software development methodology has become the most popular plugin in the Claude Code ecosystem, with over 93,000 GitHub stars. Its principle is simple but radical: instead of making the agent smarter, it enforces the discipline that human developers spent decades building.

Jesse Vincent is no newcomer to the open-source world. He created Request Tracker (RT), the open-source ticketing system written in Perl that is used by thousands of organizations worldwide, including the Perl community itself for bug tracking. He served as the "pumpking" of Perl 5, the person responsible for language releases. More recently, he co-founded Keyboardio, a company designing and manufacturing high-end ergonomic mechanical keyboards.

His background explains much of the philosophy behind Superpowers. Vincent comes from a world where process rigor, automated testing, and documentation are not optional. When he started working intensively with Claude Code in 2025, he quickly identified the gap between the model's raw capabilities and the actual quality of the code it produced. His response was to build a system of composable "skills" that turn the agent into a structured development team.

As Simon Willison, the respected Python developer and creator of Datasette, noted, Jesse Vincent is "one of the most creative users of coding agents" he knows. The first version of Superpowers was published in October 2025, the same day Anthropic launched its plugin system for Claude Code. Since then, the project has experienced explosive growth, going from a few thousand stars to over 93,000 by March 2026.

Superpowers is not an enhanced prompt or a collection of isolated instructions. It is a complete software development workflow built on composable skills and a set of initial instructions that force the agent to use them. The key word here is "force": skills are not suggestions. They are mandatory.

Here is how a complete development cycle works with Superpowers:

1. Brainstorming (Socratic design)

The moment the agent detects you are building something, it does not rush to write code. It steps back and asks you what you are really trying to do. Through a Socratic question-and-answer process, it refines your idea, identifies edge cases, and produces a design document. This document is presented in short sections so you can validate it progressively without being overwhelmed.

2. Git worktree creation

Once the design is approved, Superpowers automatically creates an isolated Git worktree on a new branch. This isolation is fundamental: it allows parallel tasks on the same project without changes stepping on each other. The agent also verifies that the test baseline is clean before starting.

3. Implementation plan writing

The design document is broken down into two-to-five-minute tasks, each with exact file paths, complete expected code, and verification steps. The plan is written as though "an enthusiastic junior engineer with poor taste, no judgment, no project context, and an aversion to testing" had to follow it. This phrasing, typical of Vincent's humor, ensures that every task is explicit enough to leave no room for interpretation.

4. Subagent-driven development

This is the core of the system. Instead of executing all tasks in a single context (which causes drift on long projects), Superpowers launches a fresh subagent for each task. Each subagent goes through a two-stage review: spec compliance first, then code quality. This mechanism allows Claude to work autonomously for several hours without deviating from the plan.

5. Strict Test-Driven Development

Superpowers enforces the RED-GREEN-REFACTOR cycle without negotiation. The agent must write a failing test (RED), then write the minimum code to make that test pass (GREEN), then refactor. If code is written before a failing test exists, the framework deletes it. This radical approach to TDD eliminates one of the most common problems with AI-generated code: the complete absence of test coverage.

6. Automated code review

Between each task, a code review is performed against the plan. Issues are classified by severity, and critical issues block progress. The agent cannot move to the next task until critical issues are resolved.

7. Branch finalization

When all tasks are complete, the agent verifies that all tests pass, then presents four options: merge the branch, create a GitHub pull request, keep the branch for later, or discard everything. The worktree is then cleaned up.

Beyond the main workflow, Superpowers includes a library of specialized skills:

One remarkable aspect is the "writing-skills" skill: Superpowers can create new skills. Vincent has described how he asks Claude to read a programming book and extract reusable skills from it. The framework even uses TDD to test the skills themselves, submitting them to subagents to verify they are comprehensible and that agents comply with them.

To understand the practical impact of Superpowers, here is a comparison between a standard Claude Code workflow and one structured by Superpowers:

Installing Superpowers takes seconds. For Claude Code, two commands in the terminal:

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

To verify the installation, type /help and you should see the Superpowers commands. The three main commands are:

/superpowers:brainstorm     - Start a brainstorming session
/superpowers:write-plan     - Create an implementation plan
/superpowers:execute-plan   - Execute the plan with subagents

The plugin updates automatically via /plugin update superpowers.

Superpowers also works with other tools. For Codex, you tell the agent to fetch installation instructions from the GitHub repository. For OpenCode, the procedure is similar.

Superpowers works out of the box without additional configuration. However, for best results, it is recommended to use a powerful model like Claude Opus for brainstorming and planning tasks. Implementation subagents can use faster models without significant quality loss, since each task is explicit enough not to require complex reasoning.

At Bridgers, we have been using Superpowers daily for several months. Our CTO, Charles, relies particularly heavily on this framework for structuring the team's development workflows. What convinced him from the start was the brainstorming phase: instead of having to write a detailed spec before launching Claude Code, he describes a feature in a few sentences and lets Superpowers organize the design through structured dialogue.

The most tangible gain is in testing. Before Superpowers, AI-generated code often arrived without test coverage, or with superficial tests written after the fact. With the TDD enforced by the framework, every piece of delivered code has its associated tests from the start. This has considerably reduced the time spent on manual code review and debugging.

The other major advantage is the agent's ability to work through long sessions without losing track. On complex projects, Charles regularly launches autonomous development sessions lasting several hours. The fresh-subagent-per-task mechanism prevents the context drift that used to make long sessions unusable.

The one caveat is that Superpowers works best when you know what you want to build. For rapid exploratory prototyping where you are still figuring out the direction, the structured workflow can feel heavy. But once requirements are clear, even approximately, the gain in quality and reliability is undeniable.

The philosophy of Superpowers rests on five foundational principles worth examining in detail:

Test-Driven Development: tests come first, always. This is not a recommendation; it is a system constraint. The idea is that if an AI agent can write code, it can also write tests. And if it writes tests first, the code that follows is mechanically more reliable.

Systematic over ad-hoc: every decision follows a defined process. No shortcuts, no "I will just quickly modify this file." This rigidity, which might seem constraining, is actually liberating: it allows the agent to work autonomously for hours without constant supervision.

Complexity reduction: simplicity is the primary goal. Each task is broken into two-to-five-minute units. Each subagent has a single responsibility. The produced code follows YAGNI (You Aren't Gonna Need It) and DRY (Don't Repeat Yourself) principles.

Evidence over claims: the agent cannot declare a task complete without evidence. Tests must pass. The code review must be validated. Verifications must be executed.

Skills as units of knowledge: perhaps the deepest innovation of Superpowers is the concept of skills itself. These are structured documents that capture not instructions but complete methodologies. They can be tested, shared, and composed. Vincent even used persuasion principles (authority, commitment, social proof) to ensure agents actually follow the skills.

Superpowers sits within a broader ecosystem of Claude Code skills that includes projects like Impeccable (for interface design) and Vercel Best Practices (for React and Next.js). But Superpowers occupies a unique position: it is the only framework that covers the entire development cycle, from brainstorming to merge.

Anthropic's plugin marketplace, launched in late 2025, played a key role in Superpowers' adoption. Before the marketplace, installation required cloning a Git repository and manually configuring symlinks. Direct integration into Claude Code made the framework accessible to all developers, even those unfamiliar with command-line tool configuration.

The project's growth reflects a genuine industry need. As one widely-shared LinkedIn comment summarized: "82,000 developers just agreed on something: the biggest problem with AI coding is not intelligence. It is discipline." In March 2026, Superpowers is still gaining nearly 2,000 stars per day, making it one of the fastest-growing open-source projects of the year.

Superpowers represents a paradigm shift in how we use AI coding agents. Rather than seeking a smarter model, Jesse Vincent has demonstrated that imposing rigorous methodology on an existing model produces better results than letting a superior model work without constraints.

For development teams using Claude Code in production, Superpowers has become essential. The framework transforms an unpredictable AI assistant into a reliable, documented, and testable development process. And with a community of over 93,000 developers contributing and improving the skills, the project is only accelerating.

If you have not installed Superpowers yet, the two installation commands take less than thirty seconds. The time you invest in the brainstorming phase will be more than offset by the quality of the code produced and the time saved on debugging.