Stop Coding Sprints Manually: BAD Orchestrates Your Entire Team

Stop Coding Sprints Manually: BAD Orchestrates Your Entire Team

What if your next sprint could run itself? Not partially. Not with you babysitting pull requests at 2 AM. But fully — from the moment a story enters your backlog to the second it merges into main, passing tests, code review, and CI without a single human interrupt.

Here's the brutal truth most engineering teams won't admit: sprint execution is 70% coordination overhead and 30% actual coding. Dependency tracking. Context switching between stories. Waiting for reviews. Rebasing after someone else's merge. These aren't engineering problems — they're orchestration problems. And until now, we've thrown headcount at them instead of solving them systematically.

Enter BAD — BMad Autonomous Development. This isn't another AI coding assistant that suggests completions in your IDE. This is a full-stack autonomous development orchestrator that runs parallel, multi-agent pipelines through your entire story lifecycle: create → dev → review → PR. One coordinator, seven sequential steps per story, up to multiple stories running simultaneously in isolated git worktrees. While you sleep. While you plan the next sprint. While you finally have lunch away from your desk.

The secret? Every unit of work is delegated to a dedicated subagent with a fresh context window. No monolithic AI trying to remember everything. No context pollution. Each agent focuses on exactly one job, then hands off cleanly. This architecture decision alone separates BAD from every other "AI coding tool" you've seen.

Ready to understand how this actually works? Let's dismantle the future of software development.

What Is BAD — BMad Autonomous Development?

BAD is a module for the BMad Method — a structured approach to AI-assisted software development. Created by Marie Stephen Leo and released under MIT license in 2026, BAD represents a fundamental architectural shift in how we think about development automation.

Most tools in this space fall into two broken categories: IDE copilots that suggest code but don't execute, and monolithic agents that try to do everything in one massive context window until they hallucinate, forget constraints, or hit token limits. BAD rejects both models entirely.

Instead, BAD implements a coordinator-subagent pattern. The coordinator never reads files or writes code itself. Its sole job is orchestration: tracking dependencies, dispatching work, monitoring progress, and handling handoffs. Every actual task — story creation, test generation, implementation, code review, PR management — gets its own specialized subagent with a clean, focused context window.

This design mirrors how elite engineering teams actually work. You don't have one senior engineer write specs, code, tests, and review everything themselves. You distribute expertise. BAD automates that distribution using AI subagents, each configured with appropriate model tiers (MODEL_STANDARD for creation and development tasks, MODEL_QUALITY for code review where deeper reasoning matters).

The repository has gained significant traction because it solves a problem every engineering manager recognizes but few tools address: the gap between planning and execution. Your sprint ceremonies produce beautiful backlogs. Then reality hits — dependencies block stories, reviews stall, context switches multiply, and velocity collapses. BAD closes that gap by making execution as systematic as planning.

Key Features That Separate BAD From the Noise

True Parallel Execution with Isolated Worktrees

BAD doesn't just claim parallelism — it implements it correctly. Each story runs in its own git worktree under a configurable base path (default: .worktrees). This means no branch contamination, no merge conflict nightmares during development, and clean separation of concerns. The coordinator manages up to MAX_PARALLEL_STORIES simultaneously (default: 3), respecting dependency constraints from your sprint graph.

Seven-Step Validated Pipeline

Every story passes through a rigorous, sequential pipeline:

• bmad-create-story: Generates and validates the story specification
• bmad-testarch-atdd: Produces failing acceptance tests (test-driven development done right)
• bmad-dev-story: Implements the actual code
• bmad-testarch-test-review: Quality gates the tests themselves
• bmad-code-review: Deep implementation review using the stronger MODEL_QUALITY
• CI/PR automation: Commits, pushes, opens PR, monitors CI, fixes failures
• PR diff review: Final validation before clean merge

This isn't arbitrary complexity — it's systematic quality assurance. Most AI coding tools skip straight to implementation. BAD enforces the engineering practices that prevent technical debt.

Dependency-Aware Batch Processing

The coordinator builds and maintains a live dependency graph from your sprint-status.yaml. It syncs GitHub PR status, identifies ready-to-work stories, respects epic ordering, and auto-merges completed batches sequentially (lowest story number first) with conflict resolution. The loop continues until your entire sprint completes.

