Superpowers Turned 93k Developers Into Senior Engineers Overnight

Jesse Vincent's open-source skills framework doesn't just suggest best practices to your coding agent. It enforces them. The result: hours of autonomous, test-driven development that actually ships.

obra/superpowers · 12 min read

A coding agent depicted as a young apprentice sits at a workbench. Behind it stands a stern but kind mentor figure holding a rulebook labeled Skills. The apprentice writes code on parchment while the mentor points to a test-first checklist. Tools and gears surround them.
Your coding agent, before and after discipline. The skills framework is the mentor it never had.
Key Takeaways

The Problem Nobody Talks About

Coding agents are brilliant and reckless. Hand one a prompt and it will sprint toward a solution, skipping requirements gathering, ignoring edge cases, writing code before tests, and declaring victory before verifying anything works. The output looks impressive in a demo. It collapses in production.

Jesse Vincent, the creator of Request Tracker, K-9 Mail, and the Keyboardio hardware company, noticed this pattern in October 2025. He had been using Claude Code daily and kept running into the same failure mode: the agent was talented but lacked discipline. It wrote code first, tested later, and drifted from the plan whenever the conversation grew long.

His fix was not to build a better model. It was to build a better methodology. The result is Superpowers: a library of composable "skills" that encode senior engineering practices as mandatory agent behavior.

"It starts from the moment you fire up your coding agent. As soon as it sees that you're building something, it doesn't just jump into trying to write code. Instead, it steps back and asks you what you're really trying to do."

-- Jesse Vincent, creator of Superpowers

Skills Are Not Suggestions

The core insight behind Superpowers is linguistic, not technical. Vincent discovered that classical persuasion principles work on large language models just as they work on humans. The skills are written with authority ("Skills are mandatory when they exist"), commitment ("The agent must announce which skill it's using"), and social proof ("This is how senior engineers work").

Each skill is a markdown file that describes a complete workflow. The agent loads relevant skills on-demand, reads the SKILL.md file, and follows the instructions. Not as a suggestion. As a hard gate.

The brainstorming skill, for instance, includes this line in bold:

Do NOT invoke any implementation skill, write any code, scaffold any project,
or take any implementation action until you have presented a design and the
user has approved it. This applies to EVERY project regardless of perceived
simplicity.

Every project goes through design review. A todo list. A single-function utility. A config change. The skill explicitly calls out the anti-pattern: "This is too simple to need a design." That rationalization is why simple projects accumulate unexamined assumptions.

Two figures sit across from each other at a table. One figure representing the user sketches rough ideas on paper. The other figure representing the agent asks pointed questions with a magnifying glass examining each sketch. Between them is a growing document labeled Spec.
The brainstorming skill turns your vague idea into a reviewed spec before a single line of code gets written.

The Seven-Stage Pipeline

Superpowers defines a complete development lifecycle. Each stage is a separate skill with its own hard gates, anti-patterns, and verification steps. The agent checks for relevant skills before every task. Here is the full flow.

1. Brainstorming. The agent explores your project context (files, docs, recent commits), asks clarifying questions one at a time, proposes 2-3 approaches with trade-offs and a recommendation, and presents the design in sections for your approval. It saves a spec document and dispatches a reviewer subagent to check it.

2. Git Worktrees. After design approval, the agent creates an isolated workspace on a new branch. It runs project setup and verifies a clean test baseline. Your main branch stays untouched.

3. Writing Plans. The approved spec gets broken into bite-sized tasks of 2-5 minutes each. Every task has exact file paths, complete code snippets, and verification steps. The plan is written assuming the implementer has "zero context for the codebase and questionable taste." DRY. YAGNI. TDD.

4. Subagent-Driven Development. A fresh subagent is dispatched per task. It never inherits the coordinator's session context. The coordinator crafts exactly the context each subagent needs. This isolation prevents context pollution and keeps the coordinator's window clean for oversight.

5. Test-Driven Development. The Iron Law: no production code without a failing test first. Write code before the test? Delete it. Do not keep it as "reference." Do not "adapt" it while writing tests. Do not look at it. Delete means delete.

6. Code Review. Two-stage review after each task. First, a spec reviewer checks whether the code matches the plan. Then a quality reviewer checks whether the code is clean. Different subagents, different lenses. Critical issues block progress.

7. Finishing the Branch. After all tasks complete, a final reviewer examines the entire implementation. The agent presents options: merge, create a PR, keep the branch, or discard it. It cleans up the worktree.

Subagent-Driven Development: The Secret Weapon

The most innovative skill in the library is subagent-driven development. The core principle is deceptively simple: fresh subagent per task plus two-stage review equals high quality with fast iteration.

