Repo of the day: Superpowers, the development methodology for coding agents

💡 What Superpowers is: a methodology, not a prompt collection

Superpowers is an open-source repository (MIT license) that packages a library of composable skills — Markdown files with operational instructions — plus a bootstrap that makes sure the agent consults them before acting. The skills cover the entire development lifecycle: Socratic brainstorming, implementation plans, isolated Git worktrees, TDD, systematic debugging, two-stage code review and branch completion. The central rule is brutal in its simplicity: if a skill relevant to the task exists, the agent MUST use it — mandatory workflows, not suggestions.

The project was born in October 2025 from a post on the author's blog and exploded within a few months: today it's maintained by Jesse Vincent with the Prime Radiant team, has a dedicated eval suite to test skill behavior and ships from the official Claude plugin marketplace. It's not tied to a single tool: the same repo installs on Claude Code, Codex (CLI and App), Cursor, GitHub Copilot CLI, Antigravity, Factory Droid, Kimi Code, OpenCode and Pi.

repo       obra/superpowers
stars      ~224.7k · MIT license · author Jesse Vincent (Prime Radiant)
what       ~14 composable skills + a bootstrap that makes them binding
flow       brainstorming → plan → TDD → review → merge
harnesses  Claude Code · Codex · Cursor · Copilot CLI · OpenCode · more
extras     dedicated marketplace · eval harness to test the skills

🧭 The workflow: from brainstorming to merge, skipping nothing

The heart of Superpowers is the seven-stage flow that activates on its own. As soon as the agent understands you're building something, it does not jump into code: the brainstorming skill kicks in, asking questions, exploring alternatives and presenting the design in short sections to validate one at a time. Once the design is approved, the agent creates an isolated Git worktree on a dedicated branch, verifies the tests start clean, and only then writes an implementation plan made of 2-5 minute tasks, with exact file paths and verification steps.

On "go", subagent-driven development starts: a fresh subagent per task, and every result goes through a two-stage review — first spec compliance, then code quality. The README claims sessions where the agent works autonomously for a couple of hours without deviating from the plan; in my experience the real value is elsewhere: even when I step in, the work arrives already structured, tested and justified.

⚙️ How to install it: official marketplace and ten harnesses

On Claude Code installation is a single command, from Anthropic's official plugin marketplace; alternatively there's the author's dedicated marketplace, which also publishes related plugins. On Codex (CLI and App) Superpowers is in the official OpenAI marketplace, on Cursor it installs with `/add-plugin`, and for Copilot CLI, OpenCode and the other harnesses the README documents the step-by-step path. If you use more than one agent, install it separately on each.

Once installed you don't need to do anything: a session-start hook loads the introductory `using-superpowers` skill, and from there the skills trigger on their own when the context makes them relevant. That's the practical difference versus keeping the same advice in an instructions file: here the trigger is part of the system, not entrusted to the model's memory.

# Claude Code — Anthropic's official marketplace
/plugin install superpowers@claude-plugins-official

# alternatively: the author's dedicated marketplace
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

# Codex CLI: /plugins → search "superpowers" → Install Plugin
# Cursor:
/add-plugin superpowers

🧪 TDD and verification: the discipline vibe coding lacks

The two skills I consider the real reason to install it are test-driven-development and verification-before-completion. The first enforces the RED-GREEN-REFACTOR cycle with no discounts: a failing test, minimal code that makes it pass, refactor, commit — and code written before the test gets thrown away. The second blocks the worst vice of coding agents: declaring "done, all green" without having re-run anything. Before calling a task complete, the agent must run the verification commands and show the output — evidence, not assertions.

Then there's systematic-debugging, which in front of a bug enforces four phases of root-cause diagnosis before proposing any fix. These are exactly the points where "pure" vibe coding degrades into fragile code: Superpowers doesn't make the model smarter, it prevents it from taking the shortcuts it would take on its own. It's the natural complement to the hook-based quality gates I've written about: there the control is external and at session end, here it's internal and upstream.

🏢 Why it matters, for developers and SMBs

For developers, Superpowers is the fastest way to move from "handcrafted prompts" to a repeatable process: the skills are readable Markdown, and even just studying them is a crash course in agentic engineering — how to write a plan a subagent can execute, how to structure a two-stage review, how to stop a model from grading its own homework. And since it's all versioned text, you can inspect it, fork parts of it or disable what doesn't convince you.

For an SMB using coding agents, the point is predictability: two developers with the same plugin produce work with the same shape — documented design, plan, tests, review — instead of two incompatible prompting styles. The method stops being personal knowledge and becomes a team asset, versioned like the code. It's the same cultural leap I described when writing about the move from vibe coding to agentic engineering, here packaged as a plugin that installs in a minute.

⚠️ What to know before adopting it

The flip side is the weight of the process: for a one-line fix, going through brainstorming, plan and worktree can feel like bureaucracy — the flow shines on real features, less on micro-tasks, and at first it pays to learn when to follow it and when to explicitly tell it to skip steps. There's also a cost in context and tokens: loaded skills and dispatched subagents aren't free, although the "one fresh subagent per task" design keeps the individual context windows clean.

Two transparency notes the project itself makes explicit: the optional visual companion of the brainstorming skill loads a remote logo that acts as minimal telemetry (version in use, no project data), which can be disabled with an environment variable; and the team almost never accepts new skills from outside, because every change must work across all supported harnesses — if you want to extend the system, you write your own skills in your own space, following the `writing-skills` skill.

• Process overhead: perfect on features, excessive on micro-fixes; you can always ask to skip steps.
• Token cost: brainstorming, plans and subagents consume context — the payoff is less rework.
• Optional telemetry: version in use only, via a remote logo; turn it off with `SUPERPOWERS_DISABLE_TELEMETRY`.
• Limited contributions: no external skills in the core; your custom skills live alongside, not inside.

🗺️ Where to start

The path I suggest: install the plugin on Claude Code from the official marketplace, open a real feature — not a fix — and let the brainstorming do its job by actually answering the questions. Then read the skills that guided you: they're in the repo, in plain sight, and understanding why they're written that way is worth as much as using them. After a week you'll know which ones to keep binding and where you prefer a free hand.

If the topic interests you, I've written about it from other angles: the structured workflows of claude-code-workflows (a lighter approach to the same problem), hooks as quality gates and the maximalist ECC. Superpowers sits in the middle: more method than a config pack, less invasive than an "operating system" — for me, today, the best discipline-to-friction ratio.

More articles from the blog