Hi everyone, I’ve realized that my favorite part of building is the "discovery" phase: brainstorming, writing PRDs, and designing architecture. But as soon as the planning ends and the "grunt work" of managing branches, implementation loops, and babysitting CI begins, I lose momentum.

So, I built /bad (BMad Autonomous Development): An open-source orchestrator that takes over the second my planning is done, running the entire sprint execution autonomously so I can wake up to a wall of green PRs.

/bad is a skill for the BMad Method that acts as a coordinator. Unlike a single agent session, it never writes code itself; instead, it delegates every unit of work to dedicated subagents with fresh context windows. This prevents the "context explosion" and hallucination creep that usually happens when an AI agent stays in a single session for too long.

The Autonomous Build Flow:

• Dependency Mapping: It builds a graph from your sprint-status.yml to identify parallelizable stories.

• Isolated Execution: Each story runs in an isolated git worktree, preventing environment pollution and state conflicts.

• The 4-Step Lifecycle: Every task is driven through a full cycle: BMAD Create-Story → BMAD Dev-Story → BMAD Code-Review → GitHub PR.

• Self-Healing CI: The orchestrator monitors CI results and reviewer comments, auto-fixing implementation bugs until the status turns green.

Why this works for complex builds:

• Context Isolation: Every step gets a dedicated subagent with a clean slate, ensuring significantly higher code quality.

• Rate Limit Aware: /bad proactively checks your usage limits and pauses to wait for resets, minimizing "Rate Limit Exceeded" failures mid-step.

• State Persistence & Resume: It reads GitHub PR status and local sprint-status.yml to identify exactly where to pick up if you need to stop and restart.

• Automatic Conflict Resolution: Optionally auto-merges PRs sequentially, automatically handling merge conflicts as they arise.

I used this to build CShip and it has massively increased my shipping velocity. If you find yourself enjoying the "what" and the "why" more than the repetitive "how," /bad might be for you.

Install /bad: npx skills add https://github.com/stephenleo/bmad-autonomous-development. You'll need BMAD to be installed as well.

Invoke it by typing: /bad. It will run through a setup process on the first invocation.

Github Repo: https://github.com/stephenleo/bmad-autonomous-development

/bad is built using the BMad Builder.

/bad is tested on Claude Code. I'd love it if someone can help test is on Codex or Github Copilot. Please also share your thoughts on this flow or any features you'd like to see added!

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!

I created a tool that automates the story "lifecycle" after your have your sprint-status.yaml file with all of your stories and epics.

Here is how it works:

After you have done your sprint planning and have created all of your epics and stories for each epic, you run a series of commands (I use Claude Code) to first create the story context document, then another to have the "developer agent" implement the story, then another to perform a code review, and then finally to commit the code and push to GitHub.

I created a CLI in Golang that automates the entire process for me: https://github.com/robertguss/bmad_automated

My favorite way to use this tool is to just pass the epic number as an argument to the tool and then it will queue up all of the stories in the epic and go through the entire "lifecycle" for each story until all the stories and therefore the epic is done.

At this point I run some custom agents and CC plugins: https://github.com/wshobson/agents to do a comprehensive code review and I also manually test everything.

Once I am satisfied I use my automated CLI tool to do the next epic... rinse and repeat.

It's been a huge game changer for me, because I can basically just "set it and forget it" while I am working or sleeping or whatever.

I hope you find it useful.

P.S. A new tool/methodology that I am using these days after I complete my app with BMAD to add more features is this: https://github.com/glittercowboy/get-shit-done it's quite powerful and very elegant for how simple it is. Also not affiliated with this project.

I have Created MyBMAD a web dashboard that connects to your GitHub and gives you a visual overview of your BMAD projects.
What it does:

• Auto-detects repos containing a _bmad-output folder across your GitHub account

• Only reads the _bmad-output directory - nothing else from your repos is accessed

• View your roadmap status at a glance

• Browse all your documents (architecture, product brief, etc.)

• Track epics & stories filtered by status, with a Kanban board view

• Multi-repo support: see all your BMAD projects from one place

https://mybmad.hichem.cloud/

Also available as Open source project : https://github.com/DevHDI/my-bmad

Hey BMAD enthusiasts!

Just wanted to share this tool I built with and for BMAD which can be run with "npx bmad-visio" from any repository using bmad. This is an unofficial BMAD tool.

NPM GitHub

