Superpowers: The 89K-Star Skills Framework That's Reshaping How Developers Use AI Agents

You Are Probably Using 30% of Your AI Agent

Most developers install Claude Code, type a prompt, and get code back. The code is usually good. Sometimes it is excellent. And yet something is off. The agent writes implementation before tests. It guesses at architecture instead of asking questions. It fixes symptoms instead of root causes. It works fast, but it works like an enthusiastic intern who skips the boring parts.

This is not the agent's fault. Large language models are trained to be helpful, which in practice means they rush to produce output. Ask for a feature and the agent starts writing code. It does not stop to ask what you actually need. It does not write a spec. It does not plan the file structure. It certainly does not write a failing test first.

Jesse Vincent noticed this pattern and decided to fix it. Not by building a new model or a new tool, but by giving existing agents a set of rules to follow. The result is Superpowers, a framework of composable skills that turns your AI coding agent from a fast typist into a disciplined engineering partner. As of March 2026, it has over 89,000 GitHub stars and is one of the fastest-growing developer tools in history.

The idea is disarmingly simple: if your agent is smart but undisciplined, give it discipline.

Who Made This and Why

Jesse Vincent is not new to building tools that developers depend on. He created Request Tracker (RT), the open-source ticket tracking system, back in the 1990s. He managed the Perl 6 project from 2005 to 2008. He co-founded Keyboardio, the artisan keyboard company. He built K-9 Mail for Android, which Mozilla later acquired and rebranded as Thunderbird for Android. The common thread: Jesse builds infrastructure that other people rely on, and he obsesses over workflow.

Superpowers grew out of Jesse's own experience using Claude Code for serious software development. He found that the agent was capable but inconsistent. Left to its own devices, it would skip tests, implement features before understanding requirements, and apply quick fixes to bugs it had not properly diagnosed. These are not AI problems. They are engineering discipline problems. A junior developer does the same things.

The insight was that AI agents respond to structure. You cannot lecture them about best practices and expect compliance. But you can give them explicit, step-by-step workflows and hard gates that block progress until conditions are met. A skill that says "write tests first" is ignored. A skill that says "NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST. Write code before the test? Delete it. Start over." is followed.

This is the philosophical core of Superpowers: treat your AI agent like a powerful but undisciplined junior engineer, and give it the process guardrails that turn junior engineers into senior ones.

The Core Skills

Superpowers ships with over a dozen skills organized into a complete development workflow. Each skill is a SKILL.md file containing explicit instructions, hard gates, and process flows. Here are the ones that matter most.

Brainstorming: Explore Before Building

The brainstorming skill activates before any creative work. It has a hard gate:

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.

The skill forces the agent to explore your project context first (reading files, docs, recent commits), then ask clarifying questions one at a time, propose 2-3 approaches with trade-offs, present the design in sections for approval, and write a spec document. Only after you approve the written spec does it transition to implementation.

Why this matters: most wasted work in software development comes from building the wrong thing. The agent may be fast, but if it builds the wrong thing fast, you have lost more time than if it had asked two questions first.

Superpowers 5, released in early March 2026, added visual brainstorming tools that generate HTML mockups in-browser instead of ASCII diagrams. When a design involves visual elements, the agent offers a "visual companion" before asking clarifying questions.

Writing Plans: Spec Before Code

Once you approve a design, the writing-plans skill breaks it into bite-sized tasks. Each task is 2-5 minutes of work with exact file paths, complete code context, and verification steps. The plan is written assuming the implementer has "zero context for your codebase and questionable taste."

This sounds harsh, but it is practical. When the agent dispatches subagents to execute tasks (more on this below), each subagent starts with a fresh context. The plan must be detailed enough that a new agent, knowing nothing about your project, can complete each step correctly.

Plans enforce DRY (Do not Repeat Yourself), YAGNI (You Are not Gonna Need It), and TDD. Every task includes what to test, how to test it, and what the expected output looks like.

Test-Driven Development: Test Before Implementation

The TDD skill is the strictest in the framework. It has what the documentation calls "The Iron Law":

NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST. Write code before the test? Delete it. Start over. No exceptions.

The cycle is classic red-green-refactor: write a failing test, verify it fails for the right reason, write the minimum code to make it pass, verify all tests pass, refactor. The skill includes an anti-patterns reference that catalogues common TDD mistakes.

