⚡ TLDR

What it solves: AI agents often rush to write code before they understand the problem; Superpowers forces them to slow down
Why it matters: Slower at the beginning, but far less rework later because the agent plans, tests, and reviews like a grown-up
Best for: People using Claude Code, Cursor, Codex, OpenCode, or Gemini who want AI help without turning their repo into a junk drawer
Main differentiator: It is not one more prompt pack. It is a full workflow with mandatory skills and checkpoints

Superpowers: The Workflow That Teaches AI Agents Discipline

Part 1: Foundations — The Mental Model

The first time I let an AI agent work too freely, it felt magical.

I asked for one feature. It gave me five. The code compiled. The tests passed. For a moment I felt clever.

A little later, the bill arrived. There was code for cases I never asked about, abstractions nobody needed, and tests that looked busy without really proving much. Everything was technically there. Only the judgment was missing.

This is the dangerous thing about AI coding tools: when they are wrong, they are often wrong in a very energetic way. They do not just misunderstand you. They misunderstand you at high speed.

After a while I realized the problem was not intelligence. The problem was impulse.

Think of two builders. One hears you say, “I need a shelf,” then immediately starts sawing wood. The other asks where the shelf goes, how much weight it must hold, whether the wall is concrete or plaster, whether you even need a shelf or just a box with a door.

The first builder feels fast. The second builder feels annoying. Until six months later, when the shelf is still on the wall.

That, to me, is the mental model for Superpowers. It is not a bigger hammer for your agent. It is the habit of asking a few boring questions before creating a big mess.

Superpowers turns the agent into the second builder. Brainstorm first. Plan second. Test before code. Review before celebration. None of these ideas are new. That is precisely why they matter.

Part 2: The Investigation — What It Actually Contains

When I looked through the repository, what struck me was how little of it tries to impress you.

There is no grand theory hidden under the floorboards. The basic idea is simple: if the agent is about to do real work, it should automatically invoke the right skill and follow a workflow. Not maybe. Not if it feels like it. Automatically.

At a high level, the workflow looks like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Developer Request
    ↓
1. Brainstorming
   └─ clarify what you actually want
   └─ compare alternatives
   └─ get sign-off on design
    ↓
2. Git worktrees
   └─ isolate the work on its own branch
   └─ verify a clean baseline
    ↓
3. Writing plans
   └─ break work into small explicit tasks
   └─ define exact files and verification
    ↓
4. Subagent-driven development
   └─ fresh context per task
   └─ review against spec and code quality
    ↓
5. Test-driven development
   └─ red, green, refactor
   └─ no code before failing test
    ↓
6. Code review
   └─ block progress when the work is wrong
    ↓
7. Finish branch
   └─ verify tests
   └─ merge, PR, keep, or discard

That may sound ordinary. It is ordinary. Most good engineering habits are.

The repository is organized around those habits. There are skills for brainstorming, writing plans, executing plans, TDD, code review, debugging, worktrees, and finishing a branch. There are also installation paths for different agent ecosystems: Claude Code, Cursor, Codex, OpenCode, Gemini CLI. The implementation details differ by platform, but the underlying attitude stays the same.

The part I liked most was the lack of romance. Superpowers does not sell you on genius. It assumes the agent will drift if left alone, so it puts rails on the road.

That is rarer than it should be. The software world loves tools that promise to make us feel powerful. Much rarer are tools that politely force us to behave.

Part 3: The Diagnosis — What Changes In Practice

The easiest way to understand Superpowers is not to read its philosophy section. It is to compare what happens before and after discipline enters the room.

1. Vague requests become smaller, clearer requests

Without Superpowers:

1
2
3
4
5
User: "Add user authentication"
Agent: starts writing immediately

One hour later you have login, reset password, token rotation,
three abstractions, and a strange new helper nobody asked for.

With Superpowers:

1
2
3
4
5
6
7
8
User: "Add user authentication"
Agent asks first:
  - local passwords or OAuth?
  - sessions or tokens?
  - do you need reset flow now, or later?
  - any rate limit on login attempts?

Only after that does it write a design and move on.

This sounds slow only if you have never had to delete code. Deletion is often the most expensive part.

