Two names keep coming up when engineering teams talk about serious AI-assisted development: BMAD and Superpowers. They get compared a lot, usually by people trying to decide which one to adopt. That framing is off. They aren't competing tools — they operate at different layers of the stack. Knowing which layer you're missing tells you which one to reach for.
What BMAD is
BMAD — Breakthrough Method for Agile AI-Driven Development — is a project management framework for teams shipping software with AI in the loop. It organises work around personas (Analyst, PM, Architect, Scrum Master, Developer, QA) and four sequential phases (Analysis, Planning, Solutioning, Implementation). Each phase produces an artifact that feeds the next: PRD, user stories, architecture notes, code.
The core bet is that AI coding quality collapses without persistent context, so documentation has to be the source of truth, not a by-product. Code is the derivative.
BMAD is heaviest at the front end of a project. It forces decisions — problem definition, constraints, acceptance criteria — before code gets written, and it formalises handoffs between roles so nothing gets lost when the context window resets.
What Superpowers is
Superpowers is a Claude Code plugin by Jesse Vincent. It's not a methodology. It's a curated skill library that changes how a single Claude instance behaves while working on code.
Install it and Claude gains opinionated defaults for the craft of engineering: test-driven development with a hard rule against writing implementation before a failing test exists, a scientific-method debugging loop for root-cause work, a brainstorming skill for shaping ideas into plans, worktree-based workflows for isolating changes, and verification skills that force the agent to actually run what it wrote before claiming success.
Skills load progressively — Claude pulls in the relevant one when the task calls for it, rather than front-loading the entire library into context. The effect is a Claude that writes tests first without being told, refuses to mark things "done" without evidence, and surfaces uncertainty instead of hallucinating over it.
Superpowers is heaviest at the point of execution. It's about raising the floor on what one agent produces at the keyboard.
The key difference
BMAD structures the team workflow around AI. Superpowers structures the agent behavior during a single task.
BMAD is a framework you run; Superpowers is a plugin you install. BMAD gives you artifacts, phases, and role handoffs. Superpowers gives you a better-behaved Claude.
That's why they feel hard to compare head-to-head — they aren't solving the same problem. BMAD answers "how does a team plan and ship a project with AI?" Superpowers answers "how does my agent stop skipping tests and inventing APIs?"
When BMAD fits
BMAD is the right tool when the problem is coordination, not code quality. Teams with multiple developers sharing an AI workflow, projects where requirements are still being shaped, organisations that need reviewable decisions between phases, work that spans more than one sitting and has to survive context resets. If your pain is "the AI keeps losing the plot between sessions" or "nobody agrees what we're building," BMAD's artifact-first approach pays off.
Where it fails: solo work on well-understood tasks. The persona ceremony becomes theatre. You're generating PRDs for things that didn't need them.
When Superpowers fits
Superpowers is the right tool when the problem is execution quality inside Claude Code. Individual engineers or small teams using Claude Code as their primary interface, debugging sessions that keep going in circles, codebases where the agent keeps shipping untested code or claiming false completions, tasks where you want TDD or scientific debugging enforced by default rather than by prompt discipline.
Where it fails: multi-phase projects with unclear scope. Superpowers makes a single task go better. It doesn't tell you what the task should be or how it fits into the quarter.
Using them together
The cleanest combination: use BMAD to run the project and Superpowers to run the agent.
BMAD produces the PRD, the stories, the architecture notes. Each implementation story is small enough to hand to Claude Code in a single session. That session runs with Superpowers loaded, so TDD, verification, and root-cause debugging are enforced by the skill library rather than by the developer remembering to prompt for them.
You get BMAD's coordination and artifact trail at the project level, and Superpowers' execution discipline at the task level. Neither layer substitutes for the other. Skipping BMAD gets you well-written code for the wrong feature. Skipping Superpowers gets you a clean PRD and sloppy implementation.
Which one to reach for
Ask what's breaking first. If your AI output is incoherent across sessions and nobody knows what's decided, you have a process problem — start with BMAD. If your output within a session is untested, unverified, or confidently wrong, you have an execution problem — start with Superpowers.
The mistake is treating them as alternatives. They sit at different layers. Most teams shipping real work with AI end up wanting both.
If you're working out how to put AI into a real engineering process without losing quality or control, book a call — a short conversation usually makes the right sequence obvious.