This is the skill that draws the strongest reactions. Some developers love it because it finally makes their AI agent write tests. Others resist it because they do not practice TDD themselves. But the results speak for themselves. When chardet shipped version 7.0.0 using the Superpowers methodology, it delivered 41x faster performance and 96.8% accuracy while fixing dozens of longstanding issues. The comprehensive test suite covering 2,161 files across 99 encodings was a direct product of the TDD skill.

Systematic Debugging: Diagnose Before Fixing

The systematic-debugging skill enforces a four-phase process: root cause investigation, hypothesis formation, targeted fix, and verification. Like TDD, it has an iron law:

NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.

The skill explicitly warns against the situations where developers most want to skip the process: "Use this ESPECIALLY when under time pressure. Emergencies make guessing tempting." It includes techniques for root-cause tracing, defense-in-depth analysis, and condition-based waiting.

This addresses one of the most common AI agent failure modes. Without guidance, an agent encountering a bug will try random fixes, and if the first fix makes the error message go away, it declares victory. The debugging skill forces the agent to understand the error before touching code.

Code Review: Verify Before Merging

The requesting-code-review skill dispatches a separate subagent to review completed work. The reviewer gets precisely crafted context for evaluation, never the implementing agent's session history. This prevents the reviewer from being biased by knowing the implementer's reasoning.

Reviews check against the implementation plan, report issues by severity, and critical issues block progress. The receiving-code-review skill handles the other direction: how to respond to feedback without getting defensive or making unrelated changes.

Subagent-Driven Development: Parallelize Independent Tasks

This is where Superpowers moves from "good practices" to "architectural innovation." The subagent-driven-development skill dispatches a fresh agent per task from the implementation plan, with two-stage review after each: spec compliance first, then code quality.