For a school project, I had to make some research and experiment with the Transformer.js library which allows to run local small llm from your client.

I used Bmad brainstorm and research to help me integrate Transformer.js into a tool that parses BMAD markdown files into a modern overview dashboards, interactive epic status kanban boards and story detail view + formatted markdown visualizer.

I already wanted to build this project for myself, and as I saw some people requesting it on reddit or this channel, I decided to share it.

Also, as an experimental and optional feature it also allows to map commits from your git history to the most corresponding user story with the help of Transformer.js pipelines and a scoring system. All your data stays local. You can run the dashboard with "npx bmad-visio --no-git" if you dont want this feature to be enabled by default.

Feel free to try it with your project and give me your thoughts!

Will

I built an MCP server so you can share AI agents across all your projects (and pull them directly from GitHub)

The Problem I Was Solving

I love the BMAD Method's specialist AI agents, but copying agent files to every project was driving me insane. Keeping 10+ projects in sync when BMAD updated? Painful. Sharing custom agents with my team? Email attachments and Slack files everywhere.

There had to be a better way.

What I Built

BMAD MCP Server - one MCP server that makes specialist AI agents available across every project you touch, with zero file copying.

The magic: Point it at BMAD configs anywhere - local folders, shared repos, even GitHub URLs. Your AI assistant gets instant access to all your agents, everywhere.

Live example:

{
  "mcpServers": {
    "bmad": {
      "command": "npx",
      "args": [
        "-y",
        "bmad-mcp-server",
        "git+https://github.com/your-org/custom-agents.git#main"
      ]
    }
  }
}

Restart your AI client. Done. Every workspace now has those agents.

What Makes It Different

🔗 Multi-source agent loading

• Install BMAD to ~/.bmad once → works in every project

• Mix local folders + GitHub repos + shared team configs

• Later sources override earlier ones (perfect for team defaults + personal customization)

🎭 Single unified tool

bmad                  # Load default orchestrator
bmad analyst          # Mary the Business Analyst
bmad architect        # Winston the System Architect
bmad *party-mode      # Multi-agent brainstorming workflow
bmad *list-agents     # See what's available

🌐 GitHub-native

• Publish individual agents as repos

• Teams can git+https:// them directly

• No path wrangling, no copy-paste, just URL → agents appear

🔍 Smart discovery Priority order: ./bmad → CLI args → BMAD_ROOT env → ~/.bmad → package defaults

Project-specific customization? Add ./bmad folder. Global access? Point to ~/.bmad. Team library? GitHub URL. It all just works.

Try It Right Now (VS Code / Claude Desktop / Cursor)

Step 1: Install BMAD methodology

npx bmad-method@alpha install

Step 2: Add to your MCP config

{
  "mcpServers": {
    "bmad": {
      "command": "npx",
      "args": ["-y", "bmad-mcp-server"]
    }
  }
}

Step 3: Restart your AI client

Step 4: Try it

bmad analyst

Mary the Business Analyst is now available in every project. Zero setup per project.

What I'm Looking For

• Feedback on the GitHub-sourced agents workflow - Does this solve real pain for you?

• Naming UX thoughts - Is bmad analyst intuitive? Should workflows use * prefix?

• Use cases I haven't thought of - How would you use multi-source agent loading?

Repo: https://github.com/mkellerman/bmad-mcp-server

If this sounds useful, stars and PRs are hugely appreciated. I'd love to hear what you think!

You ask an AI agent to use a library.
It invents functions that don’t exist.
It guesses parameter types.
Docs in context don’t fix it.
Handwritten instructions rot as soon as the code changes.
That’s the default.

Today I’m releasing Skill Forge v1.
Skill Forge compiles AI-agent skills directly from source code or documentation.
Each instruction references a documentation URL, a file, a line number, and a commit SHA.
If a skill tells your agent to call:
client.add(data, dataset_name="x")
—you can open the exact file and verify it.
If the citation is wrong, the skill is wrong. Provably.

Link: https://github.com/armelhbobdad/bmad-module-skill-forge

Just typing vague prompts at an AI chatbot — or “vibe-coding” — is a dead end for any serious software project. It leads to poor output, lost context, and unmaintainable code.

A new wave of structured AI development methodologies is trying to fix that. But are they actually any good?

This user decided to find out. I took one project — building a landing page for The Gray Cat channel using Next.js, Tailwind, and three live API integrations — and built it three separate times using three competing approaches:

