BMAD-METHOD: the agile method that organizes AI agent teams to build software

BMAD-METHOD (Breakthrough Method of Agile AI-Driven Development) is a set of instructions, workflows, and specialized agents that turns an idea or change request into finished software without the developer losing control. It isn’t a model, a server, or an IDE: it’s a methodology layer, in the form of Markdown skills and Python scripts, that installs inside an AI coding tool (Claude Code, Codex, Cursor, Cline, Roo, Aider, and others) and forces product, architecture, and testing decisions to be made explicit before the agent writes code. As of September 11, 2026 it has over 52,800 GitHub stars, placing it among the most widely used “AI-driven development” frameworks.

Origin

The repository was created on April 13, 2025 (14:54 UTC per the GitHub API) by Brian Madison, who goes by “BMad” and the BMad Code brand, with GitHub handle bmadcode. Authorship is verified in the commit log: the initial commit (“Initial Commit of the BMAaDd Workflow,” April 13, 2025) and following ones are signed Brian Madison <brianmadison@Brians-MacBook-Pro.local> and Brian <bmadcode@gmail.com>. His public profile (github.com/bmadcode/bmadcode, “Hey — I’m BMad 👋 Creator of the BMad Method”) and the official blog’s footer (blog.bmadcode.com, “FOUNDER & EDITOR IN CHIEF — Brian Madison”) confirm the role. His self-reported bio mentions over 25 years of career (Northrop Grumman, Siemens) and an AI-native transformation role at Extend (self-reported, not independently verified).

There’s an authorship nuance worth noting: the largest number of contributions in the history belongs to alexeyv (644 commits) versus bmadcode (187). However, all the initial commits and the project announcement carry Brian Madison’s signature, so the founder is Madison and Verkhovsky is a core maintainer, not the creator.

The project didn’t change names: it was always called BMAD-METHOD. What did happen was an account move: it started on the personal account bmadcode/BMAD-METHOD (Wayback Machine captures from 2025-04-22 to 2025-06-26) and moved to the bmad-code-org organization in August 2025 (the org was created on 08-01-2025; the first capture of the org’s URL dates to 2025-08-09).

The launch narrative was explicitly anti-vibe-coding. The presentation video on YouTube (@BMadCode, April 18, 2025) was titled “Better than Vibe Coding: Hands‑On AI Agents Build Your Project Blueprint,” and an April 2025 README (Wayback snapshot, 04-22-2025) sold the method as a “predictable implementation flow with less costly rework or agent-credit burn than vibe coding produces.” The value proposition, in short: code assistants tend to turn implicit assumptions into code; BMAD forces important decisions to be written down as documents (brief, PRD, architecture, spec) that become durable context for the next piece of work.

Philosophy and principles

The current README summarizes its philosophy around the idea of AI-driven development (AiDD) that covers the whole effort, not just the code: what to build, how it fits, and how it changes as you learn. Verifiable principles in the documentation:

Right-sized process: a clear change goes straight to implementation; large initiatives get deeper planning added. “Small changes go straight to build; complex work gets the depth it needs.”
New or existing code: start from scratch or establish verified context over legacy code and work from what’s actually there.
Durable context: product and technical decisions are carried forward in documents, instead of being re-explained in every chat.
Specialized perspectives: bring in product, architecture, UX, dev, and QA expertise when it helps.
Guided collaboration: structured flows and multi-agent discussions without ceding judgment.
A single delivery path: from early reflection through reviewed implementation, correction, and learning.

CONTRIBUTING.md adds a governance principle: Human Amplification, Not Replacement. Every contribution must answer “Does this make humans and AI work better together?”; purely automated solutions that sideline the human and complexity that fragments the shared foundation are rejected.

How it works

The method functions as a team of specialized agents running an agile flow that produces artifacts. Version 6 (released as stable on February 17, 2026) reorganized the journey into a delivery loop: Clarify → Plan → Build → Learn, where you can start at any point. Planning skills are grouped into three phases, each writing a document handed to the next:

