Your AI coding agent is smart. But without structure, it’s like hiring a brilliant engineer with no process, it’ll jump straight into coding, skip the design doc, ignore tests, and refactor the same file three times.

Two open-source frameworks have emerged to fix this: BMAD Method (45K stars) and Superpowers (180K stars). Both turn your AI agent into a disciplined development team. But they take fundamentally different approaches.

We installed both in Claude Code, ran them on real projects, and here’s exactly how they compare, with real terminal output.

The Core Philosophy

BMAD: “Build More Architect Dreams”

BMAD is a full agile methodology adapted for AI. It gives you 12+ specialized agent personas: Business Analyst, Product Manager, Architect, Developer, UX Designer, QA Engineer, and more, each with distinct expertise. Think of it as hiring an entire engineering team, where each team member is an AI agent with a specific role.

Superpowers: “Skills That Enforce Discipline”

Superpowers is a composable skills framework. Instead of agent personas, it provides behavioral rules that your AI agent must follow. When you start coding, it forces a brainstorming session. When you write code, it enforces TDD. When you finish, it runs code review. Think of it as installing engineering discipline directly into your agent’s brain.

BMAD MethodSuperpowers
GitHub Stars45K+180K+
Latest Versionv6.6.0 (Apr 2026)v5.1.0 (May 2026)
PhilosophyFull agile methodologyEngineering discipline via skills
Agent Model12+ role-based personasSingle agent with enforced behaviors
Installationnpx bmad-method installclaude plugin install superpowers
Skills Count42 skills12 core skills
LicenseOpen SourceMIT
Primary PlatformClaude Code, CursorClaude Code, Cursor, Codex

Hands-On: Installing BMAD Method

Let’s install BMAD from scratch. First, create a project and initialize Git:

$ mkdir my-project && cd my-project
$ git init
Initialized empty Git repository in /my-project/.git/

Now install BMAD with the Claude Code integration:

$ npx bmad-method install --directory . --modules bmm --tools claude-code --yes

You’ll see BMAD’s signature ASCII banner and a complete installation summary:

+----------------------------------------------------------------------------+
| ██████╗ ███╗ ███╗ █████╗ ██████╗ ™ |
| ██╔══██╗████╗ ████║██╔══██╗██╔══██╗ |
| ██████╔╝██╔████╔██║███████║██║ ██║ |
| ██╔══██╗██║╚██╔╝██║██╔══██║██║ ██║ |
| ██████╔╝██║ ╚═╝ ██║██║ ██║██████╔╝ |
| ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═════╝ |
| Build More, Architect Dreams |
+----------------------------------------------------------------------------+

 Using directory: ./my-project
 Using modules: bmm
 Using tools: claude-code

 +-BMAD is ready to use!------------------------------------------------------+
 | Shared scripts |
 | BMad Core Module (v6.6.0, installed) |
 | BMad Method Agile-AI Driven-Development (v6.6.0, installed) |
 | Module directories |
 | Configurations (generated) |
 | Help catalog |
 | claude-code (42 skills → .claude/skills) |
 +----------------------------------------------------------------------------+

What BMAD Creates

After installation, your project gains a structured directory:

my-project/
├── .claude/
│ └── skills/ # 42 Claude Code skills
│ ├── bmad-agent-analyst/ # Business Analyst agent
│ ├── bmad-agent-architect/ # System Architect agent
│ ├── bmad-agent-dev/ # Developer agent
│ ├── bmad-agent-pm/ # Product Manager agent
│ ├── bmad-agent-ux-designer/
│ ├── bmad-brainstorming/ # Brainstorming workflow
│ ├── bmad-create-architecture/
│ ├── bmad-create-prd/ # Product Requirements Doc
│ ├── bmad-create-epics-and-stories/
│ ├── bmad-dev-story/ # Story implementation
│ ├── bmad-party-mode/ # Multi-agent collaboration
│ ├── bmad-help/ # AI-powered guidance
│ └── ... (42 total)
├── _bmad/
│ ├── bmm/ # Module workflows
│ │ ├── 1-analysis/ # Phase 1: Analysis
│ │ ├── 2-plan-workflows/ # Phase 2: Planning
│ │ ├── 3-solutioning/ # Phase 3: Solution Design
│ │ └── 4-implementation/ # Phase 4: Implementation
│ ├── core/ # Core framework files
│ ├── config.toml # Project configuration
│ └── scripts/ # Utility scripts
├── _bmad-output/
│ ├── planning-artifacts/ # PRDs, architecture docs
│ └── implementation-artifacts/ # Stories, sprint plans
└── docs/ # Project knowledge base