Harness Agnosticism

BAD detects your installed agent harness — Claude Code, Cursor, GitHub Copilot, or others — and configures platform-specific settings automatically. Model selections, rate limit thresholds, timer support: all adapted to your environment. This isn't a Claude-only tool; it's infrastructure for wherever AI-assisted development evolves.

Intelligent Resource Management

Built-in watchdog timers, context compaction at configurable thresholds (default: 80% context window), and API usage pauses protect against runaway costs. The STALE_TIMEOUT_MINUTES setting alerts on stuck subagents. API_FIVE_HOUR_THRESHOLD and API_SEVEN_DAY_THRESHOLD prevent billing surprises with Claude Code specifically.

Real-World Use Cases Where BAD Dominates

Legacy Team Velocity Recovery

Your team of six engineers spends 40% of sprint time in coordination meetings, code review backlogs, and deployment pipeline debugging. BAD takes over execution, reducing human coordination to planning and exception handling. Engineers focus on architecture decisions and complex problem-solving while agents handle the implementation pipeline. Result: 2-3x throughput improvement without headcount increase.

Solo Founder/Technical Lead Scaling

You're building a startup with one technical co-founder who can't clone themselves. BAD becomes your autonomous execution layer — planning sprints with you, then implementing them overnight. Wake up to merged PRs with passing tests. The dependency graph ensures critical path stories complete first, protecting your launch timeline.

Enterprise Compliance Pipelines

Regulated industries require documented, repeatable processes: story specifications, acceptance tests, code review records, CI validation. BAD's seven-step pipeline generates this audit trail automatically. Each subagent's work is traceable. The enforced quality gates prevent the "skip tests to ship faster" pressure that creates compliance debt.

Microservice Maintenance at Scale

Managing 40+ microservices means constant dependency updates, security patches, and cross-service compatibility work. BAD parallelizes these maintenance tasks across services, with each worktree isolated. The dependency graph handles inter-service ordering automatically. Your platform team shifts from manual ticket execution to pipeline optimization.

Rapid Prototyping with Production Rigor

Need to validate ten feature ideas in two weeks? BAD runs each as a parallel story through the full pipeline — specs, tests, implementation, review — giving you production-quality prototypes instead of throwaway code. Merge what works, abandon what doesn't, with zero technical debt from rushed experiments.

Step-by-Step Installation & Setup Guide

Getting BAD operational requires the BMad Method foundation, GitHub CLI authentication, and the BAD module itself. Here's the complete path from zero to autonomous execution.

Prerequisites

First, install the BMad Method core with required modules:

npx bmad-method install --modules bmm,tea

You'll need a sprint plan with epics, stories, and the sprint-status.yaml file that BAD consumes for dependency tracking.

GitHub CLI Setup

BAD's subagents interact with GitHub for PR creation, CI monitoring, and auto-merge operations. Install and authenticate the CLI:

# Install GitHub CLI
brew install gh

# Authenticate (follow interactive prompts)
gh auth login

Expose your token to BAD's subagents by adding to your shell configuration:

# Add to ~/.zshrc or equivalent
export GITHUB_PERSONAL_ACCESS_TOKEN=$(gh auth token)

Critical for Claude Code users: If running with sandbox mode, allow gh network access:

// Add to .claude/settings.json
{
  "sandbox": {
    "enableWeakerNetworkIsolation": true
  }
}

BAD Module Installation

Install the BAD skill module:

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

Then initialize BAD in your project:

/bad setup

This creates the bad: configuration section in _bmad/config.yaml and detects your installed agent harness for platform-specific tuning.

Launching Autonomous Execution

For fully unattended operation — no permission prompts interrupting your pipeline:

claude --dangerously-skip-permissions

Then trigger BAD naturally:

/bad

Or use any of these recognized natural language triggers:

• "run BAD"
• "kick off the sprint"
• "automate the sprint"
• "start autonomous development"
• "run the pipeline"
• "start the dev pipeline"

Runtime Configuration Overrides

Override any setting without editing config files:

