What Is Superpowers? Give Claude Code a Senior Dev Workflow

You’ve been using Claude Code to write software, but every session feels like rolling the dice — sometimes it nails the architecture, sometimes it skips tests and bulldozes through your codebase. One open-source developer named Jesse Vincent built a plugin that enforces the exact workflow a senior engineer would follow, and over 80,000 developers have already installed it. In this article, you’ll learn exactly what Superpowers is, how to install it in under two minutes, and how it transforms Claude Code from a fast typist into a disciplined development partner.

What Is Superpowers?

Last fall, Jesse Vincent — the developer behind Request Tracker and a long-time open-source contributor — got frustrated. He was using Claude Code daily, and it was fast. But fast doesn’t mean good. Claude would jump straight into implementation, skip the design phase, ignore edge cases, and write code before writing tests. It was like hiring a brilliant junior developer who refuses to slow down and think — a pattern we’ve seen across AI software engineers like Devin and other agentic tools.

So Vincent built Superpowers — a framework of composable “skills” that automatically activate during development tasks and force Claude Code through a disciplined engineering workflow. Instead of letting the AI improvise, Superpowers makes it brainstorm requirements, write a design spec, break the work into micro-tasks, execute those tasks with test-driven development, and then review its own work before declaring victory.

Here’s the thing: Superpowers isn’t a different AI model. It’s the same Claude you’re already using. The plugin works by injecting structured instructions — called skills — that guide Claude’s behavior. Think of it as giving Claude Code a senior engineer’s playbook instead of letting it wing it.

The project hit a nerve. With over 80,000 GitHub stars and 6,000+ forks, it became the most widely adopted agentic development framework in the ecosystem. In January 2026, Anthropic accepted it into the official Claude Code plugin marketplace, which means you can install it with a single command.

But the star count isn’t what matters. What matters is whether it actually changes how Claude writes code — and it does. Let’s look at why.

Why Should You Care About Superpowers?

If you’ve used Claude Code for anything beyond simple scripts, you’ve probably hit the same wall. You ask Claude to build a feature, and it writes 200 lines of code in 30 seconds. Impressive speed. But then you realize it didn’t consider the existing architecture, didn’t write tests, and made assumptions about your database schema that aren’t true.

This is the core problem Superpowers solves. It adds friction in the right places — the places where a human senior developer would naturally pause to think.

Without Superpowers, a typical Claude Code session looks like this: you describe what you want, Claude writes code, you review it, you find problems, you ask Claude to fix them, it introduces new problems, and you spend more time debugging AI output than you would have spent writing the code yourself.

With Superpowers, the same session follows a different arc. Claude asks clarifying questions first. It writes a design spec and waits for your approval. It breaks the work into 2-5 minute tasks with exact file paths and function signatures. It writes a failing test before writing any implementation code. And it reviews its own work against the original spec before moving on.

Here’s what that means in practice: you spend less time babysitting and more time making decisions. Claude becomes the implementer. You become the architect.

And the best part? The workflow isn’t optional. Superpowers uses what Vincent calls “mandatory triggers” — skills that activate automatically based on context, not because you remembered to ask for them. If Claude is about to start coding without a plan, the planning skill fires. If it writes implementation before tests, the TDD skill intervenes.

How Does Superpowers Compare to Other AI Dev Tools?

You might be wondering how this stacks up against Cursor, Devin, SWE-Agent, or just using Claude Code on its own. The key distinction is that Superpowers isn’t a competing product — it’s a layer on top of Claude Code that changes its behavior.

Cursor gives you AI-assisted editing inside a VS Code fork. It’s great for inline completions and chat-driven edits, but it doesn’t enforce a development methodology. You still decide when to plan and when to test.

Devin positions itself as an autonomous AI software engineer — it runs in its own environment, opens PRs, and works independently. But that autonomy comes with less control. You hand off the work and hope for the best.

SWE-Agent is excellent at fixing specific GitHub issues. Point it at a bug, and it’ll diagnose and patch it. But it’s a single-task tool, not a full development workflow.

Superpowers takes a different approach. It keeps you in the loop as the decision-maker while making Claude Code follow a structured process for every task. You still approve the design. You still review the plan. But Claude does the heavy lifting of implementation, testing, and self-review — in the right order, every time.

The Core Skills Inside Superpowers

Superpowers ships with a library of skills that cover the full development lifecycle. Each skill is a markdown document that teaches Claude a specific workflow. Here are the ones that matter most:

Brainstorming is where every session starts. Instead of diving into code, Claude asks you Socratic questions about requirements, constraints, edge cases, and success criteria. It pushes back on vague requests and helps you refine the idea before a single line of code gets written. This alone eliminates the most common failure mode — building the wrong thing fast.

Planning takes the brainstorm output and generates a detailed implementation plan. Each task is scoped to 2-5 minutes of work with exact file paths, function signatures, and acceptance criteria. The plan isn’t a vague outline — it’s a step-by-step blueprint that a subagent can execute without ambiguity.

Subagent-Driven Development is where the real power shows up. Once you approve the plan, Superpowers dispatches specialized subagents to execute each task in parallel. Each subagent works in an isolated git worktree, writes tests first, implements the feature, and submits its work for a two-stage review. This means Claude can work on multiple tasks simultaneously without conflicts.