Why does this matter? Because LLMs degrade as their context window fills up. By the fifth task in a long session, the agent is working with thousands of tokens of accumulated conversation. It starts making mistakes. It forgets constraints. It drifts from the plan.

Superpowers solves this by treating each task as an isolated unit of work. The coordinator reads the plan, picks the next task, crafts a precise prompt with just the context that task needs, and dispatches a fresh subagent. That subagent does its work, gets reviewed, and terminates. The coordinator stays clean.

The review is two-stage by design. A spec reviewer asks: does the code do what the plan specified? A quality reviewer asks: is the code well-structured? These are deliberately separate concerns. Conflating them means one always dominates the other.

The model selection guidance is pragmatic. Mechanical implementation tasks (isolated functions, clear specs, 1-2 files) should use the cheapest model available. Integration tasks use a standard model. Architecture and review tasks use the most capable model. This keeps costs down without sacrificing quality where it matters.

The Iron Law of TDD

Most coding agents pay lip service to testing. Superpowers makes it non-negotiable.

The test-driven-development skill enforces a strict Red-Green-Refactor cycle. RED: write one minimal failing test showing what should happen. Verify it fails correctly. GREEN: write the simplest code that makes the test pass. Nothing extra. REFACTOR: clean up while staying green. Commit.

A circular diagram rendered in crosshatched ink showing three stages. A red section labeled Write Failing Test. A green section labeled Minimal Code. A blue section labeled Refactor. Arrows connect them in a continuous cycle. In the center the word DELETE appears with an arrow pointing to discarded code.
Red-Green-Refactor is mandatory. Write code before the test? Delete it. Start over.

The skill includes a testing anti-patterns reference document that catalogs common mistakes: testing implementation details instead of behavior, writing tests that always pass, using overly broad assertions, and skipping edge cases. The agent reads this before writing any test.

The "delete it" directive is the most aggressive rule in the framework. It targets the rationalization every developer recognizes: "I already wrote the code, I'll just write tests around it." That approach produces tests that verify the code works as written, not tests that verify the code works as specified. The distinction matters.

How It Actually Installs

Superpowers runs as a plugin across multiple platforms. The installation differs by tool, but the experience converges once running.

For Claude Code, it is available through the official Anthropic plugin marketplace since January 2026:

/plugin install superpowers@claude-plugins-official

For Cursor, you install from the plugin marketplace or search for "superpowers" in the agent chat. For Codex and OpenCode, you tell the agent to fetch and follow install instructions from a raw GitHub URL. Gemini CLI uses a native extensions command.

Once installed, the skills trigger automatically. You do not need to invoke them. The agent checks for relevant skills before any task. The brainstorming skill activates before creative work. The TDD skill activates during implementation. The review skill activates between tasks. It is a methodology, not a tool you remember to use.

What Is Inside the Skills Library

The repository contains 14 skills organized into four categories.

Testing. The test-driven-development skill with its companion testing-anti-patterns reference. This is the enforcement backbone.

Debugging. A systematic-debugging skill that follows a four-phase root cause process including root-cause tracing, defense-in-depth, and condition-based waiting techniques. Plus a verification-before-completion skill that ensures the bug is actually fixed before the agent declares victory.

Collaboration. This is the largest category. Brainstorming for Socratic design refinement. Writing-plans for detailed implementation plans. Executing-plans for batch execution with human checkpoints. Dispatching-parallel-agents for concurrent workflows. Requesting and receiving code review. Using git worktrees for parallel branches. Subagent-driven development for fast iteration. Finishing a development branch for the merge decision.

Meta. A writing-skills skill that teaches the agent how to create new skills following best practices. And a using-superpowers skill that introduces the system itself. The framework is self-extending.

A library wall with labeled skill books on shelves organized into four sections: Testing, Debugging, Collaboration, and Meta. Each book spine shows a skill name. An agent hand reaches for the brainstorming book while the test-driven-development book glows to indicate it is always active.
Fourteen skills across four categories. The agent loads them on-demand, not all at once.

The Persuasion Science Behind It

The skills are not just checklists. They are carefully engineered prompts that leverage how LLMs respond to directive language.

Vincent applies Robert Cialdini's principles of persuasion. Authority: "Skills are mandatory when they exist." Commitment: The agent must announce which skill it is using at the start. Social proof: "This is how senior engineers work." Scarcity/Urgency: Production is down, costing $5K/minute. Check the skill or start debugging now.

The hard gates are the most critical technique. Each skill includes explicit blocks on proceeding without completion. The brainstorming skill blocks code until design is approved. The TDD skill blocks production code until a failing test exists. The review skill blocks the next task until issues are resolved. These are not suggestions the agent can weigh. They are directives.

