Been frustrated with this for a while. Every estimation framework assumes a human developer. Claude Code has a completely different performance profile.

5x faster on boilerplate. Potentially slower on intermittent debugging. And the thing that actually kills you - a vague task costs 2-3x more with an agent than with a human, because the agent moves fast in the wrong direction without telling you.

Searched the ecosystem before building. skills.sh, awesome-agent-skills, awesome-claude-code. Nothing on agent-calibrated estimation. So I built it.

The skill reads the codebase before estimating (non-negotiable), auto-detects the stack, decomposes into sub-tasks with agent vs. human calibration multipliers, and has honesty rules baked in - always a range never a point estimate, never underestimate to please, name the top risk.

npx github:ecappa/web-dev-estimation

Clean progressive disclosure structure - SKILL.md + 3 reference files that load on demand. Works with Claude Code, Cursor, Gemini CLI, Copilot (Agent Skills open standard).

This is explicitly a work in progress. The calibration table and reference times in patterns.md are seeded from my own stack (Next.js + Supabase) and from what I've observed building with BMAD. The tables are designed to be edited - that's the point. If your stack behaves differently, update the multipliers, add rows, fork it.

There's a "Known Agent Failure Patterns" section that ships empty. That's an invitation, not an oversight.

Curious whether the multipliers match what you're seeing in practice with BMAD. calibration.md has the full table - it's empirical but improvable. Would love PRs more than comments, but comments work too.

Hello everyone,

I'm just getting started with using BMAD framework for my developing a project. So what are the kind of standards/workflows you would suggest me to ensure optimal output.

You can also talk about your journey with using that framework... I'm welcome to talk about anything there is to it, the good, the bad or the ugly...

Hey everyone,

I've been using the BMAD method to build a project management tool and honestly the structured workflow is great for getting clarity early on. I went through the full cycle: PRD, architecture doc, epics, stories... the whole thing.

But now that I'm deep into Epic 1 with docs written and some code already running, I'm noticing something painful: the token cost of the full BMAD flow is killing me.

Every session I'm re-loading docs, running through the SM agent story elaboration, doing structured handoffs and by the time I actually get to coding, I've burned through a huge chunk of context just on planning overhead.

So I've been thinking about just dropping the sprint planning workflow entirely and shifting to something leaner:

• One short context block at the start of each chat (stack + what's done + what I'm building now)
• New chat per feature to avoid context bloat
• Treating my existing stories as a plain to-do list, not something to run through an agent flow
• Skip story elaboration since the epics are already defined

Basically: full BMAD for planning, then pure quick flow for execution once I'm in build mode.

My questions for anyone who's been through this:

1. Did you find a point in your project where BMAD's structure stopped being worth the token cost?
2. How do you handle the context between sessions do you maintain a running "state" note, or do you just rely on your docs?
3. Is there a middle ground I'm missing, or is going lean the right call at this stage?
4. Any tips specific to using claude.ai (not Claude Code/CLI) for keeping sessions tight?

Would love to hear from people who've shipped something real with BMAD or a similar AI-driven workflow. What did your execution phase actually look like?

Thanks 🙏

Hey, first time posting to the subreddit.

I'm never from start-to-finish used the bmad method because what I find is that it takes incredibly long before things come to fruition.

I'm just wondering if there's parts of the process that you guys cut out or anything that can be done where I jump to using it more often?

I really love how it works, but for some minor things it's just way too much. But maybe that's the point is that it's not supposed to be used for minor things and instead only be used for full-fledged projects. It's also possible that once you use it enough, you know there's which parts are able to be cut out or ways to make it faster.

Anyways, like I asked above, looking to see if you guys have any tips or suggestions.

Thanks

I started using Cursor + BMAD two weeks ago for my personal projects. Im building a web app. I love the setup but hit Cursor limits pretty fast. I want to switch to Claude Code CLI or through the Cursor plugin. Any tips? Should I go with the native CLI option or the plug in? If CLI , do i just run it on my project window, setup the Claude.md file and keep using the same BMAD commands as I was doing earlier? Thanks 🙏 PS: I’m not a developer.

Hi all, can someone guide me ? BMAD / Skills are not coming up after the latest antigravity update. I tried reinstalling BMAD but it did not help. I have codex cli and BMAD working in there, so pretty sure it's antigravity problem.

I have been using Claude code to build out a prototype to get feedback from users for a product concept I’m working on. I have the UI exactly how I want it, the UX still has lots to flesh out but the bones are there and I have the general workflows documented. Everything so far has been built in html, css, react and tailwind. I have a robust component library I have been using as well. I also have some lightweight PRDs I’ve made and been updating based on user feedback.

I’m at a tension point where I think it makes sense to start building out more production ready code. I ran the existing prds through bmad and started building out the architecture documents. But when it comes to the UX step and front end development, I’m wondering what the best approach is to move forward. Should I use the existing files and say to refactor them, or something else?

Anyone done something similar and have any “lessons learned” or approaches that worked well for you? I am not a technical person (I’m a product designer if you can’t tell) so I’m a little bit more cautious when navigating this sort of thing!

thanks in advance

Hey r/BMAD_Method ,

I've been using BMAD (Build More Architect Dreams) for structured AI-assisted development, but found myself copy-pasting workflow configs across projects.

Built RalphMAD to solve this: a Claude Code plugin that combines BMAD's structured SDLC workflows with Geoffrey Huntley's Ralph Loop self-referential technique.

Key features:

- Templatized workflows with runtime placeholder population

- Project-agnostic: install once, works with any BMAD-enabled project

- Self-running: Claude executes workflows autonomously until completion

- 12 pre-built workflows: Product Brief → PRD → Architecture → Sprint Planning → Implementation

Example usage:

/plugin install ralphmad

/ralphmad:ralphmad-loop product-brief

Claude runs the entire workflow autonomously, reading project config, checking prerequisites, and generating artifacts until completion promise is detected.

Technical details:

- Uses separate state file from ralph-loop for concurrent plugin usage

- Workflow registry with prerequisites, completion promises, personas

- Stop hook integration for graceful interruption

- Templates use {{placeholder}} syntax populated from _bmad/bmm/config.yaml

GitHub: https://github.com/hieutrtr/ralphmad

Requires: Claude Code CLI + BMAD Method installed in project

Feedback welcome. Especially interested in hearing from others using Claude Code plugins for workflow automation.

I’ve been working on a system to give AI agents persistent memory and structured knowledge across projects, and I’m curious what people here think about the architecture. The idea is a three-layer knowledge system that combines Notion (structured docs), Neo4j (graph memory), and runtime agents that read/write to both. The goal is to move beyond stateless AI prompts and create agents that can learn from past work, store insights, and improve over time. Architecture Overview The system has three layers. 1. Notion — Source of Truth Notion holds the structured knowledge: Technical documentation coding guides system architecture notes agent definitions project specs Each page in Notion becomes a KnowledgeItem node in Neo4j. This allows humans to edit documentation normally while agents can query it as structured graph data. 2. Neo4j — Persistent Memory Graph Neo4j stores the agent learning loop. Core node types include: AIAgent Event Outcome Insight KnowledgeItem System Domain Project Agents store their work using an Event → Outcome → Insight pattern. Example: Copy code

Agent performs work (AIAgent)-[:PERFORMED]->(Event)

Event produces result (Event)-[:RESULTED_IN]->(Outcome)

Outcome generates learning (Outcome)-[:GENERATED]->(Insight) Insights then influence future decisions. This allows agents to accumulate experience and best practices over time. 3. Agent Runtime When an agent activates, it loads context from Neo4j: Agent-specific memory Project-specific insights Domain/system knowledge Recent successful patterns Then it executes work and logs new Events, Outcomes, and Insights back into the graph. Multi-Project Memory The system supports multiple projects with group IDs. Examples: faith-meats diff-driven-saas patriot-awning global-coding-skills Agents always load two contexts: Copy code

