BMAD

BMAD (Breakthrough Method of Agile AI-Driven Development) orchestrates multiple AI agents working on complex features simultaneously. The /bmad-init command provides a lite implementation focusing on parallel development with bounded contexts.

Core Implementation

The codebase includes BMAD initialization through:

/bmad-init "real-time collaboration system" --agents=3 --context=full

This command decomposes features into parallel work streams with specialized agents.

Agent Structure

The current implementation creates three default agent types:

• Core Functionality Specialist - Implements primary feature logic
• Testing and Validation Specialist - Creates comprehensive test suites
• Integration and Deployment Specialist - Handles system connections

Additional agents can be specified for complex features:

/bmad-init "payment processing" --agents=5 --prp

Generated Artifacts

The command creates coordination structure:

• context.md - Shared context for all agents
• agent-1-prp.md - Core functionality PRP
• agent-2-prp.md - Testing PRP
• agent-3-prp.md - Integration PRP
• contracts.ts - Interface definitions
• integration-plan.md - Rollout strategy

Context Files

Each agent receives bounded context through individual PRPs:

# agent-1-prp.md
## Scope: Core Notification Engine
- WebSocket connection management
- Message broadcasting logic
- State synchronization

## Interfaces
See contracts.ts for MessageBroker interface

## Constraints
- No database access (use agent-3)
- Must implement all contracts.ts interfaces

Interface Contracts

TypeScript interfaces define boundaries:

export interface MessageBroker {
  publish(channel: string, message: Message): Promise<void>;
  subscribe(channel: string, handler: Handler): Subscription;
}

Agents implement against these contracts ensuring compatibility.

Workflow Process

1. Feature Analysis - Command analyzes complexity and identifies work streams
2. Agent Assignment - Each stream gets dedicated agent context
3. Contract Generation - Shared interfaces prevent integration conflicts
4. PRP Creation - Detailed implementation plans for each agent
5. Progress Tracking - Monitor multi-agent coordination

Parallel Execution

Agents work simultaneously within boundaries:

Agent 1: Implements core business logic
Agent 2: Creates tests for agent 1 outputs
Agent 3: Integrates with existing systems

Clear separation enables true parallel development. Dependencies tracked in integration plan.

Command Options

Context Levels

--context=minimal   # Basic feature requirements only
--context=standard  # Include architecture constraints
--context=full      # Complete codebase patterns

PRP Generation

--prp  # Generate detailed PRPs for each agent

Without this flag, agents receive lighter context files.

Limitations

This implementation provides BMAD-lite functionality:

• No automated sprint ceremonies
• No role-based agent specialization (Analyst, PM, etc.)
• No story file generation
• Manual coordination between agents
• No built-in hand-off protocols

Full BMAD methodology includes agile ceremonies and specialized agent roles not currently implemented.

When to Use

The /bmad-init command suits:

• Features with clear component boundaries
• Parallel development opportunities
• Need for isolated agent contexts
• Complex multi-layer implementations

Simple features gain little from agent orchestration overhead.

Integration Benefits

Despite being a lite implementation, the command provides:

• Bounded contexts preventing agent confusion
• Interface contracts ensuring compatibility
• Task decomposition for parallel work
• Progress tracking through structured outputs

These benefits make complex features manageable through AI agent coordination.

Example Usage

Implementing a real-time collaboration system:

/bmad-init "real-time collaboration" --agents=3 --context=full --prp

Generates:

• Core agent builds WebSocket infrastructure
• Testing agent creates integration tests
• Integration agent connects to authentication and database

Agents work in parallel following their PRPs and respecting interface contracts.

Related Documentation