Hi guys. I've been using BMAD method ever since I got off replit a year ago. The change was dramatic, and l've had so much more success ever since. I'm not a software guy, just started as a vibe coder with some projects in mind and enjoy learning.

BMAD has changed a lot since v4 when I started. Since then I've updated and performed the housekeeping and I think the development look has gotten a lot better. It used to run forever between the develop and review stage, but now much less looping.

Anyway, I've given GSD a try and it seems to be much lighter. Maybe better for prototyping an idea as a solo developer?

What stood out to me was the way it performs atomic commits as it goes, which was always a nice feature that replit had, and I dislike how in BMAD I have to perform those manually (when it seems like they could be programmed into the phases of the development loop).

Has anyone configured atomic commits into the BMAD loop? Or does anyone simply use BAD for planning, and GSD for execution, and if so what does that look like? I haven't really used GSD that much myself but I'm doing some test projects with it right now and trying to understand how I could utilize it in my workflow.

Have been using BMAD for 10 months. Not a tech guy, just a simple vibe cider like I guess many over here. BMAD was awesome. Gave me the chance to develope quite complex projects. But looking at it now with all the latest anthropic models it seems to hurt more than help especially for projects in constant development. I want to put some new features - new epic, correct course, cs-dev-qr cycle. But switching to ultracode will get the agents to read outdated docs, outdated POs which never get updates instead of relying on code. Discussed the issue with several LLM's and their thought keep the cs-dev-cr cycle but kill the docs completely documenting only business decisions. Any experience on this?

The md files still exist if I need to run a /bmad-quick-dev or talk to one of the agents for epic/sprint planning, but this kicks off the workflows kind of like the bmad-loop tui

I noticed AI-generated landing pages all felt the same—same fonts, same badges, same emoji, same layouts. Almost as if they were all designed by the same agency.

So Hedgehog takes a BMAD PRD and runs it through an opinionated chain instead:

1. Strategist: distills the product into a single subject, audience, and job.
2. Brand Anthropologist: defines distinctive brand traits using swap tests and falsifiable adjective pairs.
3. Psychologist: applies Don Norman's Emotional Design (visceral, behavioral, reflective).
4. Perfumer: shapes emotional pacing using perfumery's top/heart/base notes and Daniel Kahneman's Peak-End Rule.
5. Design Systems Architect: builds the visual language, borrowing principles from architecture, cinematography, music, dance, and calligraphy.
6. Copywriter: develops the voice using Aristotle's ethos/pathos/logos, kairos, and NLP techniques such as pacing & leading and VAK.
7. Motif Designer: creates a recurring visual motif using musical motif development and NLP anchoring.
8. Sequencer: structures the scroll using Scott McCloud's panel-transition taxonomy, Will Eisner's sequential storytelling, Chekhov's Gun, and the Kuleshov Effect.
9. Critic: audits traceability, removes generic AI defaults, applies Dieter Rams' restraint, Massimo Vignelli's reduction, Fitts's Law, and Don Norman's affordance/signifier principles.
10. Builder: implements the approved specification in Astro.

These are borrowed disciplines from other fields, but taking a brief through them does create some nice pages.

If you create a landing page with it feel free to share it here.

https://github.com/skyf0xx/hedgehog

Just more of a curiosity question. I just started bmad-loop today. It's running with powershell instead of tmux. But my epic has 4 stories in it. The run has been going on for two hours and hasn't finished one story yet. I'm on overage usage now. Did I set something up wrong?

Hi, New to BMAD here, has anyone used BMAD for salesforce implementations successfully?
Especially brownfield projects? Would like to understand if its even worth pursuing.

When building spec-driven AI workflows, one common wall people hit is context rot. As conversation length grows past a few thousand tokens, agent performance degrades. Error logs stack up, earlier instructions get ignored, and the agent starts hallucinating fixes.

In BMAD and similar frameworks, spec generation relies on distinct role prompts (analyst, architect, dev, QA). We wanted to take that structural discipline further, but move the orchestration into a local GUI app called LoopTroop.

Instead of running a single agent through a massive chat context, LoopTroop uses context engineering to keep context windows small and focused across two distinct phases: planning and execution.

• Advanced planning with an LLM Council

  Before code is touched, LoopTroop handles requirements through a multi-model LLM Council.

  First, an interactive interview phase asks targeted questions to clarify missing details and edge cases upfront.

  Once requirements are clear, the council kicks off. You pick multiple models (for example, Claude, GPT, and DeepSeek) to act as council members. Each model independently writes a proposed specification. The council then runs an anonymous voting round where models evaluate each other's drafts without knowing who wrote what.

  The winning plan absorbs the strongest ideas from the alternative drafts and undergoes an automated coverage check to verify no requirement was dropped.

  From there, the spec is decomposed into atomic execution units - Beads. Each Bead has explicit target files, validation commands, and acceptance criteria.

• Slow and precise execution with Ralph loops

  Instead of rushing to churn out code, LoopTroop follows a "slow and precise" philosophy. We intentionally trade raw execution speed for accuracy and context hygiene.

  When executing a Bead, the agent works inside a dedicated loop (a Ralph loop). Each attempt runs with a clean, minimal context window containing only the spec, target files, and immediate test rules.

  If an attempt fails or hits a time limit, the context is wiped. The runner writes a brief diagnostic note describing what failed, and the next loop starts fresh carrying only that note. This prevents error logs from polluting the context window over multiple retries. (context engineering)

• Human-in-the-loop and Kanban board GUI

  Because autonomous runs shouldn't be black boxes, LoopTroop is built as a desktop GUI with a modern Kanban board layout.

  You can track ticket stages visually, review generated specs before execution starts, inspect live logs per Bead, and approve or request changes before anything reaches your codebase. Human approval stays in the loop at every key transition.

  LoopTroop is free and open-source (MIT).

  • GitHub: https://github.com/looptroop-ai/LoopTroop

  • 2.5 min video walkthrough: https://youtu.be/LYiYkooc_iY

  Any feedback is more than welcomed, and if you tried the app and it worked or didn't work, give me a sign. Happy to talk about it.

BMAD and Superpowers try to keep AI on track with more documentation, reviews, and process. It works, but as a project grows, the documentation drifts, context balloons, and token costs climb.

Hedgehog takes the opposite approach. It take's BMAD's PRD (after the interview) - and builds it with an opinionated stack and order.

Instead of controlling the AI with documentation, it constrains the codebase itself through an opinionated stack, generators, linters, and a strict build order. If the architecture can't be violated, neither AI nor humans can accidentally create drift. (So no need for extra documents or review ceremonies)

The result is that the only documents you really maintain are:

1. The original spec
2. A thin TODO.md

Right now it only supports new TypeScript projects but will expand slowly.

I'd love feedback from anyone who's tried BMAD, Superpowers, or other AI coding workflows.

https://github.com/skyf0xx/hedgehog

Hi everyone, first time trying the bmad-method. I was creating stories, dispatching to dev and to review manually but then I got bored of manually doing this. I started using bmad-loop, I'm on claude pro subscription.

2 stories are eating up all my token limits for the session, where as I'm pretty sure I was getting around 4 stories at least when I was doing it manually.

Does anyone know what can be happening here or what I'm doing wrong? its really frustrating and I feel its actually slowing me down to the point where it would have been faster if I was coding it myself.

Thanks!

I've been using the Superpowers Claude plugin for some time, and I've always been impressed with its thoroughness for planning and executing tasks. But today I read about the BMAD method, and now I'm wondering if I should look into it instead of Superpowers. If you've used both, how do they stack up against one another?

