BMad Autonomous Development — The /bad Coordinator

A skill that takes over the moment your planning is done and runs the sprint execution autonomously. Wake up to a wall of green PRs instead of managing branches, implementation loops, and CI.

What /bad Actually Is

Published 5 April 2026 by MachineLearner00 as part of the BMad Method ecosystem. Coordinator-only — /bad never writes code itself. It delegates every unit of work to dedicated subagents with fresh context windows.

“I’ve realised my favourite 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.”

GitHub: stephenleo/bmad-autonomous-development

Architecture 

flowchart TB
    You([You])
    Plan[PRD / sprint-status.yml]
    Bad["/bad coordinator"]
    Graph[Dependency graph<br/>parallelisable stories]

    subgraph "Per-story isolated execution"
        WT[git worktree]
        CS[BMAD Create-Story]
        DS[BMAD Dev-Story]
        CR[BMAD Code-Review]
        PR[GitHub PR]
    end

    CI{CI passes?}
    Heal[Self-heal<br/>fix implementation bugs]
    Merge([Auto-merge PRs<br/>resolve conflicts])

    You --> Plan
    Plan --> Bad
    Bad --> Graph
    Graph -. spawn parallel .-> WT
    WT --> CS
    CS --> DS
    DS --> CR
    CR --> PR
    PR --> CI
    CI -- no --> Heal
    Heal --> DS
    CI -- yes --> Merge
    Merge --> You

    classDef runtime fill:#1a2b4a,stroke:#0f1a2e,color:#fff,rx:8,ry:8;
    classDef step fill:#f4f7fb,stroke:#1a2b4a,color:#1a2b4a;
    classDef gate fill:#ffd966,stroke:#a07800,color:#4d3800;
    class You,Bad,Merge runtime;
    class Plan,Graph,WT,CS,DS,CR,PR,Heal step;
    class CI gate;

The core mechanics

  1. Dependency mapping — builds a graph from your sprint-status.yml to identify parallelisable stories.
  2. Isolated execution — each story runs in its own git worktree, preventing environment pollution and state conflicts.
  3. 4-step lifecycle per task: BMAD Create-Story → BMAD Dev-Story → BMAD Code-Review → GitHub PR.
  4. Self-healing CI — orchestrator monitors CI results and reviewer comments, auto-fixing implementation bugs until the status turns green.

Why the isolation matters

Context isolation = every step gets a dedicated subagent with a clean slate. This prevents the “context explosion and hallucination creep” that usually happens when a single Claude Code session stays open too long.

What makes it more than “just run BMAD until a blocker”

MachineLearner00 on the difference:

“I started that way. Then found repeated patterns that kept popping up so I wrote this skill to follow through all those. For example, the merging of PRs sequentially, fixing merge conflicts as they appear. Or the waiting for CI to complete and fix issues automatically. Or identifying dependencies to pick the next few parallelisable tasks to build concurrently. /bad is ultimately a workflow following best practices I’ve discovered so far.”

Key Capabilities

Feature What it does
Context isolation Each step gets a fresh subagent with a clean slate
Rate-limit aware Proactively checks your usage limits and pauses to wait for resets
State persistence + resume Reads GitHub PR status + local sprint-status.yml to know exactly where to pick up
Automatic conflict resolution Optionally auto-merges PRs sequentially, handling merge conflicts as they arise
Dependency-aware parallelism Graph-informed concurrent execution of independent stories

Install 

npx skills add https://github.com/stephenleo/bmad-autonomous-development

Prerequisite: BMAD must already be installed. Invoke in Claude Code:

/bad

First run walks through a setup process.

Autonomous mode: Use auto mode or dangerously-skip-permissions. Run inside a sandbox to prevent access outside the working directory.

Community-Suggested Extensions

TEA test-plan / test-review (Randyslaughterhouse)

Insert BMAD’s Test Engineering Architect (TEA) module around dev-story:

create-story → test-plan → dev-story → test-review → code-review → PR/merge

Plus a dedicated E2E testing story per epic that collates all story-level test plans into an epic-E2E automated run and backfills coverage gaps. Used as part of the epic close-off process.

Adversarial reviews before dev (RD-Epimetheus)

Run every story through one party-mode review and two adversarial reviews (both BMAD inbuilt) before the programming phase. Subjective observation: makes the actual programming phase smoother.