2. Big scary tasks become small boring tasks

Without Superpowers:

1
2
3
4
5
Plan: "Implement user authentication"
Agent writes until it feels finished.

Now the tests, schema, routes, and middleware are all entangled,
which is another way of saying tomorrow will be unpleasant.

With Superpowers:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Task 1: create User model
  files: exact files listed
  verify: exact command listed

Task 2: create POST /auth/login
  files: exact files listed
  verify: exact command listed

Task 3: set JWT in httpOnly cookie
  files: exact files listed
  verify: exact command listed

At first this feels fussy. Then you realize fussy is good. A plan should be boring enough that almost anyone can execute it without improvising. Improvisation is where many AI agents become artists, and codebases rarely need more artists.

3. Tests stop being decoration

Without Superpowers:

1
2
3
4
5
6
7
Agent writes code first:
  function validateEmail(email) {
    return email.includes("@");
  }

A bad email gets through.
Later someone discovers it in production, which is always the most expensive place to learn anything.

With Superpowers (TDD enforcement):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
Agent writes test first:
  test("rejects emails with multiple @", () => {
    expect(validateEmail("foo@[email protected]")).toBe(false);
  })

Then writes only enough code to pass:
  function validateEmail(email) {
    const parts = email.split("@");
    return parts.length === 2 && parts[0].length > 0 && parts[1].length > 0;
  }

This is not glamorous. Neither is insurance. Both become very interesting right after something goes wrong.

The common theme across all three scenarios is simple: Superpowers reduces the amount of pretending. The agent pretends less that it understands. Pretends less that a vague task is clear. Pretends less that untested code is safe.

Part 4: The Resolution — Getting Started with Superpowers

Superpowers is for people who have already been impressed by AI coding tools, and are now ready for a more boring ambition: they want code they can live with.

Installation: 2 Minutes

Pick your platform:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
# Claude Code (Official Marketplace - Easiest)
/plugin install superpowers@claude-plugins-official

# Cursor Agent
/add-plugin superpowers

# Codex
Fetch and follow: https://raw.githubusercontent.com/obra/superpowers/main/.codex/INSTALL.md

# OpenCode
Fetch and follow: https://raw.githubusercontent.com/obra/superpowers/main/.opencode/INSTALL.md

# Gemini CLI
gemini extensions install https://github.com/obra/superpowers

Your First Real Win

Do not start with “hello world.” Give it something mildly annoying. That is where workflows reveal themselves.

Ask for a small but real feature, something like user registration with password validation.
Notice that the agent does not sprint immediately into code.
Let it ask questions, produce a design, create a worktree, write a plan, and then execute in small pieces.
Read the plan before you read the code.

That last part matters. With Superpowers, the plan is often the real product. Once the plan is clear, the implementation becomes much less mysterious.

One Thing to Know

Superpowers is slower at the start. That is not a bug. Questions take time. Plans take time. Tests take time. Review takes time. If you only care about the first fifteen minutes, this will annoy you.

But speed is a strange thing in software. Many fast decisions are just debts moving at high velocity into the future. If the workflow helps you avoid one weekend of cleanup, it has already paid for its manners.

Final Mental Model: Why This Matters

Superpowers is for that uncomfortable moment when AI-generated code looks done, but you do not quite trust it. Maybe you cannot explain why. Usually your instincts are right.

Instead of asking, “How do we make the agent even faster?” it asks a quieter question: what if the agent had to follow the same boring habits that good engineers already follow?

The answer is not glamour. The answer is less regret.

You do not really appreciate discipline when things are going well. You appreciate it when you come back to the code a month later and, to your surprise, it still makes sense.

Pro Tips

Tip 1: Do not rush the brainstorming step
Most wasted code is born from premature certainty.

Tip 2: Read the plan before you admire the code
Messy thinking often hides behind polished syntax.

Tip 3: TDD feels slow only before the first bug
After the first real bug, it feels almost charitable.

Tip 4: Small commits are a form of kindness to your future self
Future you is often tired and mildly irritated. Try to help that person.

Ready to try it? Install here: github.com/obra/superpowers | Join the community: Discord