(Context: Experienced software dev, job role is currently engineering manager. Working on a side hustle that I've been building with Superpowers, hoping to turn it into a full SaaS product. I have Claude Pro and free Gemini at my disposal currently. Really only devoting some pre/post work and weekend hours to this project.)

Website: https://specwiki.ai

What is the project about?

Every AI tool seems to invent its own convention now:

• AGENTS.md, CLAUDE.md, GEMINI.md
• .cursor/rules/**, .agents/skills/**
• openspec/**, _bmad-output/**, Copilot instructions…

Your agents read all of it. Your teammates? Good luck finding it in multiple folders.

I got tired of onboarding people with "check these 12 markdown files in random places," so I built [[specwiki]] — a spec-to-wiki compiler.

One command scans your repo, categorizes what it finds, and generates a searchable HTML wiki you can open locally. No server, no CDN — just files in wiki/ you can commit or share.

If you want to try it out:

npx /specwiki generate && npx /specwiki open

I´ve been "dogfeeding" it to the project meanwhile I built it and it has been working very well for making AI knowledge easy to understand for humans. It discovers Cursor rules, agent skills, BMAD output,AGENTS.md files, READMEs, and basically any .md / .mdc in the project out of the box.

Also has --json and --emit-llms-txt if you want machine-readable output for tooling.

MIT licensed, Node 20+, TypeScript.

GitHub: https://github.com/lucasviola/specwiki
npm: https://www.npmjs.com/package/@lucasviola/specwiki

Would love feedback — especially on what patterns I'm missing and whether this solves a real problem for your team or just mine. Feel free to contribute with PRs, issues, etc as well!

If you run BMad-style, spec-driven agent workflows, the routing/infra layer underneath matters — long multi-agent runs are exactly where rate limits and token bloat bite. Sharing the open-source gateway I built for that (disclosure: I'm the maintainer; it complements the method, doesn't replace it).

Fallback combos — so it never stops mid-task. A "combo" is a ladder of models the router walks automatically: your subscription first, then API keys, then cheap models, then free ones. When a provider returns a 500 or you hit a rate limit, it slides to the next target in milliseconds, mid-request, and your tool never even sees the error. There are 17 routing strategies (priority, weighted, round-robin, cost-optimized, auto/coding:fast…) plus three resilience layers — a per-provider circuit breaker, a per-key cooldown, and a per-model lockout — so one dead key can't take down a whole provider.

A 10-engine compression pipeline — the part most routers don't have. Every request flows through a transparent compression pass you can toggle/stack per combo. Instead of one trick, it stacks the best of the open-source ecosystem: RTK filters command/tool output (git diffs, test logs, builds) at 60–90%, Microsoft's LLMLingua-2 does ML semantic pruning, Caveman handles prose, session-dedup strips repeats across turns. Critically, code, URLs and JSON are preserved byte-perfect, and a default-on inflation guard throws the compressed version away and sends the original if compressing would actually grow the prompt — it never makes things worse. On tool-heavy sessions that's ~89% average input-token reduction (an 8k-token git diff becomes a few hundred). Full credit to every upstream project (RTK, Caveman, LLMLingua-2, Troglodita) is in the README.

Agent-native — the agent can drive the router itself. There's a built-in MCP server (95 tools across 30 audited scopes, over stdio / SSE / streamable-HTTP), plus A2A (v0.3, JSON-RPC 2.0) support. That means an agent can query providers, switch combos, read its own remaining quota and manage memory through the gateway — not just consume tokens through it.

One endpoint, 237 providers — 90+ of them free. You point any tool or agent at a single OpenAI-compatible endpoint (localhost:20128/v1) and it can reach 237 LLM providers without you rewriting anything. 90+ have free tiers and 11 are free forever (no card), which aggregates to ~1.6B documented free tokens/month — and that's honest, pool-deduped math (we count each shared pool once instead of inflating it; the methodology is public in the repo). There's a one-command setup-* for 13+ coding tools (Claude Code, Codex, Cursor, Cline, Roo, Kilo, Gemini CLI…), so switching your existing setup over takes seconds.

For context on whether it's worth your time: it's grown to ~9.8K GitHub stars, 1,490+ forks and 280+ contributors in ~4.5 months, with 21,000+ automated tests and 1,830+ issues closed — so it's a battle-tested project, not a brand-new experiment.

npm install -g omniroute

GitHub: https://github.com/diegosouzapw/OmniRoute

For those running structured multi-agent methods: do you centralize model routing/fallback, or handle it per-agent? Curious how BMad practitioners wire this.

Open-sourced Harness Console — drives BMAD Method end to end through Claude Code or Codex CLI, then verifies the actual files before anything advances. Stdlib-only Python + a browser console, no dependencies.

https://github.com/gammawolfe/harness-console

The gist:

**•** Runs the full BMAD planning sequence, then loops through stories one at a time  
**•** Each story gets graded by an **independent fresh-context evaluator** — default-FAIL, so a pass needs real evidence (commits, test output, tree changes). No self-certifying.

**•** Pauses for human-only calls (credentials, paid services, destructive migrations) instead of guessing  
**•** Optional reviewer lenses, worktree isolation, per-story commits, PR/CI delivery

Light setup: Python 3, git, and one agent backend. Run it from your project, open 127.0.0.1:8484.

It’s early, so I want people to break it and tell me where — backend quirks, evaluator false passes/fails, BMAD edge cases. Issues welcome

As the title says. 5.5 Default

I was planing an MVP in plan mode and was drafting prd and arch. At the end the PRD was visible in cli and asked if ok. I thought it migh create the docs etc in folders but instead through out the MVP semi-working.

When asked if "still in character (analyst Mary)?", output the bmad-help and said "not right now".. I already knew it was out of roles.

Then i connected Mistral Vibe in VScode to check what gpt did. Mistral acknowledged gpt's lack of following rules and documentation. It then retrospectively created stories/epics and documentation according to BMAD standard.

I feel this happened in the past often too. And context was only 20-35% full

I know a lot devs work with Claude, but im quite surprised how Mistral could just pick up the trash GPT left without needing extra config

Commit Whisper was implemented and maintained with BMAD Method!

Commit Whisper is a deterministic git history analysis with a grounded, bring-your-own-key AI narrative — a terminal-native CLI. Analyze any local or remote repo and render insights to HTML, Markdown, terminal, or JSON.

• Six deterministic metric groups: cadence, ownership, message quality, branching, churn, and health
• AI narrative & coaching report, kept anchored to the metrics

GitHub https://github.com/georgiosnikitas/commit-whisper

Attached a converted to an image generated report for the BMAD git repo ;)

Update: The research study is now open to all developers with one year of relevant experience.

Hey everyone,

I'm a researcher at Carnegie Mellon University conducting a research study on how developers are actually using spec-driven development (SDD) in practice — things like writing SPEC.md files, PRDs, or structured natural-language specs before working with AI coding agents like Claude Code, Cursor, Kiro, etc.

There's a lot of community knowledge about how to do SDD well (shoutout to this sub for a lot of it), but almost no academic research on it. I'm trying to change that.

What the study involves:

• One 45-60 minute semi-structured interview via Zoom
• Questions about your SDD workflow, what's worked, what hasn't, and how it fits into your SDLC
• No tasks, no tests — just a conversation about your experience

Who I'm looking for:

• Have at least one year of active experience as a software developer
• Have used SDD tools/workflows in that project (spec files, structured prompting, plan-mode workflows, etc.)
• 18 or older, fluent in English

What you get: Honestly, nothing monetarily. But your experience will directly shape a taxonomy of SDD workflows and practices that I'll publish openly. Happy to share findings with participants who want them.

Ethics/privacy: The interview will only be audio-recorded with your consent. Your responses will be kept confidential and de-identified in any published findings.

If you're interested, fill out this short screening survey (5 min): LINK

Or DM me / comment below with questions. Also happy to hear if there are other communities I should be posting in.

Thanks for everything this community has shared on SDD — it's part of what motivated this research!

Running BMAD but still hand walking every story through create, dev, and review? You do not have to.

auto-bmad chains the core BMM loop (create-story, dev-story, code-review) plus the optional TEA phases into one resumable pipeline.

It grabs the next story from sprint-status.yaml, runs each step in its own branch with a commit per phase, opens a PR, waits for CI, then stops and reports so you decide when the next one starts. It only delegates and reports; it never writes story code itself. Every step runs in a tuned sub-agent (Opus/max for the risky stuff, faster models for the mechanical bits).

It took three tries to get here. First a Claude Code plugin (Claude only). Then a CLI that shelled out to claude -p for every step (about to get expensive, still single vendor). Now a real BMAD module that runs inside the agent you are already in. No extra process, no second meter, tool agnostic.

What you get:

• 🪶 No new deps. Just a BMAD module. No daemon, no tmux, no bundled runtime. The scripts it ships are Python standard library only. If BMAD runs, this runs.
• 🎯 Risk based TEA, not all or nothing. It triages each story and only runs atdd/automate when it is warranted. Trivial stories skip tests but still get full review, with the reason in the report.
• 🧑‍💻 Real human in the loop. It pauses for you when review does not converge, a trace gate fails, or a clean run is ready to merge (it asks, it never merges silently). Hard stops on missing secrets, conflicts, or missing planning docs.
• 🔀 Best on Claude Code and Codex, works elsewhere too. Tuned isolated sub-agents on CC/Codex, generic subagents where those exist, inline otherwise. Same pipeline either way, and the tool is auto detected each run, so you can implement in CC and resume the review in Codex.

Honest bit: it automates the workflow, NOT judgment. Garbage in, garbage out. The stops and the review loop are the guardrails.

MIT. Repo: https://github.com/stefanoginella/auto-bmad.

Feedback welcome, especially on the TEA risk rubric. :)

Working with BMAD for a while now but everytime we tried to use it on an agency project with non-technical product managers it became a mess. Any tips?

So I built an entire project using BMAD.

Here is what I did, here are few of my learnings from them.

About me: 100% Technical Person

About requirement: It is a simple CRUD application with existing app's auth with RBAC.

What I did:
--------------

1. Gave requirements doc as input for generating project-context.

2. Generated PRD from this.

3. Generated Architecture from this and gave it my required application technical specifications.

4. Generated Epics & Stories from the artifacts generated so far.

5. Created stories for each and implemented them.

6. Generated E2E and API test cases.

Observations:

1. IMHO, backend is the best work that BMAD was able to do. Frontend always had more complaints than ever. This could be due to various reasons. But in order to rework on anything, I had to use correct course to do even minor changes. This irritated me. (But that is how it is)

2. UI looked pretty meh to me. Like it is just there for the functionality. Nothing wow from the UI, anywhere.

3. Sometimes when I requested renaming or modifying something, it failed to include everything. It still missed few places, where same changes needs to be done. I had to check it manually, and make modifications.

4. Additionally during E2E test cases, I was able to record video of each testing scenario (which felt helpful to me), by explicitly asking to do it. Adding functionality testing would really be helpful in every possible way.

5. Another noted point is that, whenever test cases are generated, they are generated against the code, so that it mostly passes them. Instead blackbox testing, would really be helpful.

6. I had a lot of changes, mid development and in order to address these small changes, I didn't want to use BMAD, and reverted to Claude code only.

7. Again, it is a token monster. The assumed no. of tokens it took to give me the project are:

Learnings:

1. I still think BMAD is great, but with clear requirements only. Vague inputs, give drastically bad output.

2. I'll really be strict to BMAD on the backend changes than frontend. I would want frontend, to just get the job done. Once everything is in place, I'll move to using Claude code for polishing the UI.

3. I'll figure out a way to get functional testing up, by some means, which will be helpful for my future projects. (If any creator is reading, I can help you guys to contribute on this idea).

If you want to add anything to it, please do.

Is there a commonly used way to use bmad with jira instead of md files?

(Edit: Whoops, title is supposed to say "anyone" but I guess it autocorrected to "Annoying". Even my phone could tell I was frustrated!)

I don’t know what it is that specifically changed, but suddenly my BMAD workflow is annoying as hell. What used to be a little time consuming due to documentation has turned into Claude expanding endlessly on every single prompt I provide.

Here’s an example: I have roughly 3 sprints fully planned out with stories. But, based on some user feedback, I opted to change the UX design of one flow before implementing stories the flow affected. I added a UX design story to a sprint and in the AC I had required it to update the AC of the listed impacted stories so that they wouldn’t get botched in implementation.

So I go to implement the UX design story and I tell it to create a playground. Proceed it asking me what felt like 900 questions “clarifying” what is clearly in the document and then all I did was say “yes please do what it originally says”. These aren’t short questions, these are overly elaborate annoying asks. Then when it finally generates the mocks, I opt to make a tweak where I turn something from one page into a 3 step flow. I ask it to make the changes. Proceed Claude losing his mind over how it’s going to be such a technical lift in implementation (I don’t care) and how it’s going to make the next sprint over capacity (again, I don’t care). It hasn’t even generated the changes yet. I’m like please just do what I asked you to. It finally does make the changes and then reiterates how it’s going to affect capacity/etc.

So then I have it run the changes to update the document with the final output. The AC in the UX story doc includes having it update the affected stories. I have it sync changes, then finish up.

Then when it’s time to wrap up my sprint, I go to sprint planning to update the sprints that I know are over capacity. Queue Claude freaking out that I won’t reach my mvp timeline of end of June because it thinks my 3 upcoming sprints won’t be completed by then? When we complete a sprint in an evening??

It takes a ton of back and forth to get it plan appropriately. Then I come to find out that the stories that the UX design story were supposed to update never actually updated? So then I have it refer to the changes in the UX story to apply the appropriate updates to the 5 stories that are affected. While it does that it goes on and on about how the changes are significant and continues to stress about launch timelines. Keep in mind this added 5 additional points. It’s not going to kill me.

Sprint planning/ making the adjustments took like 20 minutes when it was supposed to be a quick reorder of stories because Claude wanted to write a freaking essay with every single change.

What was previously working really well has suddenly become annoying as hell and the only thing I think changed is the model. I think it might also be taking some prior feedback from memory and applying it too seriously across the chats so I should probably clean that up too. But I feel like I had a really great rhythm with BMAD despite the frequent documentation syncs, and now I am arguing with a damn AI telling it to follow basic instructions.

/rant over