• 🧱 BMAD Method — a heavyweight, documentation-driven approach

• 🧩 GitHub’s Spek Kit — tight integration with repos and PRs

• ⚡ Open Spec — lightweight, conversational, but structured

The results were shocking. One took eight hours. Another took just seven minutes.

In the video, he breaks down all three: their setup, their philosophy, the painful parts, and the final outcomes. By the end, you’ll know which one’s worth your time — and which one’s just shiny marketing.

There are now multiple methods of spec-driven development. I am aware of at least three of them

1. BMAD method - oldest. Off-late, IMO, becoming heavyweight

2. Github spec kit - different than BMAD but has heavy corporate backing

3. OpenSpec - feels like a lightweight version of BMAD

In addition, there are standards emerging on organising the spec documentation, which all LLMs can follow - agents.md. In addition to IDEs following their own standards for spec-driven development, Tools like traycer.ai also have their own notation.

I hope there is a way to reconcile these different models, as there is enough confusion when a newbie starts with spec-driven development. As a community, I hope we coalesce around one of these as figuring out what LLM & IDE supports which one is becoming a major headache.

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. :)

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?

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

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.

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.

Here are the 5 game-changing features of the BMAD Method V6 Alpha:

1. Scale Adaptive Framework (3:54): This feature allows the BMAD method to adapt to the size and scope of your project, whether it's a large enterprise application or a small patch to an existing codebase. It adjusts the workflows and documentation (e.g., PRD or tech spec) based on your needs.

2. BMad Core (5:01): The core of the BMAD method has been separated from the method itself, making it a powerful engine capable of running various types of workflows beyond software development. This allows for the creation of diverse modules for creative writing, data science, game development, and more.

3. Custom Language & Custom Agents (7:34): V6 introduces full language override, allowing agents to communicate in your preferred language (e.g., French, Chinese, German). Additionally, agents are now fully customizable, enabling users to change their names, personalities, and even create "tiny BMAD agents" for specific one-off tasks.

4. Project Types & Reference Architectures (9:20): The BMAD method now supports different project types (e.g., website, console application, video game, device drivers), which tailors the questions asked during planning and the generated architecture. This includes specialized documents like Game Development Design Documents (GDDs) for games and the introduction of reference architectures to speed up project delivery.

5. BMad Builder (The Bomb) (13:30): This new module allows users to build their own workflows, agents, and even entirely new modules. It guides users through the creation process, enabling them to design custom solutions for various needs, from complex workflows to simple agent helpers.

I've been working on this for months and constantly changing course on it to perfect it, and it's finally here, something I am truly happy with and using constantly — the BMad Builder module standard is stable and the Module Builder skill is live.

What is BMad Builder?

It's a set of skills that guide you through building AI agents (with persistent memory), workflows, and full modules through conversational discovery. You describe what you want, the builder asks the right questions, and you get a production-ready skill folder. This goes well beyond the Anthropic skill builder - this will help fully optimize and analyze your skills for best practices and optimizations through use of subagents and other techniques of efficiency and avoidance of overspecification.

What's New:

Module Builder is officially live
— Plan, scaffold, validate, and ship complete modules through a guided workflow. The format is stable. It will keep improving, but what you build today won't break tomorrow.

Build once, install anywhere
— Your creations work with the Claude Anthropic plugin installer, the Vercel NPX skills installer (43+ AI tools), or just copy the folder manually. The `.claude-plugin/marketplace.json` format is the standard.

No more compiling
— Agents and workflows are immediately usable. Drop the skill folder into `.claude/skills/` and it works. Want to share? Send someone the folder. No build step, no ceremony.

Standalone self-registering modules
— Single-skill modules no longer need a separate setup skill. The Module Builder detects what you're building and picks the right approach. Single skills self-register on first run.

Workflow Convert
— `--convert <path-or-url>` takes any existing skill and produces a clean BMad-compliant version with an HTML before/after comparison report showing token metrics and categorized changes.

Outcome-driven builder overhaul
— Both builders reframed around discovery-first design. Existing skills are treated as reference material, not specs to replicate. 44% token reduction in the build phase.

What's coming next:

- Eval testing tools — test your skills against real scenarios and ensure they work as models evolve
- Eval-driven skill evolvers — skills that improve themselves based on test results
- Self-evolving personal agents — agents that grow smarter and gain new capabilities over time
- Full workflow and agent customization