/bad MAX_PARALLEL_STORIES=2 AUTO_PR_MERGE=true MODEL_STANDARD=opus

Key variables you'll adjust most often:

REAL Code Examples: Inside BAD's Architecture

Let's examine actual implementation patterns from the repository, with detailed commentary on how this orchestration works in practice.

Example 1: The Coordinator's Core Loop

The coordinator's fundamental responsibility is maintaining pipeline state and dispatching subagents. While the full SKILL.md implementation isn't excerpted in the README, the documented behavior reveals the loop structure:

# Conceptual representation of BAD's coordinator logic
# Based on documented behavior in README

def coordinator_loop():
    """
    Main execution loop: builds dependency graph, dispatches batches,
    monitors completion, handles auto-merge, repeats until sprint done.
    """
    while not sprint_complete():
        # Step 1: Build/update dependency graph from sprint-status.yaml
        # MODEL_STANDARD subagent: maps dependencies, syncs GitHub PR status
        dependency_graph = build_dependency_graph()
        
        # Identify stories with all dependencies satisfied
        ready_stories = dependency_graph.get_ready_stories(
            respect_epic_ordering=True
        )
        
        # Batch dispatch: up to MAX_PARALLEL_STORIES simultaneously
        active_worktrees = []
        for story in ready_stories[:MAX_PARALLEL_STORIES]:
            # Each story gets isolated git worktree
            worktree = create_isolated_worktree(
                base_path=WORKTREE_BASE_PATH,  # default: ".worktrees"
                story_id=story.id
            )
            active_worktrees.append(worktree)
            
            # Dispatch 7-step pipeline for this story
            dispatch_sequential_pipeline(story, worktree)
        
        # Wait for batch completion with stale timeout watchdog
        wait_for_batch_completion(
            timeout_minutes=STALE_TIMEOUT_MINUTES  # default: 60
        )
        
        # Optional: auto-merge completed PRs sequentially
        if AUTO_PR_MERGE:
            # Lowest story number first to minimize conflicts
            merge_batch_sequentially(ready_stories)
        
        # Pause before next batch (default: 3600s = 1 hour)
        sleep(WAIT_TIMER_SECONDS)

Why this matters: The coordinator's simplicity is architectural strength. It doesn't do the work — it orchestrates workers. This prevents the context window pollution that destroys monolithic agents. The STALE_TIMEOUT_MINUTES watchdog ensures no zombie pipelines consume resources indefinitely.

Example 2: Seven-Step Pipeline Dispatch

Each story's pipeline demonstrates BAD's quality-first philosophy:

# Seven-step sequential pipeline per story
# Each step runs in fresh subagent with focused context

def run_story_pipeline(story, worktree):
    """
    Execute full story lifecycle through validated stages.
    Each step gets MODEL_STANDARD or MODEL_QUALITY as specified.
    """
    
    # Step 1: Story specification generation and validation
    # MODEL_STANDARD subagent
    spec = subagent_run(
        model=MODEL_STANDARD,  # default: "sonnet"
        skill="bmad-create-story",
        context={"story": story, "epic_context": get_epic(story.epic_id)},
        worktree=worktree
    )
    validate_spec(spec)  # Ensure acceptance criteria are complete
    
    # Step 2: Acceptance Test-Driven Development (ATDD)
    # MODEL_STANDARD subagent
    # Critical: generates FAILING tests first — true TDD
    failing_tests = subagent_run(
        model=MODEL_STANDARD,
        skill="bmad-testarch-atdd",
        context={"spec": spec, "existing_test_patterns": get_project_test_patterns()},
        worktree=worktree
    )
    verify_tests_fail(failing_tests)  # Red phase confirmed
    
    # Step 3: Implementation
    # MODEL_STANDARD subagent
    implementation = subagent_run(
        model=MODEL_STANDARD,
        skill="bmad-dev-story",
        context={
            "spec": spec,
            "failing_tests": failing_tests,
            "codebase_patterns": get_relevant_code_patterns(story)
        },
        worktree=worktree
    )
    
    # Step 4: Test quality review
    # MODEL_STANDARD subagent
    reviewed_tests = subagent_run(
        model=MODEL_STANDARD,
        skill="bmad-testarch-test-review",
        context={"tests": failing_tests, "implementation": implementation},
        worktree=worktree
    )
    apply_test_fixes(reviewed_tests)
    
    # Step 5: CODE REVIEW — uses stronger model for quality gate
    # MODEL_QUALITY subagent (default: "opus")
    review_result = subagent_run(
        model=MODEL_QUALITY,  # Stronger model for critical quality check
        skill="bmad-code-review",
        context={
            "implementation": implementation,
            "spec": spec,
            "tests": reviewed_tests,
            "review_criteria": get_project_review_criteria()
        },
        worktree=worktree
    )
    apply_code_fixes(review_result)
    
    # Step 6: CI/CD automation
    # MODEL_STANDARD subagent
    pr_result = subagent_run(
        model=MODEL_STANDARD,
        skill="bmad-pr-automation",
        context={
            "worktree": worktree,
            "story": story,
            "run_ci_locally": RUN_CI_LOCALLY  # false = use GitHub Actions
        },
        operations=["commit", "push", "open_pr", "monitor_ci", "fix_failures"]
    )
    
    # Step 7: Final PR diff review
    # MODEL_STANDARD subagent
    final_review = subagent_run(
        model=MODEL_STANDARD,
        skill="bmad-pr-diff-review",
        context={"pr": pr_result, "original_spec": spec},
        worktree=worktree
    )
    apply_final_fixes(final_review)
    push_clean_commit()
    
    return pr_result

The critical insight: Step 5's MODEL_QUALITY upgrade is where BAD prevents the "garbage in, garbage out" failure mode of lesser tools. Code review gets the strongest available model, while faster models handle routine generation. This model tiering is economically essential — you don't need GPT-4-class reasoning to generate a story spec, but you absolutely want it reviewing security-critical implementation patterns.

Example 3: Configuration and Environment Setup

The _bmad/config.yaml structure shows BAD's operational parameters:

# _bmad/config.yaml — BAD configuration section
# All values overridable at runtime with KEY=VALUE arguments

bad:
  # Parallelism control
  MAX_PARALLEL_STORIES: 3
  WORKTREE_BASE_PATH: ".worktrees"
  
  # Model tiering: separate capabilities by task criticality
  MODEL_STANDARD: "sonnet"    # Fast, capable for generation tasks
  MODEL_QUALITY: "opus"       # Deepest reasoning for code review
  
  # Automation levels
  AUTO_PR_MERGE: false        # Enable with caution — requires mature CI
  RUN_CI_LOCALLY: false       # true for faster dev loop; false for prod parity
  
  # Timing and polling
  WAIT_TIMER_SECONDS: 3600    # 1 hour between batches
  RETRO_TIMER_SECONDS: 600    # 10 min delay before auto-retrospective
  
  # Resource protection
  CONTEXT_COMPACTION_THRESHOLD: 80   # Compact context at 80% window usage
  STALE_TIMEOUT_MINUTES: 60          # Alert on stuck subagents
  
  # Platform integration
  TIMER_SUPPORT: true         # Native platform timers vs prompt-based
  MONITOR_SUPPORT: true       # Monitor tool for CI/PR polling
  
  # Claude Code-specific rate limiting
  API_FIVE_HOUR_THRESHOLD: 80   # Pause at 80% of 5-hour usage
  API_SEVEN_DAY_THRESHOLD: 95   # Pause at 95% of 7-day usage
  API_USAGE_THRESHOLD: 80       # Generic threshold for other harnesses

Operational wisdom: The CONTEXT_COMPACTION_THRESHOLD at 80% is defensive programming for long-running stories. Rather than waiting for context overflow errors, BAD proactively compacts, preserving essential state while maintaining performance. The dual timer support (TIMER_SUPPORT/MONITOR_SUPPORT) acknowledges platform differences — Claude Code has native tools that Bedrock or Vertex deployments lack.

Advanced Usage & Best Practices

Progressive Automation Adoption

Don't enable AUTO_PR_MERGE on day one. Run with defaults for several sprints, reviewing PR quality manually. Once you trust the pipeline's output, gradually enable automation. BAD's value compounds with calibration.

Model Tier Optimization