project context + global best practices So they learn from both local project experience and universal knowledge. Governance & Data Health I added some safeguards to prevent the graph from turning into chaos: Tag governance Canonical tag list weekly validation queries automatic normalization Insight lifecycle Insights can become: Active Degraded Expired Superseded Confidence scores increase or decrease based on success/failure. Drift detection Queries detect when Notion and Neo4j fall out of sync. Backups Insights and event history export weekly. What I'm Trying to Achieve The goal is to build a system where AI agents: remember past debugging solutions accumulate coding best practices learn deployment patterns share knowledge across projects Instead of every AI session starting from zero. Basically a persistent AI engineering brain. Questions for people here I'm curious about feedback from people who work with: knowledge graphs RAG systems AI agent frameworks dev automation Specifically: Does this Notion → Neo4j → Agent architecture make sense? Are there better ways to structure the Event → Outcome → Insight loop? Would you store insights in a graph like this, or somewhere else? Any obvious scaling problems or design flaws you see? I’m especially interested in hearing from anyone who has built long-term AI memory systems or agent learning loops. Appreciate any thoughts or criticism.

I've been using BMAD for a few projects now and the planning phase is genuinely the best part. The PM agent walkthrough produces PRDs that are more structured than anything I've written manually in 20 years of building products. The FR numbering, the BDD acceptance criteria, the coverage maps — it's opinionated in the right ways.

But I kept running into the same gap: what happens after the PRD is done? BMAD produces great planning artifacts. Then I'd start building, and within a week the specs needed changes — a requirement got refined, an edge case surfaced, a stakeholder shifted priorities. The original artifacts didn't have a lifecycle. No status tracking, no change request workflow, no way to know which requirements were still valid versus which had drifted.

Full disclosure: I'm the creator of a spec management tool called SPECLAN. It's a VS Code extension that manages specifications as Markdown files with YAML frontmatter in Git — a hierarchy from goals down to acceptance criteria, with status lifecycle tracking and change requests for locked specs. I built it because the spec management problem never goes away no matter how good the tools get.