Hands-On: Installing Superpowers

Superpowers uses Claude Code’s native plugin system. First, add the marketplace:

$ claude plugin marketplace add obra/superpowers
Adding marketplace…
SSH not configured, cloning via HTTPS: https://github.com/obra/superpowers.git
Refreshing marketplace cache (timeout: 120s)…
Cloning repository (timeout: 120s): https://github.com/obra/superpowers.git
Clone complete, validating marketplace…
 Successfully added marketplace: superpowers-dev (declared in user settings)

Then install the plugin:

$ claude plugin install superpowers
Installing plugin "superpowers"...
 Successfully installed plugin: superpowers@claude-plugins-official (scope: user)

Verify installation:

$ claude plugin list
Installed plugins:

 > superpowers@claude-plugins-official
 Version: 5.1.0
 Scope: user
 Status: enabled

That’s it. No file scaffolding, no directories — Superpowers lives entirely as a Claude Code plugin that loads behavioral skills at session start.

How They Work: Side-by-Side Workflow Comparison

Starting a New Feature

With BMAD: When you tell Claude “I want to build a user authentication system,” BMAD activates a structured multi-phase workflow:

Phase 1: Analysis (bmad-agent-analyst)
 → Domain research, stakeholder analysis, market research
 → Outputs: Research findings, requirements brief

Phase 2: Planning (bmad-agent-pm)
 → Product Requirements Doc (PRD), epics, user stories
 → Outputs: PRD, epic breakdown, story cards

Phase 3: Solutioning (bmad-agent-architect)
 → System architecture, tech stack decisions, API design
 → Outputs: Architecture doc, data model, API specs

Phase 4: Implementation (bmad-agent-dev)
 → Story-by-story implementation with TDD
 → Outputs: Working code, tests, documentation

Each phase uses a different agent persona with specialized knowledge. You can even use Party Mode to bring multiple agents into one session for collaborative design discussions.

With Superpowers: The same request triggers a linear skill chain:

1. brainstorming (auto-activates)
 → Refines your idea through Socratic questions
 → Explores alternatives, presents design in sections
 → Saves a design document for your approval

2. writing-plans (activates after design approval)
 → Breaks work into micro-tasks (2-5 minutes each)
 → Each task has exact file paths, complete code, verification steps

3. subagent-driven-development (activates on "go")
 → Dispatches fresh subagent per task
 → Two-stage review: spec compliance → code quality
 → Autonomous for hours without deviation

4. test-driven-development (during implementation)
 → Enforces RED-GREEN-REFACTOR cycle
 → Write failing test → Watch fail → Write code → Watch pass → Commit
 → Deletes code written before tests (!)

The Key Difference

BMAD thinks in roles — “Who should handle this?” (PM, Architect, Developer). Superpowers thinks in behaviors — “What process should be followed?” (brainstorm, plan, TDD, review).

Skills Deep Dive

BMAD’s 42 Skills (Grouped by Phase)

CategorySkillsPurpose
Agent Rolesanalyst, architect, dev, pm, ux-designer, tech-writerSpecialized AI personas
Analysisdomain-research, market-research, brainstormingDiscovery and ideation
Planningcreate-prd, create-epics-and-stories, sprint-planningAgile planning artifacts
Architecturecreate-architecture, technical-researchSystem design
Implementationdev-story, quick-dev, code-reviewCoding workflows
Qualityreview-adversarial-general, review-edge-case-hunterAdversarial testing
Advancedparty-mode, distillator, shard-docMulti-agent, doc optimization
Metabmad-help, customize, generate-project-contextFramework operations

Superpowers’ 12 Core Skills

SkillTriggerWhat It Does
brainstormingBefore codingSocratic design refinement
writing-plansAfter design approvalMicro-task planning with verification
executing-plansDuring implementationBatch execution with human checkpoints
subagent-driven-developmentWith plan readyFresh subagent per task, two-stage review
test-driven-developmentDuring codingRED-GREEN-REFACTOR enforcement
requesting-code-reviewBetween tasksSeverity-based issue reporting
receiving-code-reviewAfter reviewStructured feedback response
dispatching-parallel-agentsComplex tasksConcurrent subagent workflows
using-git-worktreesParallel featuresIsolated development branches
finishing-a-development-branchFeature completeMerge/PR decision workflow
writing-skillsExtending frameworkCreate new skills with TDD
using-superpowersSession startSystem introduction

Module Ecosystem

BMAD’s Official Modules

BMAD extends beyond core development with specialized domain modules:

ModuleVersionPurpose
BMad Method (BMM)v6.6.0Core agile framework, 34+ workflows
BMad Builder (BMB)v1.4.0Create custom agents and workflows
Test Architect (TEA)v1.7.3Risk-based test strategy and automation
Game Dev Studio (BMGD)v0.2.2Unity, Unreal, Godot game dev workflows
Creative Intelligence Suite (CIS)v0.1.9Innovation, brainstorming, design thinking

Install additional modules during or after setup:

$ npx bmad-method install --directory . --modules bmm,tea,bmb --tools claude-code --yes

Superpowers’ Extension Model

Superpowers extends through custom skills. The framework provides a writing-skills skill that teaches your agent to create new skills following TDD:

# In Claude Code session:
> I need a skill for database migration workflows

# Superpowers will:
# 1. Brainstorm the skill design with you
# 2. Write the SKILL.md file
# 3. Test the skill with subagents
# 4. Validate comprehensibility and compliance

Third-party forks also exist:

  • complexthings/superpowers — Agent-agnostic version supporting GitHub Copilot, Gemini, OpenCode
  • brianchung888/superpowers — Custom skill additions

Platform Support Comparison

PlatformBMADSuperpowers
Claude CodeFull (recommended)Full (primary)
CursorSupportedPlugin marketplace
Codex CLI (OpenAI)PartialManual setup
Gemini CLIPartialVia fork
GitHub CopilotPartialVia fork
OpenCode—Supported

Real-World Performance

Token Efficiency

Both frameworks add context to your AI agent’s window, but they approach token management differently:

MetricBMADSuperpowers
Initial context overhead~15K tokens (42 skills indexed)~5K tokens (12 skills indexed)
Per-workflow tokens~3-8K per agent activation~1-3K per skill activation
Token optimizationProgressive disclosure patternHelper pattern (70-85% savings)
Subagent supportSub-agent inclusionTwo-stage review per subagent

Superpowers is notably lighter — its functional design “removed persona overhead for better performance,” while BMAD’s rich agent personas require more context.

When to Use Which

Choose BMAD when:

  • Building enterprise-scale applications that need formal planning artifacts
  • You want structured PRDs, architecture docs, and sprint plans
  • Working in teams that need agile ceremony artifacts
  • Using domain-specific modules (game dev, test architecture)
  • You value role-based thinking: “What would the architect say?”

Choose Superpowers when:

  • You want fast, disciplined individual development
  • TDD is non-negotiable in your workflow
  • Subagent-driven development appeals to you (hours of autonomous work)
  • Context window efficiency is critical
  • You prefer composable behaviors over agent personas

The Verdict: Different Tools for Different Mindsets

BMAD and Superpowers aren’t competitors — they’re answers to different questions.

BMAD asks: “How do I run a complete agile development process with AI?” Superpowers asks: “How do I make my AI agent follow engineering best practices?”

If you’re building a product from scratch and want the AI to walk you through discovery, planning, architecture, and implementation with distinct expert perspectives — BMAD is your framework. Its 42 skills and module ecosystem provide enterprise-grade structure.

If you want your AI agent to simply be disciplined — brainstorm before coding, write tests before implementation, review its own work, and execute plans via subagents for hours without losing focus — Superpowers is your framework. Its 180K stars reflect the developer community’s demand for exactly this: engineering discipline, not just intelligence.

The best part? Both are free, open-source, and actively maintained. Install one, try it for a week, and see if it transforms how you work with AI.

Quick Reference: Installation Cheatsheet

BMAD Method

# Full install with Claude Code
npx bmad-method install --directory . --modules bmm --tools claude-code --yes

# With additional modules
npx bmad-method install --directory . --modules bmm,tea,bmb --tools claude-code --yes

# Get help inside Claude Code
# Just ask: "invoke the bmad-help skill"

Superpowers

# Add marketplace (one-time)
claude plugin marketplace add obra/superpowers

# Install plugin
claude plugin install superpowers

# Verify
claude plugin list

# Usage: just start a Claude Code session — skills auto-activate

BMAD Method | GitHub | Docs | Discord

Superpowers | GitHub | MIT License | Plugin Marketplace

More from AI Tool Pick: