BMAD-METHOD — Breakthrough Method for Agile AI-Driven Development

Source: raw/gh-star-bmad-code-org-bmad-method.md (GitHub star stub, 2026-05-20) + README extraction from github.com/bmad-code-org/BMAD-METHOD.

BMAD-METHOD is an AI-driven agile development framework built around the premise that LLMs should be expert collaborators that guide you through a structured process, not “thinking-for-you tools that produce average results.” Twelve+ specialized personas (PM, Architect, Developer, UX, QA, etc.) operate individually or in “Party Mode” for collaborative discussions. Thirty-four-plus workflows span analysis, planning, architecture, and implementation phases. Scale-adaptive intelligence claim: planning depth automatically scales from bug fixes to enterprise systems. MIT license, maintained by BMad Code, LLC; 47.7K GitHub stars at 2026-05-19 capture, v6.7.1 latest version, JavaScript primary.

Key Takeaways

• 12+ specialized personas, not slash commands. BMAD ships agents-as-personas (PM, Architect, Developer, UX, etc.), each with role-specific prompts and decision frames.
• “Party Mode” multi-agent discussions. Personas debate together rather than being invoked sequentially — a deliberate design choice vs single-agent-at-a-time frameworks like gstack or GSD.
• 34+ structured workflows. Cover analysis → planning → architecture → implementation. Workflows are first-class artifacts, not improvised per-task.
• Scale-adaptive intelligence. Planning depth changes based on project complexity — same framework handles bug fixes and enterprise-system design without manual mode switching. ^[inferred — the README claim, mechanism not detailed in the surface docs]
• MIT license, BMad Code, LLC. v6.7.1 latest. v6+ launched recently per the README’s “ongoing rapid development” note.
• One-line install: npx bmad-method install. Requires Node.js v20.12+, Python 3.10+, and the UV package manager.
• Non-interactive CI/CD mode available via --yes flag.

The Design Philosophy

BMAD’s positioning vs LLM-default behavior is the load-bearing distinction:

• Traditional approach: “Tools that do the thinking for you, producing average results.” A single prompt → single LLM response → ship.
• BMAD approach: “Expert collaborators who guide you through a structured process.” Twelve personas, 34 workflows, decision gates. The structure is the differentiation.

Closest peer in the wiki is Superpowers — a similarly closed end-to-end software-development methodology shipped as a skills bundle. Adjacent: SuperClaude’s 30 /sc:* commands + 20 agents.

Implementation

Tool/Service: BMAD-METHOD (BMad Code, LLC) Setup:

npx bmad-method install

Requirements:

• Node.js v20.12+
• Python 3.10+
• UV package manager Cost: Free (MIT). Token costs at usual Claude/OpenAI rates. Integration notes: v6.7.1 latest. CI/CD with --yes for non-interactive install. JavaScript-primary repo (the npx install ships an interactive setup that scaffolds the persona + workflow library). Personas appear as agent definitions, not slash commands — invocation pattern is closer to multi-agent dispatch than slash-command-per-task.

Differentiation vs Adjacent Frameworks

Tool	Persona model	Workflow model	Invocation
BMAD-METHOD	12+ personas + Party Mode	34+ structured workflows, scale-adaptive	Multi-agent dispatch
Superpowers	Skills bundle	Closed methodology	Skill invocation
SuperClaude	20 specialized agents	7 behavioral modes	30 /sc:* slash commands
gstack	23+ role personas	Role-scoped slash commands	Per-command invocation
GSD	Researcher/planner/executor subagents	Six-step phase loop	/gsd-* slash commands
OMC	~19 specialized agents	6 orchestration modes	Team-first multi-agent

BMAD’s distinctive choice is Party Mode — explicit multi-persona collaborative discussion as a first-class invocation pattern. Most adjacent frameworks invoke agents sequentially or in parallel-isolated; BMAD models the agent-debate explicitly.

Open Questions

• Scale-adaptive mechanism. The README claims planning depth adjusts based on complexity, but doesn’t surface how — what’s the heuristic? File count? Estimated tokens? Manual hint? Worth README-deep-dive before relying on this in production.
• Party Mode practical output. Multi-agent debates can produce more thoughtful results OR can produce expensive thrashing. No measurement in the surface docs comparing Party Mode vs single-persona output quality on the same task.
• The 34+ workflows. Catalog not fully enumerated in the WebFetch extraction. Worth running bmad-method --list-workflows or similar to map the workflow catalog before recommending.
• License caveat: NOASSERTION → MIT. The gh-stars stub captured NOASSERTION as the license, but the README WebFetch confirmed MIT. Worth checking whether the LICENSE file is committed (a NOASSERTION flag means GitHub couldn’t detect a standard license header — could be a packaging issue, not a license issue).
• BMad Code, LLC. Org maintainer is a US LLC; founders / business model not surfaced. Worth follow-up before treating as a stable long-term framework.

Related

• Claude AI topic
• Superpowers — Agentic Skills Framework
• SuperClaude Framework
• gstack — Garry Tan’s 23-Tool Setup
• GSD — Get-Shit-Done System
• oh-my-claudecode (OMC)
• OpenSpec — Spec-Driven Vibe-Coding Framework

Try It

1. Install in a sandbox profile. CLAUDE_HOME=~/sandbox-claude npx bmad-method install — the framework scaffolds a full agent + workflow library and you’ll want to inspect it before merging into your daily-driver Claude Code setup.
2. Map the 34+ workflows. Run whatever the BMAD discovery command is (likely bmad-method --list-workflows or check ~/.bmad/ after install) so you can compare against your actual phase needs.
3. Test Party Mode on a low-stakes task. Pick a 2-3 hour design decision (e.g., “should this be SQLite or Postgres?”) and run it through Party Mode vs a single-persona dispatch. Measure tokens + decision quality.
4. Verify the LICENSE file is present and MIT in the repo root (the NOASSERTION gh-stars detection suggests packaging may need a LICENSE-detection fix).
5. Compare scale-adaptive claim on real projects. Try a small bug-fix task and an enterprise-system design task back-to-back — the README’s claim is that planning depth scales automatically. Verify before relying on this in production.