Each subagent starts with clean context. It receives only its specific task description and the relevant context, not the full conversation history. This prevents context pollution (where accumulated context degrades the agent's judgment) and allows the coordinating agent to manage many tasks without running out of context window.

The result: it is not uncommon for Claude to work autonomously for a couple of hours at a time without deviating from the plan. The coordinating agent dispatches tasks, reviews results, handles failures, and continues forward, only escalating to the human when something genuinely requires judgment.

The Philosophy: Rigid Where It Matters, Flexible Where It Does Not

Not all Superpowers skills work the same way. Some are rigid, with hard gates that block progress. Others are flexible, providing guidance without enforcement. The distinction is deliberate.

TDD and systematic debugging are rigid. They have iron laws, explicit prohibitions, and delete-and-restart consequences. These are skills where cutting corners causes compounding damage. A test you skipped today becomes a regression you spend hours debugging tomorrow. A root cause you did not investigate becomes three more bugs downstream.

Brainstorming is structured but adaptive. It has a checklist and a hard gate (no code before design approval), but the questions it asks and the approaches it proposes vary based on context. A todo list gets a brief design. A distributed system gets a thorough one.

Code review is advisory. It reports findings and severity levels, but the human decides which issues to fix and which to accept.

This is the "explain why, not what" approach. Each skill explains its reasoning: why tests must fail before passing, why root causes matter more than symptoms, why fresh context for subagents prevents drift. The agent follows the rules because it understands the principles behind them, not because it was told to follow rules blindly.

Installation and Usage

Superpowers installs differently depending on your platform.

Claude Code (Official Marketplace)

Since January 2026, Superpowers is in the official Anthropic marketplace:

/plugin install superpowers@claude-plugins-official

Or via the community marketplace:

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

Cursor

/add-plugin superpowers

Or search "superpowers" in the Cursor plugin marketplace.

Codex CLI

Tell Codex:

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md

Gemini CLI

gemini extensions install https://github.com/obra/superpowers

How Skills Trigger

Once installed, skills trigger automatically. Start a session and ask to build a feature. The agent detects the task type and activates the brainstorming skill. Approve the design, and it activates writing-plans. Start implementing, and TDD kicks in. Encounter a bug, and systematic-debugging takes over.

You can also invoke skills manually by referencing them in conversation: "Use the brainstorming skill to help me think through this." But the automatic triggering is the point. You do not need to remember which skill to use. The framework handles orchestration.

Verify It Works

Start a new session and ask for something that should trigger a skill, like "help me plan this feature" or "let's debug this issue." If Superpowers is installed correctly, the agent announces which skill it is using and follows the structured process instead of jumping straight to code.

Cross-Agent Compatibility

One of Superpowers' most significant design decisions is platform agnosticism. The framework works with Claude Code, Cursor, Codex CLI, OpenCode, Gemini CLI, Qwen Code, Goose CLI, and Auggie. This is possible because skills are Markdown files, not platform-specific plugins. Any agent that can read a SKILL.md file can follow the instructions inside it.

This makes Superpowers a portable methodology. If your team uses Claude Code but a colleague prefers Codex CLI, both agents can run the same skills. The brainstorming process, the TDD enforcement, the subagent coordination -- all of it transfers. The cross-agent skills ecosystem is rapidly converging on this model: knowledge encoded once, applied everywhere.

That said, Claude Code has the deepest integration. Features like allowed-tools for sandboxing, automatic plugin updates, and native subagent support mean some skills (particularly subagent-driven development) work best on Claude Code. Other agents get the core workflow without the advanced orchestration.

Writing Your Own Skills on Top of Superpowers

Superpowers is a foundation, not a ceiling. The framework includes a writing-skills skill that teaches the agent how to create new skills following best practices. This is meta, yes, but it means you can extend Superpowers with domain-specific skills for your team.

Common extensions include:

• Deployment skills that enforce your team's release checklist
• Architecture decision record (ADR) skills that document design choices
• Security review skills that check for your industry's compliance requirements
• Onboarding skills that encode tribal knowledge for new team members

The key is that your custom skills compose with the existing ones. Your deployment skill can depend on the code-review skill completing first. Your ADR skill can plug into the brainstorming workflow.

For a detailed guide on writing effective skills, see How to Write Your First SKILL.md. For the design principles that separate good skills from the 490K+ noise, read What Makes a Good Skill.

What Makes This Different from Good Prompts

You might wonder: could you get the same results by writing detailed prompts? Put TDD instructions in your CLAUDE.md, add "always ask clarifying questions" to your system prompt, and skip the framework entirely?

You could try. It would not work the same way. Here is why.

A single prompt instruction is a suggestion. The agent follows it when convenient and ignores it under pressure. Tell Claude to "always write tests first" in your CLAUDE.md, and it will write tests first for the first three tasks. By the fourth task, when context is getting long and the problem is getting complex, it quietly skips the tests. You will not notice until something breaks.

A Superpowers skill is a process with enforcement mechanisms. The TDD skill does not suggest writing tests first. It mandates it with an iron law, includes explicit instructions to delete code written before tests, and structures every implementation step around the red-green-refactor cycle. It is the difference between a speed limit sign and a speed bump. One informs. The other physically prevents the behavior.

The compounding effect matters too. Individual skills are useful. TDD alone improves code quality. Brainstorming alone reduces wasted work. But the framework together changes how you work. Brainstorming produces a spec. The spec feeds into a plan. The plan feeds into subagent-driven development. Subagents follow TDD. Code review catches what TDD missed. Each skill's output is the next skill's input.

Think of it like chess. Knowing individual moves (how the knight jumps, how the bishop slides) makes you a beginner. Understanding opening theory, middlegame strategy, and endgame technique makes you a player. Superpowers is not a collection of moves. It is a strategy for how the moves fit together.

Getting Started: 5 Steps

Here is the shortest path from "interested" to "using Superpowers productively":

1. Install Superpowers on your preferred agent. For Claude Code: /plugin install superpowers@claude-plugins-official.

2. Start a real task, not a toy example. Pick a feature you actually need to build or a bug you need to fix. The framework shines on real work, not "hello world."

3. Follow the brainstorming skill. When the agent starts asking questions instead of writing code, resist the urge to say "just build it." Answer the questions. Approve the design. Watch how much clearer the implementation becomes.

4. Let TDD run. The first time the agent writes a failing test, watches it fail, then writes minimal code to pass, you will feel the difference. The code that emerges from this cycle is smaller and more focused than what the agent would have written without it.

5. Review and extend. After your first project with Superpowers, you will know which parts of the workflow fit your style and which need adjustment. Write a custom skill for the parts that do not fit. The skill development workflow covers the process end to end.

Superpowers is not a magic wand. It will not turn a bad project plan into a good one or make a fundamentally wrong architecture work. What it does is ensure that the easy mistakes, the ones caused by rushing, by skipping steps, by not asking questions, do not happen. For most projects, those easy mistakes are the ones that cost the most time.

The framework is open source under MIT license, actively maintained, and growing fast. It went from zero to 89,000 stars in five months. That trajectory does not happen unless the tool solves a real problem for a lot of people.

If you use an AI coding agent and you have ever thought "this would be great if it just slowed down and did things properly," Superpowers is exactly that. Discipline for AI agents. It turns out that is all they needed.