Monitor which steps benefit from MODEL_QUALITY upgrades. For domains with complex business logic (finance, healthcare), consider upgrading MODEL_STANDARD to opus for bmad-dev-story. For CRUD-heavy applications, haiku may suffice for generation tasks, reserving opus purely for review.

Custom Worktree Strategies

The default .worktrees location works for most projects. For monorepos with heavy build artifacts, configure WORKTREE_BASE_PATH on fast ephemeral storage. For security-sensitive codebases, ensure worktrees inherit appropriate .gitignore and secrets management.

Batch Size Tuning

MAX_PARALLEL_STORIES=3 balances throughput against API rate limits and compute costs. Increase cautiously — the bottleneck is rarely parallel capacity but rather dependency chain length. Optimize your sprint-status.yaml dependency graph for more ready-to-execute stories rather than forcing parallelism where dependencies don't allow it.

Harness Migration

BAD's harness detection simplifies experimentation. Test your pipeline on Claude Code, then migrate to Cursor or Copilot without configuration rewrites. The _bmad/config.yaml adapts platform-specific settings automatically.

Comparison with Alternatives

The verdict: BAD occupies a unique position — more systematic than IDE copilots, more architecturally sound than monolithic agents, more accessible than closed Devin, and actually understanding software development workflow rather than merely executing commands.

FAQ: What Developers Actually Ask

Is BAD replacing engineers or augmenting them?

Augmenting — aggressively. BAD automates execution, not decisions. Engineers design architecture, define acceptance criteria, handle exceptions, and improve the pipeline itself. The goal is eliminating coordination overhead, not engineering judgment.

How much does this cost to run?

Costs scale with MAX_PARALLEL_STORIES, model selections, and sprint size. The API_*_THRESHOLD settings prevent runaway billing. Most teams find costs comparable to 10-20% of an engineer's salary for 2-3x throughput improvement.

What if a subagent produces bad code?

The seven-step pipeline includes multiple quality gates: test generation, test review, code review, CI validation, and PR diff review. Bad code must pass five verification stages — historically unlikely. Plus, AUTO_PR_MERGE defaults to false; human review remains the final gate until you choose otherwise.

Can I use BAD without the BMad Method?

No — BAD is explicitly a BMad Method module. The sprint-status.yaml format, epic/story structure, and subagent skill definitions depend on BMad conventions. Install with npx bmad-method install --modules bmm,tea first.

Does BAD work with private repositories?

Yes, via the GITHUB_PERSONAL_ACCESS_TOKEN configuration. Ensure your token has appropriate scopes for PR creation, CI status reading, and merge operations. The gh auth login flow handles this automatically for most setups.

What happens when context compaction triggers?

At CONTEXT_COMPACTION_THRESHOLD (default 80%), the subagent summarizes completed work and trims intermediate reasoning, preserving essential state. This is transparent to pipeline operation but may reduce debuggability for complex failures.

Can I interrupt and resume a sprint?

Yes. BAD's dependency graph is reconstructed from live GitHub state on each loop iteration. Interrupt safely; resume with /bad and it continues from current graph state.

Conclusion: The Future of Sprint Execution Is Orchestrated

BAD — BMad Autonomous Development — isn't a incremental improvement to existing tools. It's a category redefinition: from AI as coding assistant to AI as engineering orchestrator. The coordinator-subagent architecture, the seven-step quality pipeline, the dependency-aware parallel execution — these aren't features added to an existing product. They're the foundational design of a system built specifically for autonomous software development at scale.

The teams that adopt this pattern first will experience something unprecedented: sprints that complete themselves while engineers focus on the creative, strategic work that actually requires human intelligence. Architecture decisions. User experience innovation. System design that no current AI can originate.

The alternative? Continuing to manually execute the same coordination rituals that have consumed engineering productivity for decades. More meetings. More context switching. More 2 AM PR reviews.

Your choice. But the repository is ready now.

Get BAD — BMad Autonomous Development on GitHub. Install with npx skills add https://github.com/stephenleo/bmad-autonomous-development, run /bad setup, and kick off your first truly autonomous sprint. The future of development orchestration isn't coming — it's already orchestrating sprints while you read this.