Model routing by story complexity (Bright_Zebra_8266 + famousmike444)

  • Codex sub-agents default to 5.4 mini at medium thinking. Config at codex/agents/xx.toml.
  • Feature request: evaluate story complexity pre-dev to pick the right model size (smaller + cheaper for low-complexity tasks)
  • Dashboard idea: status, model used per task, tokens consumed by model, code-review findings counts, human-intervention callouts

Validate-story loop (Bright_Zebra_8266)

create story → validate story → dev → review → PR — “no matter how smart the model is, validate story always captures gaps and skipped acceptance criteria.”

Token Cost

Acknowledged trade-off from the Reddit thread:

“If you have tokens to spare.” (top comment)

MachineLearner00: “Yes, BMAD is token hungry. The main reason /bad tracking the Claude Code limits and pause until it resets is because I kept hitting into limits regularly. BMAD versions 6.2+ with progressive disclosure are way better in token consumption than prior versions.”

Pair /bad with:

Without monitoring, /bad running overnight can surprise you at the limit boundary. With monitoring, you can tune.

Comparison With Claude Code’s Native Agent Teams

  Native Agent Teams /bad
Context model Independent per agent Fresh subagent per step
Coordination Shared task list + messaging Coordinator + dependency graph
Use case Multi-file features in parallel Full autonomous sprint execution
Setup CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 + tmux/iTerm2 npx skills add + BMAD
CI integration Manual Self-healing loop built in
Maturity Experimental Active community iteration

Both patterns are complementary. /bad is closer to “autonomous overnight sprint”; Agent Teams is closer to “pair-program in parallel on one feature.”

See also: Agent Teams guide.

When to Use It vs When Not To

Use it for:

  • Sprint-level execution where PRDs + stories are already written
  • Maintenance backlogs of well-scoped, parallelisable tickets
  • Dependency-bumping campaigns across many services
  • Generated-code-heavy tasks (migrations, scaffolding)

Don’t use it for:

  • Exploratory or discovery work (that’s the human part)
  • Customer-facing changes without human PR review
  • Anything touching regulatory / compliance decisions (see Regulated AI)
  • Projects without good CI coverage — the self-heal loop relies on signal to operate

The BMAD Method — Quick Reference

/bad builds on the underlying BMAD plugin. If you’re new to BMAD itself, this is the short version.

Standard agents

Agent Role
Architect Evaluates design, raises scalability and maintainability concerns
Developer Owns implementation, raises edge cases and testing concerns
QA Engineer Writes test cases, identifies coverage gaps
Security Auditor Flags security risks, compliance issues, injection vulnerabilities
Product Manager Raises scope, timeline, and user impact concerns

Party Mode

Start with /bmad-party-mode or just tell Claude “start a party mode session.” The BMad Master agent activates and orchestrates other agents; as you type, relevant agents respond in character. Most valuable during the analysis phase (multiple perspectives prevent tunnel vision), architecture reviews (Architect + Security Auditor + Developer catch issues early), and sprint retrospectives.

Modules

Module Purpose
BMM (BMad Method Module) Core Agile suite for software development
BMB (BMad Builder) Framework for creating custom AI agents and extensions
CIS (Creative Intelligence Suite) Innovation, design thinking, and brainstorming
BMVCS (Version Control System) Git workflow automation and version control
BMGD (BMad Game Dev Studio) Specialized module for game development

Commands

Agent activation:

Command What It Does
/bmad:init Initialize BMAD in the current project
/bmad-help Get guidance on what to do next
/bmad-architect Activate the Architect
/bmad-dev Activate the Developer agent
/bmad-pm Activate the Product Manager
/bmad-party-mode Activate Party Mode for multi-agent collaboration

Workflow commands:

Command Phase
/bmad-bmm-create-product-brief Analysis — Create initial product brief
/bmad-bmm-create-prd Planning — Generate Product Requirements Document
/bmad-bmm-create-architecture Solutioning — Design system architecture
/bmad-bmm-create-epics-and-stories Solutioning — Break down into implementable stories
/bmad-bmm-sprint-planning Implementation — Plan the sprint
/bmad-bmm-dev-story Implementation — Develop a single story
/bmad-bmm-code-review Implementation — Review completed work

Review commands:

Command Purpose
/bmad-review-adversarial-general Stress-test plans and designs
/bmad-review-edge-case-hunter Find edge cases and failure modes
/bmad-bmm-qa-generate-e2e-tests Generate end-to-end test suites from stories

BMAD is available as a Claude plugin — install it from the plugin marketplace and activate any of the commands above.

Further Reading

Built at Harris Computer · Constellation Software. Licensed under MIT.