The anti-pattern sections are equally deliberate. By naming the exact rationalization the agent might use ("This is too simple to need a design"), the skill preempts it. The agent cannot use that excuse because the skill already acknowledged and rejected it.

The Competitive Landscape

Superpowers exists in a rapidly evolving space. Understanding where it fits requires looking at what it is not.

Approach What It Does Limitation
CLAUDE.md / .cursorrules Static configuration files with project conventions No workflow enforcement, no skill composition, no subagent orchestration
Custom system prompts One-shot instructions injected at session start No modularity, no hard gates, grows unwieldy at scale
LangChain / LangGraph Agent orchestration frameworks for building custom pipelines Requires building the workflow yourself, not opinionated about methodology
CrewAI Multi-agent role-based task execution Focused on agent coordination, not engineering discipline enforcement
Superpowers Composable skills with mandatory gates, subagent isolation, and TDD enforcement Opinionated: you adopt its methodology or you do not use it

The distinction is important. Superpowers is not an orchestration framework. It does not help you build custom agent pipelines. It is an opinionated methodology that happens to be delivered as composable skills. You adopt the whole approach: brainstorm before building, plan before coding, test before implementing, review before merging.

This is its strength and its constraint. If you want to enforce your own methodology, Superpowers may not be the right fit. If you want a proven methodology enforced for you, it is the only game in town at this scale.

Real-World Results

The numbers tell a compelling story. Developers report autonomous coding sessions exceeding two hours where Claude completes multi-file refactors, implements features end-to-end, and handles edge cases without constant supervision.

One frequently cited case: a solo developer delivered a project scoped as "four people for six months" in two months working alone using Superpowers. The plan-then-execute workflow eliminated the coordination overhead that makes team projects slow, while the TDD enforcement caught bugs that would have required weeks of debugging later.

The growth trajectory validates the demand. From zero to 93,000 stars in five months. Accepted into the official Anthropic Claude plugin marketplace. More installs than Playwright. Support expanded to Cursor, Codex, Gemini CLI, and OpenCode.

"After you've signed off on the design, your agent puts together an implementation plan that's clear enough for an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing to follow."

-- Jesse Vincent, Superpowers README

The Architecture Under the Hood

The repository is primarily Shell scripts (57%), JavaScript (30%), and Python (4%). The skills themselves are pure markdown. This is deliberate: markdown is the native language of LLMs. No compilation, no runtime, no dependencies.

The hook system fires a session-start script that searches for relevant skills and loads them into the agent's context. Skills reference each other by name. The brainstorming skill transitions to writing-plans. Writing-plans transitions to subagent-driven-development or executing-plans. The chain is explicit.

Each skill includes a "When to Use" section with a decision tree rendered as a Graphviz dot diagram. The subagent-driven-development skill, for example, asks: Have an implementation plan? Tasks mostly independent? Want to stay in this session? The decision tree routes to the appropriate skill.

The subagent prompts (implementer-prompt.md, spec-reviewer-prompt.md, code-quality-reviewer-prompt.md) live alongside each skill. The coordinator reads these templates and injects task-specific context before dispatching. This separation means the prompts can be refined independently of the coordination logic.

A tree diagram showing the repository structure. At the top is the hooks directory with session-start. Below it branches into skills with 14 labeled nodes. Each skill node has sub-nodes for SKILL.md and prompt files. Commands and agents directories branch off separately.
The repository structure is flat and readable. Skills are markdown files. The magic is in the methodology, not the machinery.

Who Built This

Jesse Vincent (GitHub: obra) has been building developer tools for over two decades. He created Request Tracker, one of the earliest widely-adopted open-source ticket tracking systems. He created K-9 Mail, the popular Android email client. He was the project lead for Perl. He co-founded Keyboardio, a hardware keyboard company.

Superpowers is built by Vincent and the team at Prime Radiant, his current company. Prime Radiant is not "The Superpowers Company," but Vincent has committed corporate resources to supporting and giving away the framework as open source under the MIT license.

The project has an active community on Discord and accepts contributions following its own writing-skills skill as the guide for creating new skills.

What Comes Next

Version 5.0 shipped in March 2026 with restored user choice between subagent-driven development and executing-plans (the previous version had made subagent-driven mandatory). The recent additions of Gemini CLI support and the official Anthropic marketplace listing suggest the framework is moving toward being platform-agnostic.

The self-extending nature of the framework (the writing-skills skill teaches agents how to create new skills) means the library will grow through community contributions. The composable architecture means new skills slot in without modifying existing ones.

The deeper question is whether this approach scales beyond individual developers and small teams. The methodology is sound. The enforcement mechanism works. The open question is whether organizations will adopt an opinionated external framework or build internal equivalents. Given the adoption curve, the answer so far is clear.