Phase	Skill	What it produces
Analysis	`bmad-brainstorming`	`brainstorm.html` + optional `brainstorm-intent.md`
Analysis	`bmad-forge-idea`	`forge-report.html`; `forged-idea.md` if the idea hardens
Analysis	`bmad-deep-recon`	`research.md` with citations + HTML briefing
Analysis	`bmad-product-brief`	`brief.md` + `addendum.md`
Analysis	`bmad-prfaq`	`prfaq-<project>.md` (tested from the press-release note)
Planning	`bmad-prd`	`prd.md`, `addendum.md`, `.memlog.md`
Planning	`bmad-ux`	`DESIGN.md`, `EXPERIENCE.md`, `.memlog.md`
Planning	`bmad-spec`	`SPEC.md` + companions under `specs/spec-<slug>/`; optional `stories.yaml`
Solution	`bmad-architecture`	`ARCHITECTURE-SPINE.md`
Solution	`bmad-create-epics-and-stories`	epic files with stories
Solution	`bmad-sprint-planning`	PASS/CONCERNS/FAIL verdict + `sprint-status.yaml`

The operational entry point is bmad-spec, which condenses any intent into a short contract and, on request, splits it into stories (stories.yaml). Then bmad-build implements one story per session. The size of the work decides how many sessions there are: a coherent outcome needing several sessions is an epic; several epics, or roughly 20+ sessions, is a project. bmad-build-auto runs a session without waiting for human input, but only after the important implementation decisions are stable; it doesn’t pick the next story or own the backlog.

Release note v6.12.0 (September 4, 2026) shows the design in motion: “Build decides how much ritual a change needs after investigating, not before. Simple changes get a two-section spec and finish in one session.” It also introduced review triage with a verdict and evidence for each finding, and adopts a hand-written AGENTS.md instead of rewriting it. There are documented breaking changes (e.g., persistent_facts arrives empty; {diff_output} became {diff_file}).

The ecosystem

Official repositories in the `bmad-code-org` organization

The README lists the official modules, and the organization maintains 18 repos. The main ones, with star counts consulted September 11, 2026:

bmad-code-org/BMAD-METHOD — the core: planning and delivering software, from prototypes to consolidated codebases; 52,875 stars.
bmad-code-org/bmad-module-game-dev-studio — ideate, design, and build games in any framework (Unity, Unreal, Godot, Phaser); 231 stars.
bmad-code-org/bmad-builder — builder and validator for skills, flows, and agents; 197 stars.
bmad-code-org/bmad-module-creative-intelligence-suite — creative-thinking partners for innovation, design thinking, and storytelling; 182 stars.
bmad-code-org/bmad-loop — builds, verifies, and retrospects a complete epic unsupervised; 125 stars.
bmad-code-org/bmad-method-test-architecture-enterprise — enterprise testing add-on; 97 stars.
bmad-code-org/bmad-method-wds-expansion — UX design (Whiteport Design System); 90 stars.
bmad-code-org/bmad-automator (40), bmad-method-ui (26, VS Code extension), bmad-module-template (17, template for creating installable modules), bmad-utility-skills (7), and bmad-eval-quality (3, quality harness).
bmad-code-org/bmad-plugins and bmad-plugins-marketplace — plugin distribution across all agent platforms.

Community ports, tutorials, and extensions

LarsCowe/bmalph — “Unified AI Development Framework” combining BMAD’s phases with Ralph’s autonomous execution; 406 stars. It’s the most visible bridge between BMAD (planning) and Ralph (loop execution).
aj-geddes/claude-code-bmad-skills — BMAD skills for Claude Code with auto-detection and memory integration; 485 stars.
ErwanLorteau/BMAD_Openclaw — a bridge from the method to OpenClaw; 309 stars.
ljxpython/bmad-method-tutorial — personal tutorial and practice in Chinese (“bmad-method使用教程及个人实践”); 150 stars.
echoVic/boss-skill — “Boss Skill,” a fully automated BMAD development pipeline with multi-agent orchestration, in Chinese; 555 stars.
rihebty/flow-kit — a fusion of bmad, spec-kit, OpenSpec, GSD, claude-task-master, and superpowers; 399 stars.
stephenleo/bmad-autonomous-development (107), bookmark/BMAD-METHOD-EXP (90), armelhbobdad/bmad-module-skill-forge (95), robertguss/bmad_automated (88), and salacoste/antigravity-bmad-config (65, Antigravity config).

The repository itself includes README translations: README_CN.md (Chinese), README_KR.md (Korean), and README_VN.md (Vietnamese), plus documentation at docs/zh-cn, docs/ko-kr, docs/fr, docs/cs, and docs/vi-vn.

Package registries (npm)

The npm ecosystem is broad and mostly third-party (consulted 09-11-2026): bmad-agent-init (Windsurf integration), bmad-mcp-server (MCP server for the method), bmad-statusline (for ccstatusline), bmad-invisible (orchestration layer), bmad-md (medical-device/SaMD module), bmad-odoo and convoke-agents (compatible agent teams), wdi-method (a method wrapping BMad), bmad-method-quarkus, and bmad-module-ultracode-goal.

Official and semi-official status

BMAD-METHOD isn’t a product from a major vendor, but it has a clear semi-official status within the “AI-driven development” / “spec-driven development” community:

Its own official distribution: the method ships via the official bmad-code-org/bmad-plugins marketplace (installable in Claude Code with /plugin marketplace add bmad-code-org/bmad-plugins and in Codex with codex plugin marketplace add bmad-code-org/bmad-plugins) and via the Skills CLI (npx skills add bmad-code-org/BMAD-METHOD).
De facto standard for the role-based agent pattern: the method was cited in the Hacker News thread “The Claude Code Framework Wars” (id 45155302, 125 points, 13 comments, Substack, 09-07-2025), which maps the Claude Code framework ecosystem and lists BMAD-code among examples of the role-based approach. There’s no formal “standard” designation from any vendor, but its presence on that kind of list and the abundance of community modules make it a de facto reference for the “agent SDLC with artifacts” pattern.
Commercial accreditation: the project presents itself as “the standard for enterprise AI delivery,” with optional training/certification and consulting at bmadcode.com. The core is 100% free and MIT-licensed (“No paywalls. No premium tiers. Ever”).
Brand: “BMad” and “BMAD-METHOD” are registered trademarks of BMad Code, LLC (see TRADEMARK.md); community modules must use naming conventions like “My Module (BMad Community Module).”

Quick-start guide

Installation and first run

Requirements: an AI coding tool that supports skills, Node.js + npm and Git, and uv (from Astral) for setup and Python scripts.

Skills CLI route — inside your project:

npx skills add bmad-code-org/BMAD-METHOD

Select the skills and the code tool you want; include bmad for setup and help.

Claude Code plugin route (inside Claude Code):

/plugin marketplace add bmad-code-org/bmad-plugins

Codex plugin route (from the terminal):

codex plugin marketplace add bmad-code-org/bmad-plugins

On either marketplace, install bmad-method (delivery flows) and bmad-toolbox (standalone skills, including the bmad hub). Open your tool in the project and ask the bmad skill to run bmad setup; then invoke bmad-build with what you want to change. Ask bmad whenever you want guidance on what’s next or what’s optional.

Updates: bmad update checks versions; install updates with npx skills update or your marketplace; then ask bmad doctor to repair the project’s existing runtime.

Common workflows

To plan a clear change: run bmad-spec with the intent; it produces SPEC.md (and companions under specs/spec-<slug>/) and, if epic-sized, stories.yaml. Then run bmad-build with the intent; the implementation lands under the spec’s folder.
For a new multi-epic product: use bmad-prd (for the shared product document) and bmad-architecture (for ARCHITECTURE-SPINE.md), then bmad-spec per epic, bmad-create-epics-and-stories to split it up, and bmad-retrospective to close each epic.
To work on legacy code: start with docs/existing-codebases/start-in-an-existing-codebase/, which establishes verified context on what already exists before building.
For an unsupervised epic: once decisions are stable, bmad-build-auto (or the bmad-loop module) builds, verifies, and retrospects the complete epic.

Essential configuration

AGENTS.md — the project’s agent contract; since v6.12, bmad-project-context adopts a hand-written AGENTS.md instead of rewriting it.
SPEC.md (+ specs/spec-<slug>/ folders) — the contract for a concrete intent; the main input to bmad-build.
stories.yaml — the order of stories within an epic; bmad-retrospective reads it as the epic’s inventory.
prd.md / ARCHITECTURE-SPINE.md — shared documents when several epics or engineers need to follow common decisions.
sprint-status.yaml — story status generated by bmad-sprint-planning (PASS/CONCERNS/FAIL).

Common pitfalls and fixes

Excessive token burn: the full flow reloads documentation every session. An r/ClaudeAI user (1rure2k, “Burning too many tokens with BMAD full flow”) reported this; the shared fix (user jayjaytinker) was to treat the documents as reference files Claude reads on demand, not as context loaded every session.
AGENTS.md bloats: an r/ClaudeAI user (1n79qvq) warned that “BMAD adds to the AGENTS.md file quite a lot.” It’s worth reviewing and trimming the file, especially on small projects.
Over-ceremony / overkill for small tasks: several sources (HN, Reddit) note the method is heavy for small changes. The project’s own documented response is to use bmad-spec, which “adapts to the size of the work,” and, for an obviously low-risk change, not to install BMad at all.
Breaking changes between versions (e.g. v6.12.0): persistent_facts arrives empty (re-add project-context.md to your override if you relied on auto-load) and {diff_output} became {diff_file} in review overrides.
File-reference validation errors: for YAML/Markdown skills, the validator is uv run tools/validate_file_refs.py --strict.

