Superpowers: Turn Any Coding Agent Into a Senior Developer

By Prahlad Menon 2 min read

You can now turn Claude Code, Codex, and Cursor into a real senior developer. 100% free.

Superpowers has already surpassed 229,000 stars on GitHub. Here’s why.

The Problem

Once a project reaches a certain size, coding agents start hallucinating, breaking tests, and introducing dead code. They jump straight into coding, debug blindly, and abandon tests the moment things get hard.

Standard Claude Code workflow:

  1. Jump into coding
  2. Debug blindly
  3. Abandon tests
  4. Drift from plan
  5. Ship broken code

The Solution

Superpowers enforces the workflow of a senior engineer:

7-Phase Workflow:

  1. Brainstorm — Agent steps back and asks what you’re really trying to do
  2. Spec — Shows design in chunks short enough to actually read
  3. Plan — Implementation plan clear enough for a junior engineer to follow
  4. TDD — Red/green testing with no exceptions (deletes code if no prior test)
  5. Subagents — Parallel work using isolated git worktrees
  6. Review — Two-stage review (spec compliance, then code quality)
  7. Ship — Merge/PR/keep/discard decision workflow

Zero code before tests are passing.

Why It Works

The key insight: these are mandatory workflows, not suggestions. The skills trigger automatically — your agent just has Superpowers.

FeatureStandard AgentAgent + Superpowers
Design phaseSkips itSocratic brainstorming before code
Test disciplineOptional, often abandonedRED-GREEN-REFACTOR enforced
Context driftAfter ~30 minHours of autonomous work
Parallel tasksManual jugglingIsolated git worktrees
Code reviewAd-hocTwo-stage review process

Installation

Works with every major coding agent:

Claude Code (official marketplace):

/plugin install superpowers@claude-plugins-official

Codex CLI:

/plugins
# Search for "superpowers", select Install

Cursor:

/add-plugin superpowers

Gemini CLI:

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

OpenCode:

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

The Skills Library

Testing:

  • test-driven-development — RED-GREEN-REFACTOR cycle

Debugging:

  • systematic-debugging — 4-phase root cause process
  • verification-before-completion — Ensure it’s actually fixed

Collaboration:

  • brainstorming — Socratic design refinement
  • writing-plans — Detailed implementation plans
  • subagent-driven-development — Fast iteration with two-stage review
  • using-git-worktrees — Parallel development branches

Philosophy

From the original release announcement:

  • Test-Driven Development — Write tests first, always
  • Systematic over ad-hoc — Process over guessing
  • Complexity reduction — Simplicity as primary goal
  • Evidence over claims — Verify before declaring success

How This Connects

This fits into the broader theme we’ve been tracking:

SIA shows agents can update their own weights and scaffolding. But what good is self-improvement if the underlying workflow is broken?

autoloop runs experiment loops to optimize any file. But the experiments still need a solid methodology to iterate on.

Superpowers provides the discipline layer — the senior engineer workflow that keeps agents from going off the rails in the first place. Combined with self-improvement loops, you get agents that both follow good practices and get better over time.

The stack is converging:

  • Superpowers → Workflow discipline
  • autoloop/SIA → Self-improvement loops
  • Memory (soul.py, etc.) → Persistent context across sessions

Each piece solves a different failure mode. Together, they start to look like something that can actually work autonomously for hours.

Links:

Related posts: