Superpowers Review: The 124K-Star Skills Framework for Claude Code

TL;DR

Superpowers is an open-source agentic skills framework that transforms your AI coding agent into a disciplined senior developer. Key facts:

124,700+ GitHub stars — one of the most-starred developer tools ever
Works with: Claude Code, Cursor, Codex, OpenCode, Gemini CLI
What it does: Enforces TDD, spec-first design, subagent-driven development, and code review — automatically
Install: /plugin install superpowers@claude-plugins-official (Claude Code marketplace)
Created by: Jesse Vincent (@obra), long-time open-source maintainer
License: MIT
The pitch: “Your coding agent just has Superpowers” — skills trigger automatically, no special prompts needed

The community is split: some call it “game-changing,” others say it “over-engineers everything.” Both are right — it depends on your project.

What Superpowers Actually Does

Superpowers isn’t a new AI tool. It’s a set of composable skills (instructions + workflows) that your existing coding agent loads automatically. Think of it as a senior developer’s methodology injected into your AI.

Here’s the workflow it enforces:

1. Brainstorming (Before Any Code)

When you ask your agent to build something, Superpowers stops it from writing code immediately. Instead, the agent:

Asks clarifying questions about what you’re really trying to build
Explores alternatives you might not have considered
Presents the design in digestible chunks for your approval
Saves a design document before proceeding

2. Planning (After Design Approval)

The agent creates an implementation plan broken into tiny tasks (2-5 minutes each). Each task includes:

Exact file paths to create/modify
Complete code to write
Verification steps to confirm it works

3. Subagent-Driven Development

This is the most innovative part. Instead of one agent doing everything:

A coordinator agent manages the plan
Fresh subagents are spawned for each task (clean context, no accumulated confusion)
Each subagent’s work gets a two-stage review: spec compliance, then code quality
Critical issues block progress; minor issues get logged

4. Test-Driven Development (Enforced)

Superpowers enforces strict RED-GREEN-REFACTOR:

Write a failing test first
Watch it fail (red)
Write minimal code to pass
Watch it pass (green)
Refactor if needed
Commit

If the agent writes code before tests, Superpowers deletes it. This is opinionated by design.

5. Code Review + Finish

Between tasks, the agent reviews against the plan. When all tasks complete, it:

Verifies all tests pass
Presents options: merge, create PR, keep branch, or discard
Cleans up the git worktree

Installation

Claude Code (Official Marketplace)

/plugin install superpowers@claude-plugins-official

Cursor

/add-plugin superpowers

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

OpenCode

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

No configuration needed. Skills trigger automatically based on what you’re doing.

The Skills Library

Category	Skill	What It Does
Planning	brainstorming	Socratic design refinement before coding
Planning	writing-plans	Breaks work into 2-5 min tasks
Development	subagent-driven-development	Fresh agents per task with reviews
Development	executing-plans	Batch execution with human checkpoints
Testing	test-driven-development	Enforced RED-GREEN-REFACTOR
Quality	requesting-code-review	Reviews against plan, blocks on critical issues
Git	using-git-worktrees	Isolated workspaces per feature
Debugging	systematic-debugging	4-phase root cause analysis
Finishing	finishing-a-development-branch	Test verification, merge options, cleanup

What the Community Says (Honest Take)

The Fans

From r/ClaudeCode: “Laravel Boost and Claude with superpowers is turning out some really solid code for me.”

On HN, a 60-year-old developer shared how coding agents (including Superpowers) reignited his passion for building software.

r/ClaudeCode on frameworks: “Depends on task weight: native/superpowers/GSD. Always have Code Rabbit review, and for important bits I double-check with Codex MCP back and forth — pure gold.”

The Critics

r/ClaudeCode: “Anyone else not a fan of the superpowers plugin?” — Some developers find it over-engineers simple tasks.

r/opencodeCLI: “With OpenCode, superpowers just runs every prompt which causes clashes. It loads unnecessary skills and causes it to over-engineer. Vanilla OpenCode works just fine for me.”

Another user: “Knowing fundamentals of TDD and having a good plan with verification gates is more than enough.”

The Reality

Superpowers works best for:

Medium-to-large features where planning prevents wasted effort
Projects that need test coverage (the TDD enforcement is strict)
Teams that want consistency across AI-assisted development
Claude Code specifically — it’s the best-supported platform

Superpowers works worst for:

Quick one-off fixes — the brainstorming/planning overhead is overkill
OpenCode — users report skill clashes and over-engineering
Projects without tests — the TDD enforcement fights you constantly
Experienced devs who already have their own methodology

Superpowers vs Alternatives

Framework	Stars	Approach	Best For
Superpowers	124K	Skills + methodology	Claude Code, structured projects
GSD	~8K	”Get Stuff Done” minimalist	Quick tasks, less overhead
SPARC	~3K	Specification-driven	Complex systems, architecture
Vanilla	—	No framework	Simple changes, experienced devs

The r/ClaudeCode consensus: “Use native for small changes, Superpowers for medium features, and manual planning for large systems.”

How to Get the Most Out of It

Don’t use it for everything. Quick bug fixes don’t need brainstorming + TDD + code review.
Trust the planning phase. The upfront design time saves much more time during implementation.
Use Claude Code. Superpowers was built for Claude Code and works best there. Cursor and Codex support is secondary.
Combine with Code Rabbit. Multiple r/ClaudeCode users recommend using Code Rabbit for an additional review layer.
Set expectations. The first time feels slow because the agent asks questions instead of coding. That’s the point.

FAQ

What is Superpowers for Claude Code?

Superpowers is an open-source skills framework (124K+ GitHub stars, MIT license) that adds automated TDD, subagent-driven development, brainstorming, and code review to your AI coding agent. It works with Claude Code, Cursor, Codex, Gemini CLI, and OpenCode. Install via /plugin install superpowers@claude-plugins-official.

Does Superpowers work with Cursor?

Yes. Install via /add-plugin superpowers in Cursor Agent chat. However, community feedback suggests it works best with Claude Code, which has the deepest integration and plugin support.

Is Superpowers worth using?

It depends on your workflow. For medium-to-large features where you want disciplined TDD and planning, yes. For quick fixes or if you’re already experienced with your own methodology, vanilla Claude Code may be better. The r/ClaudeCode community is split about 60/40 in favor.

What is subagent-driven development?

A pattern where a coordinator agent breaks work into tasks and spawns fresh subagents for each one. Each subagent gets clean context (no accumulated confusion), and its work is reviewed before merging. This prevents the common problem of AI agents going off-track during long sessions.

How does Superpowers compare to GSD?

GSD (“Get Stuff Done”) is a minimalist framework focused on quick execution. Superpowers is more opinionated, enforcing TDD, planning, and code review. Use GSD for speed, Superpowers for quality. Many developers use both depending on the task.

Can I use Superpowers with Codex or Gemini CLI?

Yes. Codex and Gemini CLI both have installation instructions in the repo. However, OpenCode users report skill clashes, and the experience is best on Claude Code where Superpowers was originally designed.

GitHub: github.com/obra/superpowers Creator: Jesse Vincent (@obra) License: MIT | Stars: 124,700+ | Forks: 10,100+