Integrations and migration

AI coding tools: the README documents installation for Claude Code, Codex, and via Skills CLI for tools supporting skills (Cursor, Cline, Roo, Aider, etc.); Polytoken, Grok, and ZCode were also added to the installer in v6.12.
MCP: the bmad-mcp-server npm package exposes the method as a Model Context Protocol server.
Bridge to autonomous execution (Ralph): LarsCowe/bmalph and hieutrtr/RalphMAD combine BMAD’s planning with snarktank/ralph’s (21,756 stars) execution loop. Typical flow: BMAD generates spec/epics/stories → Ralph executes them one by one until the PRD is complete.
Status line / CI: bmad-statusline integrates the flow’s status with ccstatusline; the bmad-method-ui module offers a VS Code extension.
Migrating from other frameworks: there’s no official documented migration path; in practice the community uses BMAD instead of SuperClaude, Claude Flow, or spec-kit (see the comparison). “Migrating to” BMAD means installing the skills and generating the artifacts (brief/PRD/spec) over existing code, starting with the “existing codebases” guide.

Current metrics

Measured: September 11, 2026, GitHub API.

Metric	Value
Stars	52,875
Forks	5,982
Subscribers (real watchers)	417
Primary language	Python
License	MIT (README badge; the API returns `NOASSERTION` in `license.spdx_id`)
Created	April 13, 2025
Last push	September 10, 2026
Latest stable release	`v6.12.0`, September 4, 2026
Last commit on `main`	September 6, 2026 (`abe4eb1b`)

Caveats: the GitHub API makes watchers_count mirror the star count; hence subscribers_count (417) is reported as the real subscriber count. The open_issues_count field (33) includes both issues and open pull requests, not just issues. The total commit count couldn’t be obtained (the commits search API returned total_count: null); the date of the last commit on main is reported as an activity proxy.

Top contributors (by commits, per the API): alexeyv (644), bmadcode (187), semantic-release-bot (91), muratkeremozcan (61), dracic (23), lrliang (15), pbean (13), ksylvan (13), forcetrainer (13), jheyworth (8). The top contributor by volume (alexeyv) is a core maintainer, not the founder.

Community reception

The real BMAD-METHOD discussion isn’t in dedicated Hacker News threads (the ~8 direct submissions have low reach, between 1 and 4 points and 0 comments; the oldest is “BMad-Method: Universal AI Agent Framework,” id 44879862, 08-04-2025, 4 points). The conversation happens as comments inside popular AI-coding threads, and on Reddit it’s dominated by r/ClaudeAI. Opinion is split: there are clear fans and repeated objections.

Praise (named users):

matt3D (HN 45155302, “The Claude Code Framework Wars,” 125 pts): “Pretty surprised BMAD-method wasn’t mentioned. For my money it’s by far the best Claude Code compliment.” He repeated the endorsement later (“my go to is the BMAD method”).
easygenes (HN 44081081, “Peer Programming with LLMs,” 213 pts/15 cmts): “The best structure I’ve found… is called BMAD, and treats the LLM as though it were a whole development team in an orchestrated way that you have full control over.”
redact207 (HN 48002442, “Agentic Coding Is a Trap,” 463 pts/67 cmts): “bmad-code-org/BMAD-METHOD is really good and I’ve onboarded a few SaaS projects into it now. Tech speccing and multiple cycles of elicitation are what deal with all the edge cases.”
ValentineC (HN 47282777, “Tell HN: I’m 60 years old…,” 1086 pts/206 cmts): “I’ve been using BMAD for planning and speccing out something fairly elaborate, and it’s been a blast.”
sminchev (several threads): “I like it, I use it, I see high potential… it gives good results.” — while qualifying the cost: “It is expensive, I know… it takes a lot of tokens and the $20 is just not enough, but [it’s] worth it.”
On Reddit r/ClaudeAI, thread 1m9lqfv (“SuperClaude vs BMAD vs Claude Flow…,” 50 upvotes, 23 cmts) is mostly favorable: Sir-Noodle (12) “I prefer BMAD. It is more extensive in terms of planning but delivers best results imo.”; Are_we_winning_son (5) “BMAD without question.”; RecentQuarter (1) “Been using BMAD for over a month now. So far it’s great… also learning to become a better product manager along the way.”