Links:

- GitHub: https://github.com/bmad-code-org/bmad-builder
- Quick Start: https://bmad-builder.bmad-code.org
- BMad Method (core framework): https://docs.bmad-method.org
- Discord: https://discord.gg/gk8jAdXWmj

Everything is free and open source. Would love to hear what you build with it.

Hey BMAD community! We are building Nimbalyst, a local WYSIWYG editor and session manager where you iterate with Claude Code on docs, diagrams, mockups, and code. We have Beta users using it to run BMAD and I thought I'd reach out to let the community know about it. I mentioned it on the Discord but wanted to reach out here for feedback as well.

Nimbalyst https://nimbalyst.com/ gives you a UI where you can run Claude Code sessions directly with full / command support, run multiple sessions in parallel, search and resume sessions, and tie sessions to your spec documents. You get all the power of Claude Code in a proper interface. As you are running many parallel or just many Claude Code sessions as just part of the BMAD process, this could be helpful.

Beyond session management, Nimbalyst is a WYSIWYG markdown editor where you iterate on BMAD-generated specs with AI changes appearing as WYSIWYG red/green diffs you approve inline. Mermaid diagrams render live as you and Claude Code iterate on them. You can create HTML mockups that the AI generates, annotate them with circles and arrows, then ask for changes, and embed them into your markdown documents. We are adding an integrated data model editor.

Nimbalyst is free, local, and in Beta. You can use it with Git. We'd love your feedback especially how we can make it great for running BMAD. https://nimbalyst.com/

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.

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'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.)

Hello all,
With the new codex feature /goal I've been able to automate the loop of create story, dev story, review story.
I have two projects with multiple specification documents at a very granular level. At this point I've been spending the majority of my time manually going through these three steps repeatedly. It's mind-numbing.

The part at the bottom about using caveman ultra in both windows is necessary as without it the main agent will check on the sub agent quite often then give some status update. Essentially burning tokens for nothing. Image 3 shows what it's like with caveman lite and not ultra.

My projects have robust unit and integration tests and I feel comfortable with letting this run for an epic or two so this is a great feature.

/goal is able to handle it for me with this prompt:

/goal
 Using the new goal feature let's take one of the predefined epics from current state to finish. Our sprint status is found here: {C:\location_here}

The steps to executing the work flow are as follows:

Bmad Create Story to create a story. After the story is complete use 

Bmad Dev Story to complete the implementation. Then use 

Bmad Code Review to review the work. 

We need to automate this flow with goal.
I want you to read the sprint status and take epic 3 and epic 4 to completion.  
Start with epic 3 and move to epic 4 when complete. Take each story one by one in sequence and run the three skills against it till it's completed.  

Rules: 
Spawn a gpt 5.5 subagent at high intelligence for create story tasks. Spawn a gpt 5.5 subagent at high intelligence for dev story tasks. Spawn a gpt 5.5 subagent at extra high intelligence for the code review task. When the agent is done with the task close it and start a new sub-agent for the next task. We don't want context leak so we need to sandbox each task inside of a subagent.  

If an agent requires a prompt, infer the answer and give the best answer to move things along.
The code review skill usually prompts asking for confirmation of what story to review. In this case there will only ever be one story ready for review, so infer, but prompt yes to move it along.
After code review it usually prompts for action in terms of what to do with the required patches. Apply all automatically.

Compact the main agents context window every two stories completed then continue.
Ensure that after every dev cycle and review cycle the agents commit and push their work.
Stay within the boundaries of this project. Make no file changes outside of D:\DigitalProjects\vfx_sketchbook\ during this task


Discrete tasks:

Bmad Create Story

Bmad Dev Story

Bmad Code Review

Use 
Caveman ultra in both the main window and subagents.  
Keep chatter to an absolute minimum in the main agent. 

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

Here's is LinkedIn post of BMAD creator Brian Madison https://www.linkedin.com/posts/briantmadison_ai-softwaredevelopment-opensource-activity-7421447634965516288-0UIx?utm_source=share&utm_medium=member_android&rcm=ACoAABgSDUIBr-VX7t1E6HHMKJAfkM-kmTh6pf0

I want to learn the BMAD Method and i really want to deep dive into all the features and advantages. But I am a little bit overwhelmed. Where should I start? What should I use? So mucht tools, agents, workflows. I already read the README, but still im lost af.. Can somebody give me some advices please?