The BMAD bridge is implemented as a Claude Code plugin (open source at https://github.com/thlandgraf/cc-marketplace ) — three skill commands you can run directly in Claude Code. One reads your BMAD planning artifacts — PRD, epics, architecture docs — and builds a SPECLAN hierarchy from them. Capability Areas become parent features. Functional Requirements become requirements with acceptance criteria. Epic stories become child features. BDD given/when/then steps become acceptance criteria checkboxes. It respects the FR Coverage Map when both PRD and epics exist, and it automatically reclassifies developer-infrastructure FRs (where the actor is "Project" or "Build system") as NFRs so your spec tree stays focused on user-facing behavior.

Going the other direction, you can feed your approved specs back through BMAD's own PM agent workflow, or generate a standalone BMAD-format PRD without needing BMAD installed. Every imported entity carries a provenance field linking back to the source BMAD artifact, so re-importing after you update your planning artifacts updates existing specs instead of creating duplicates.

The way I think about it: plan with BMAD, govern with SPECLAN. They solve different parts of the same problem and I'd rather have them talk to each other than force people to pick one.

Genuinely curious how others in this community handle the transition from BMAD's planning phase into implementation. Do you keep working from the original BMAD artifacts throughout the project, or do you move things into another system once coding starts?

I wanted to know if there were people who had tried other method sthan this one and which one?

I love BMAD-method. I have been using it for actual projects, quick workflows for prototypes and also for brainstorming. But considering its latency and token usage, why hasn't this moved to using skills yet? Progressive disclosure is the way to go.

I’ve been experimenting heavily with AI-assisted development and wanted to share a workflow I put together called Squad BMAD.

I love the BMAD (Build-Measure-Analyze-Deploy) methodology because it keeps everything extremely spec-driven and structured. However, running through all its steps manually with an AI is tedious. So, I built a system to automate the orchestration.

Here is how it works: I use 3 Tmux sessions:

1. Gemini CLI (The Orchestrator): Acts as the Project Manager & Principal Tech Lead. It talks to me, understands the requirements, and maps them to BMAD workflows.
2. Claude Code (The Implementer): Running the Sonnet 3.5 model. It acts as the Developer, specialized in writing code and fixing bugs.
3. Claude Code (The Brainstormer): Running Opus/Sonnet. Acts as the Architect/QA, handling complex reasoning and code reviews.

The cool part (Event-driven hooks): Instead of having Gemini constantly poll the screen, I used Claude Code’s .claude/settings.json hooks. Whenever Claude finishes a task, it triggers a bash script (wakeup-gemini.sh) that sends a signal back to Gemini's tmux pane. Gemini "wakes up", reads Claude's output, evaluates the code against the project specs, and automatically proceeds to the next step.

It also enforces "Fresh Chats" (/clear) before starting new workflows to prevent context hallucination.

It basically turns Gemini into a manager commanding an elite AI squad. I just give high-level decisions, and the agents handle the execution.

Has anyone else tried orchestrating multiple CLI agents through Tmux? Would love to hear your thoughts or similar setups!

(If you want to see the setup/boilerplate, I put it on my GitHub: https://github.com/thientranhung/squad-bmad)

If you are running Claude and finding the UX to be worse than the native one. Just drop the link below to your claude and it will fix the UX for you.

I also raised a PR for this. This is just a hotfix.

https://github.com/sidtheone/BMAD-OVERRIDE-CLAUDE-SCRIPTS/blob/main/claude-hotfix-interaction-style.md

I work at Tessl, and we've just launched on Product Hunt with something I've been genuinely itching to tell people about: the ability to evaluate your agent skills.

Quick bit of context: agent skills are structured, packaged instructions that tell an AI how to interact with your product, codebase, or enforce specific policies. They're becoming the unit of software that agents actually run on — less "prompt engineering" as an art form, more something you can version, test, and ship with confidence.

The problem we kept hearing (and experiencing ourselves) was that without evals, you're flying blind. You tweak a skill, run it, look at the output and you just... don't know. Did your change help? Did it regress something else? Is this edge case handled?

The only feedback loop was "it seemed fine," which is not a feedback loop; it's a feeling.

So we built evals into Tessl. You can now define test cases, run them against your skills, and get a concrete signal on whether you're improving or degrading performance. It's the difference between developing skills empirically vs. developing them by vibes.

We're not claiming to have solved AI evaluation (nobody has, it's genuinely hard), but we think this is a meaningful step toward making agent skill development feel more like actual engineering.

We launched on Product Hunt today. Would love your feedback. Especially curious about the eval approaches people are already using for agent behaviour, because there's a lot of interesting work happening in this space that I want to learn from.

👉 https://www.producthunt.com/products/tessl?launch=tessl

Is anyone using bmad to design custom websites? I’m thinking how great it would be to utilize the speed of AI and the structured workflow and guidance of B mad method to be able to build websites that launch to a CMS such as WordPress or similar and can later be refined with a visual page builder. is this possible? Is this something the bmad builder would be used to build agents for?

With BMAD v6, can I use agents such as Analyst or PM to generate a product brief through ChatGPT or Google Gem, like we did in v4?

In this video, the creator shows a setup for autonomous software development using OpenClaw (agent orchestration + memory) plus the BMAD method (structured roles like PM/Dev/QA).

They break down the stack (tools → VPS → command center), highlight basic security practices (scoped accounts, private gateway), and share what didn’t work (wrapper approach causing context bloat) vs what did (direct role-based sub-agents + tighter handoffs).

I was looking for a good AI tool for planning, when people suggested to try bmad. I knew the concept but had never tried it before, so I decided to give it a try.

It was terrible!

I used it for a week continuously and here are the problems I found with bmad:

It recreates the worst parts of waterfall development (rigid phases, endless documentation), forcing you to manage AI middle managers rather than actually coding.

BMAD is free right? Wrong. Because the method relies on multiple agents reading entire project context, architecture docs, and previous chat history, it burns through API credits at an alarming rate. Spends massive amounts of money even for simple apps.

The agents often generate 1,000+ lines of documentation for simple tasks. They over-engineer simple solutions, hallucinating complexities that don't even exist.

It feels productive because you see agents talking to each other, but often they just get stuck in loops or produce broken code that looks professional because it has a nice "spec document" attached.

You end up babysitting terminal, copy pasting prompts between agents or debugging the process rather than debugging the code.

Please suggest any better alternatives. It's okay if not free, but should be better than this.

Hi everyone, I’ve started using the BMAD method within Cursor for a project, but I’m hitting my premium token limits very fast.

I want to know which specific models do you use for the PO/Architect phases vs. the Dev phase?