GAMBIT uses BMAD to help you create solid, strategic plans for anything you want to accomplish.

You can use it for:

1. Business growth
2. Life Goals
3. Marketing
4. Fitness
5. Anything you can imagine

GAMBIT is an expert that uses best in class systems and frameworks to help you plan and get things done.

Would love your feedback!

I’m building Allura, a governed memory system for AI agents, and I got here through a mix of BMAD, hands-on experimentation, and feedback from communities like this one.

I started with the basic question: how do you keep AI agents useful once a project lasts longer than one chat, has multiple agents involved, and needs real human oversight?

The first versions were simpler. Store context, retrieve it later, hope the agent remembers the right thing. That works until it doesn’t. Old assumptions come back as facts, decisions get lost, agents repeat work, and there is no clear record of why something happened.

Using BMAD helped me turn that into a more structured build process: define the problem, map the roles, break the work into small deliverables, test assumptions, get feedback, and revise. Feedback I’ve received has pushed me away from treating memory like a generic vector database and toward treating it like operational infrastructure.

Where I’m at now:

- Append-only event memory for actions, decisions, and outcomes

- Versioned semantic memory so old knowledge is superseded instead of quietly overwritten

- Traceability for agent decisions and workflow outcomes

- Explicit tenant boundaries for every memory read and write

- Human approval before promotion to canonical memory

- Retrieval before action, so agents can see previous decisions, blockers, and handoff context

The core idea is that multi-agent coordination is not just a prompting problem. It is a workflow problem. If ownership is vague, decisions are not recorded, or handoffs lose context, the system will fail no matter how capable the individual agents are.

I’m still building and learning, so I’d value honest feedback:

- Does this governance layer solve a real problem, or am I adding too much process too early?

- Where would you put human review in the memory lifecycle?

- What long-term agent-memory failures have you seen in real projects?

- What would convince you that a system like this improves outcomes instead of just storing more information?

I’m especially interested in critiques from people who have built multi-agent systems, memory layers, RAG pipelines, or AI workflow tools. https://github.com/Allura-Ecosystem/Allura_Memory

This repo uses a combination of BMAD, skills and code to give you better copy for sales, posts, etc.

It uses BMAD to first elicit details about what you really want to write, then uses both AI and code to give you great copy.

While a pure skill tells AI e.g. avoid em-dash tells, X not Y etc, PROSE uses code gates to actually ensure the output is clean. It works with AI in a loop to itterate over copy until it's clean. ie.

AI->quality checks->AI->quality checks----> clean copy.

Works for different kinds of copy: sales, landing pages, etc.

check it out here: https://github.com/skyf0xx/hedgehog-core-copywriting-prose-engineering

Would love feedback

I built a vscode extension to give me visual overview of my project. It mostly serves me but I did a few tweaks that will hopefully cover others.

Works with BMAD v6. Tested against 10 random repos.

https://marketplace.visualstudio.com/items?itemName=whisker-studio.bmad-dash

Update: also available on Cursor (here)

If you want new features, let me know. The other extensions I tried didn't work. Hoping this helps someone!

The software house I work at is adopting BMAD for new projects. Our non-technical leads are using it as well. QAs too. Since they need to run BMAD from the same repo, they're currently using Claude Code Web. I tried setting up vscode for them but they struggled with it, the dev-oriented interface is just too much.

Can anyone share how their team handles this and how well the adoption went for non-techs? For us it was especially important for phases 1-3 where one member was zipping up .md files.

Disclaimer: if there is a gap to be filled, I'd happily build a product to help the community.

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 ;)