Superpowers for AI Coding: Execution Discipline That Makes Specs Hold

The most-starred project in the AI coding ecosystem isn't a spec tool at all. Superpowers, created by Jesse Vincent (obra) in October 2025, passed 230k GitHub stars by mid-2026 — bigger than every other project in the space combined — and it doesn't generate specs, plans, or tasks. What it does is make agents obey process.

Superpowers is a framework of 13+ composable Markdown skills that impose engineering discipline on coding agents: TDD as a hard rule, a brainstorm gate that forbids coding before design approval, four-layer review gates, systematic debugging, and subagent-driven development. The philosophy is blunt: "Process over Prompt." The most capable model in the world still produces junk if it's allowed to write code without a failing test, or to "fix" a bug it hasn't diagnosed.

This guide covers the discipline stack, how it relates to spec-driven coding, and what changed in v6.

The discipline stack

1. TDD as an iron rule

Superpowers' most distinctive rule: no production code without a failing test. The agent must write the failing test first, watch it fail, then implement. This isn't a suggestion — the skill definitions structure the workflow so the agent literally doesn't proceed to implementation until the test failure is demonstrated. In practice this eliminates the ecosystem's most common failure mode: agents that write code which looks right and quietly breaks.

2. Brainstorm gate

Before any code for a non-trivial change, the agent must produce a design in the brainstorming skill and get it approved — by a human or by the gate itself. Design not approved = no code. This is the point where Superpowers meets spec-driven coding: the brainstorm output is a design document, though deliberately lighter than a formal spec. The difference from GitHub Spec Kit: Superpowers treats the design as scaffolding for execution, not as the versioned source of truth.

3. Four-layer review gates

Every implementation passes a review chain: agent self-review, automated checks, and — the innovation — a reviewer subagent with a mandate to find problems. In v6 the review tightened: one reviewer instead of two, but with no suppression allowed — the controller cannot dismiss a reviewer's finding, and findings must cite file and line as evidence. The diff is passed by file to save context.

4. Subagent-driven development

Each task runs in its own subagent with a double-layer review, so a stalled or broken agent doesn't corrupt the main session's context — and each task's work is isolated and reviewed before integration. Combined with git worktree isolation (a tmux-style parallel setup), this is what lets multiple agents work the same codebase safely.

5. Systematic debugging

A four-phase root-cause skill: reproduce → diagnose → fix → verify. The agent is forbidden from "trying things" — it must demonstrate the cause before proposing the fix. For anyone who's watched an agent attempt the same wrong patch three times, this is the single most valuable skill in the pack.

Superpowers and spec-driven coding: scaffolding or truth?

Superpowers sits at one end of the spec-driven debate. Where Spec Kit says "the spec is the single source of truth and code serves it," Superpowers says the spec (or brainstorm) is scaffolding — what matters is the execution loop around it: fail-first tests, review gates, evidence-based fixes.

| | Superpowers | GitHub Spec Kit | OpenSpec | |---|---|---|---| | Core | Execution discipline | Spec as source of truth | Delta-spec planning engine | | Planning artifact | Brainstorm design, approved by gate | Spec + plan + tasks artifacts | Delta specs per change | | Requirements style | Design discussion | Numbered FR-001 requirements, SHALL/MUST | ADDED/MODIFIED/REMOVED deltas | | Enforcement | TDD rule, review gates, no suppression | Constitution compliance gates | None (discipline left to you) | | Stars (mid-2026) | ~230k | ~115k | ~55k |

The debate — spec as scaffolding vs. spec as truth — is the central argument of 2026's methodology wars, covered in depth in our spec-driven vs vibe coding comparison.

The v6 changes (June 2026)

Version 6.0.0 (released June 16, 2026) was a substantial rewrite:

• One reviewer, stricter standard: down from two reviewers per task to one, but the reviewer's findings can't be suppressed and must cite evidence.
• No controller discretion: the orchestrator agent lost the ability to wave off reviewer findings.
• Diff-by-file: code diffs are passed between agents via files, cutting context usage significantly.
• Official evals claim ~2x efficiency and ~50% token savings (with the honest caveat that results vary by task).

Where Superpowers fits

Use Superpowers when:

• You already have a plan (from any source) and your problem is the agent executing it responsibly.
• You've watched agents write untested code, "fix" things blindly, or merge broken PRs — the discipline stack targets exactly those failure modes.
• You're doing serious work on real codebases where a broken merge costs an afternoon.

Skip Superpowers when:

• You need formal requirements tracking — its planning is design discussion, not numbered requirement artifacts. Pair it with OpenSpec or Spec Kit for that.
• You want minimal ceremony for quick experiments — the skill pack is discipline-heavy by design; specdd is the minimal alternative.

The hottest development of 2026 is exactly this pairing: fusion projects like superspec and spec-superflow that use OpenSpec for planning and Superpowers for execution, targeting the planning-execution gap.

Getting started

Install the skills into your agent of choice (Claude Code, Codex, Cursor, Gemini CLI, Copilot — 10+ platforms are supported) and start with the TDD skill on your next bug fix. Watch what happens when the agent refuses to write code before it has a failing test — then decide whether you ever want to go back.

For the big picture: the complete spec-driven coding guide places Superpowers in the ecosystem, and Spec Kit vs OpenSpec vs BMad covers the planning-tool alternatives.