Test-Driven Development is non-negotiable in Superpowers. The framework enforces a strict RED-GREEN-REFACTOR cycle. Write a failing test. Make it pass. Clean up the code. If Claude tries to skip the failing test and jump straight to implementation, the skill intervenes and forces it to restart with a test. Vincent built this constraint deliberately — he found that without it, Claude would consistently skip tests to save time.

Code Review runs after every task completion. Claude reviews its own work against the original plan specifications, checking for missed requirements, untested edge cases, and code quality issues. This catches problems before they reach you.

How to Install Superpowers

Installation takes less than two minutes. You need Claude Code version 2.0.13 or later.

Open Claude Code and run these two commands in sequence:

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

Quit Claude Code and restart it. That’s it.

If you want Superpowers active in every project without per-project setup, add the global flag:

/plugin install superpowers@superpowers-marketplace --global

Global install is what most developers choose. You get the structured workflow everywhere — personal projects, work repos, open-source contributions — without remembering to activate it each time.

To verify it’s working, start a new conversation and ask Claude to build something. Instead of jumping into code, it should start with brainstorming questions. If it does, Superpowers is active.

Superpowers also supports other platforms beyond Claude Code. Cursor users can install it through settings, and there are manual setup instructions for Codex, OpenCode, and Gemini CLI. But the Claude Code installation is the most seamless since it’s an official marketplace plugin.

How the Workflow Actually Works

Let’s walk through a real session to see Superpowers in action. Say you ask Claude to add user authentication to your Express.js app.

Without Superpowers, Claude would immediately start writing passport.js middleware, JWT token handlers, and login routes — all in one giant code dump. Maybe it works. Maybe it doesn’t match your existing session management.

With Superpowers, the session unfolds differently. Claude starts by asking questions: What authentication method do you want — session-based, JWT, or OAuth? Do you have an existing user table? What’s your current middleware stack? Are there specific routes that need protection?

Once you’ve answered, Claude writes a design spec. It lists every component it plans to build, the files it will modify, and the tests it will write. You review and approve — or push back.

Then Claude breaks the spec into micro-tasks. Task 1: Create user model with password hashing. Task 2: Write registration endpoint with validation. Task 3: Write login endpoint with JWT generation. Each task has a defined input, output, and test case.

Now, here’s where it gets interesting. Superpowers can dispatch subagents to work on independent tasks in parallel. Each subagent creates an isolated git worktree — a separate branch and working directory — so there are no merge conflicts during execution. When a subagent finishes, its work goes through a two-stage review before merging back.

Think about it this way: instead of one Claude doing everything sequentially, you have a team of specialized Claudes working in parallel — similar to how CrewAI orchestrates multi-agent teams, but built directly into your Claude Code workflow. You’re the tech lead. Claude agents are your development team.

Creating Your Own Custom Skills

Superpowers ships with a meta-skill — a skill for creating new skills. This means you can extend the framework with your own workflows.

A skill is just a markdown file (SKILL.md) that follows a specific structure. It describes when the skill should activate, what process to follow, and what the expected output looks like. You can create skills for anything your team does repeatedly: database migrations, API design reviews, security audits, deployment checklists.

Here’s what the process looks like. You describe the workflow you want to encode — say, a checklist your team runs before every database migration. Claude reads the existing skills as examples, then generates a new SKILL.md that follows the same patterns. The skill automatically triggers when Claude detects a migration-related task.

This is where Superpowers becomes more than a plugin. It becomes a way to encode your team’s engineering culture into the AI’s behavior. The skills you create are version-controlled markdown files that live in your repo. New team members — human or AI — inherit the same workflows automatically.

What to Do Next

Open Claude Code, install Superpowers with the two commands above, and then ask Claude to build something you’ve been putting off. Watch how the brainstorming phase catches requirements you would have missed, and how the micro-task plan gives you confidence that the implementation will be thorough. The first session with Superpowers running is the one that convinces you.

obra / superpowers

An agentic skills framework & software development methodology that works.

Shell 124.7k 10.2k MIT

Frequently Asked Questions

Is Superpowers free?

Yes. Superpowers is completely free and open-source under the MIT license. There are no paid tiers or premium features. The entire framework — all skills, instructions, and updates — is available at no cost.

Does Superpowers work with Cursor or other editors?

Superpowers supports multiple platforms including Claude Code, Cursor, Codex, OpenCode, and Gemini CLI. The Claude Code integration is the most seamless since it’s available through the official plugin marketplace. Other platforms require manual setup via instruction fetching.

Will Superpowers slow down Claude Code?

The brainstorming and planning phases add time upfront — typically 2-5 minutes before implementation starts. But this time is recovered many times over by eliminating the debug-fix-debug cycle that happens when Claude codes without a plan. Most developers report finishing tasks faster overall.

Can I disable specific skills?

Yes. Skills are modular and can be individually enabled or disabled. If you want planning but not TDD enforcement, you can configure that. However, the skills are designed to work together — disabling TDD often leads to the same quality issues Superpowers was built to prevent.

How is Superpowers different from CLAUDE.md instructions?

CLAUDE.md files are static project-level instructions. Superpowers skills are dynamic — they activate based on context, enforce multi-step workflows, and include self-correction mechanisms. Think of CLAUDE.md as a note taped to the monitor. Superpowers is a process that Claude actively follows.

Who created Superpowers?

Jesse Vincent (GitHub: obra), an open-source developer known for creating Request Tracker and contributing to the Perl ecosystem. He built Superpowers after months of daily Claude Code usage revealed consistent failure patterns that static instructions couldn’t fix.