Criticism and concrete objections (named users):

MattGrommes (HN 47243272, “Agentic Engineering Patterns,” 543 pts/53 cmts): “There’s already BMAD… Basically, it’s Waterfall for Agents. Lots of Capitalized Words to signify something. Also they constantly call it the BMAD Method, even though the M already stands for method.”
taffyda vid (HN 47994012, “Specsmaxxing,” 287 pts/54 cmts): “I just spent a week training up in spec driven development through bmad, which was awful… unnecessary ceremony around the specs, generating fields of spec documents which presumably fill up the context window quickly.”
paulnovacovici (HN 46743908, “Claude Code’s new hidden feature: Swarms,” 521 pts/43 cmts): asks whether the method reaches 90% “production-ready” code but fails on the last 10% as technical debt grows.
desireco42 (HN 47417804, “Get Shit Done,” 473 pts/65 cmts): “this was completely not very much useful… all smoke and mirrors. I would maybe use BMad, which suffers from same issues, like Speckit… I don’t know if they have some sponsorship with bunch of youtubers who are raving how awesome this is… without any supporting evidence.”
vielite1310 (HN 47197595, “Verified Spec-Driven Development,” 211 pts/35 cmts): asks whether RPI, BMAD, or other spec-driven approaches actually work on medium/large projects “without wasting millions of tokens.”
The most critical thread found is r/ChatGPTCoding 1o6j1yr (“Spec-driven development for AI is a form of technical masturbation and frameworks like Spec-kit, bmad, Openspec are BS,” 39 upvotes, 55 cmts): OP im3000 claims “Context drift and pollution… you try to hand them a 4-page long spec and expect good results? Please!… Also mad token burn.” The top-voted pro-BMAD reply (Chetan496, 27) responds: “each task is supposed to be completed in a new session. That way there is no context pollution.”
On r/ClaudeAI, n0beans777 (1mmn41s): “it was bloating my projects out of proportion. Overly documenting everything, running around in circles.”; nizos-dev: “Agents are happy to over-engineer… I don’t use personas and I don’t see the point.”; stingraycharles (1m9lqfv): “These pre-built workflows are very meh… generic and generally total overkill.”

Honest synthesis: the consensus isn’t uniform. Defenders value it for clarifying vague ideas and planning at scale (new products, teams with a shared PRD, legacy code); critics point to high token cost, over-ceremony for small changes, and the risk of over-engineering. The recurring counter-argument is that the problem isn’t the method but the usage: “you’re using the specs the wrong way — split into per-session tasks.”

Comparison with similar projects

Project	Verifiable overlap	Verifiable difference
`snarktank/ralph` (21,756 ★)	Automates the development cycle through PRD completion.	Ralph is an autonomous execution loop that repeats until the PRD closes; BMAD is a planning-and-delivery method with artifacts. They aren’t direct rivals: projects like `bmalph` and `RalphMAD` combine them (BMAD plans, Ralph executes).
Spec-driven development (spec-kit / OpenSpec / VSDD)	All generate specifications and tickets the agent fulfills.	BMAD adds role-based agents (PM, architect, UX, dev, QA) and a complete agile flow with Kanban; the others focus on the spec → code cycle. Reddit users group BMAD with spec-kit and OpenSpec in the same category (“BS” to some, “brilliant” to others).
SuperClaude / Claude Flow / Awesome Claude	Plugins/skills that extend Claude Code with roles and flows.	SuperClaude and Claude Flow are shards/skills for a single tool; BMAD aims to be IDE-agnostic (Claude Code, Codex, Cursor, Cline, Roo, Aider, etc.) and delivers portable documents.
TaskMaster	Task orchestration for code agents.	TaskMaster focuses on managing/backlog of tasks; BMAD covers the full SDLC from idea to retrospective. On Reddit both are mentioned together in “lock-in” debates.

How to contribute

CONTRIBUTING.md documents a specific, strict process:

Talk in Discord before coding if the change adds functionality, restructures code, or touches more than a couple of files. “A large PR out of nowhere has a high chance of being closed, regardless of effort invested.”
Issues and requests always via GitHub Issues (bug report and feature request templates).
Branches: development happens against dev (the development branch), and main is release-only. There’s a V6.12 branch for npm maintenance. PRs opened against main get redirected to dev.
PR size: ideal 200–400 lines, max 800 (excluding generated code), one feature/fix per PR.
AI-generated code: most contributions are expected to use AI, but intensive human curation is required; PRs that “read like raw LLM output” (massive unrequested refactors, unsolicited “improvements”) are rejected.
PR template: What / Why / How / Testing sections, under 200 words. Conventional commits (feat:, fix:, docs:, refactor:, test:, chore:), under 72 characters.
File-reference validation: uv run tools/validate_file_refs.py --strict (for *.yaml/*.md/*.xml).

The project also maintains tools/validate_skills.py, tools/quality.py, and a bmad-eval-quality harness for quality/evaluation.

Use cases and who this repository can help

Teams or tech leads who want spec-driven development at scale: the bmad-prd → bmad-architecture → bmad-spec → stories → bmad-build-per-session flow gives a new multi-epic product with documented shared decisions and per-epic tracking. Suited to organizations where several engineers build in parallel and need a PRD as a document everyone approves.
Solo/indie developers on large projects: for a project that doesn’t fit “one-shot,” the method organizes the work. An r/LocalLLaMA user built a complete web app with a local Qwen 3.6-35B using BMAD; another described cutting onboarding to ~15 minutes at their company. It isn’t meant for quick bug fixes on legacy systems (the same user acknowledges this).
People inheriting someone else’s / consolidated codebase: the “existing codebases” path (bmad-deep-recon, bmad-project-context) establishes verified context on what already exists before modifying it, instead of guessing.
Product teams needing to clarify vague ideas: bmad-brainstorming, bmad-forge-idea, and bmad-prfaq test an idea until it hardens or dies cheap, before code gets written.
Those working with local or open models: bmalph/RalphMAD and the execution flow allow using open models (glm, kimi, deepseek) to deliver complex apps.
Game studios and creative teams: the official bmad-module-game-dev-studio (Unity, Unreal, Godot, Phaser) and bmad-module-creative-intelligence-suite modules extend the method to those domains.
Those wanting to automate an unsupervised epic: bmad-build-auto or the bmad-loop module build, verify, and retrospect the complete epic once decisions are stable.

Resources

Repository: https://github.com/bmad-code-org/BMAD-METHOD
Documentation: https://docs.bmad-method.org/ (“Build your first change” guide: https://docs.bmad-method.org/start/build-your-first-change/)
Official skills / plugins: https://github.com/bmad-code-org/BMAD-METHOD/tree/main/skills · plugin marketplace: https://github.com/bmad-code-org/bmad-plugins
Official modules: Game Dev Studio, Creative Intelligence Suite, Test Architect, bmad-builder, bmad-loop (org bmad-code-org)
Official blog / changelog: https://blog.bmadcode.com/ (per-version changes at https://github.com/bmad-code-org/BMAD-METHOD/releases)
Web bundles (Gemini Gems / ChatGPT GPTs): https://bmadcode.com/web-bundles/
Community / Discord: https://discord.gg/gk8jAdXWmj
YouTube (tutorials and master classes): https://youtube.com/@BMadCode
GitHub Discussions: https://github.com/bmad-code-org/BMAD-METHOD/discussions
Package registries (npm, mostly third-party): https://www.npmjs.com/package/bmad-mcp-server · https://www.npmjs.com/package/bmad-statusline · https://www.npmjs.com/package/bmad-invisible
Curated lists (awesome-*): shanraisshan/claude-code-best-practice (65,835 ★), awesome-opencode/awesome-opencode (10,183 ★), eltociear/awesome-AI-driven-development (539 ★), quemsah/awesome-claude-plugins (1,283 ★)
Hacker News threads: 45155302 (Framework Wars) · 48002442 (Agentic Coding Is a Trap) · 47243272 (Agentic Engineering Patterns) · 44879862 (direct submission)
Associated projects: LarsCowe/bmalph · ErwanLorteau/BMAD_Openclaw · aj-geddes/claude-code-bmad-skills · snarktank/ralph

Methodology note: this article draws on the README, CONTRIBUTING.md, docs.bmad-method.org documentation, release notes, and the GitHub API for BMAD-METHOD, the Hacker News search API, and Reddit mirror archives consulted on September 11, 2026. Figures (stars, forks, contributions) change over time; Reddit upvote counts are archive snapshots.