DEV Community

Cover image for BMAD-Method Workflows Deep Dive: From Idea to Production (Part 2)
Brian Spann
Brian Spann

Posted on

BMAD-Method Workflows Deep Dive: From Idea to Production (Part 2)

#ai #programming #agile #productivity

In Part 1, we introduced BMAD-Method and its philosophy of AI as collaborator. Now let's dive deep into the workflows that make it practical.

The Four Development Phases

BMAD organizes development into four distinct phases, each with specific goals and outputs:

┌─────────────────────────────────────────────────────────────────┐
│  Phase 1: ANALYSIS      │  Phase 2: PLANNING                   │
│  ─────────────────      │  ───────────────────                 │
│  • Brainstorming        │  • PRD (Product Requirements)        │
│  • Research             │  • Tech Spec (Quick Flow)            │
│  • Product Brief        │  • User personas & journeys          │
│                         │                                       │
├─────────────────────────┼───────────────────────────────────────┤
│  Phase 3: SOLUTIONING   │  Phase 4: IMPLEMENTATION             │
│  ─────────────────────  │  ───────────────────────             │
│  • Architecture         │  • Sprint planning                   │
│  • Epics & Stories      │  • Story development                 │
│  • UX Design            │  • Code review                       │
│  • Implementation Check │  • Retrospectives                    │
└─────────────────────────┴───────────────────────────────────────┘
Enter fullscreen mode Exit fullscreen mode

Phase 1: Analysis (Optional but Valuable)

This is where ideas become clearer. You're not committing to anything yet—just exploring.

Workflows:

  • /bmad-brainstorming — Structured ideation with the Analyst agent
  • /bmad-bmm-research — Market analysis, competitive research, technical feasibility
  • /create-product-brief — Capture the essence before diving into details

Example: Brainstorming Session

You: /bmad-brainstorming

Analyst: Welcome! I'm here to help you explore ideas systematically.
         What problem or opportunity are you thinking about?

You: I want to build a tool that helps developers manage their
     AI prompts across projects.

Analyst: Interesting! Let's explore this from multiple angles.

         🎯 PROBLEM SPACE:
         - Who experiences this pain most acutely?
         - What do they currently do instead?
         - What makes this urgent now?

         Would you like to start with user research or competitive analysis?
Enter fullscreen mode Exit fullscreen mode

Phase 2: Planning (Required)

This is where requirements become concrete. The output differs based on your track:

Quick Flow → Tech Spec

You: /quick-spec

BMAD: I'll analyze your project and create a technical specification.
      [Reads existing code, understands stack]

      📄 Generated: _bmad-output/tech-spec.md

      Summary:
      - 8 stories identified
      - Estimated complexity: Medium
      - Recommended approach: Incremental implementation
Enter fullscreen mode Exit fullscreen mode

Full BMad Method → PRD

You: /create-prd

PM: Let's build a comprehensive Product Requirements Document.
    I'll guide you through each section.

    First, let's define the problem statement.
    What problem does this product solve, and for whom?

[Guides through: Problem, Users, Personas, Features, Success Metrics, Risks]

📄 Generated: _bmad-output/PRD.md
Enter fullscreen mode Exit fullscreen mode

Phase 3: Solutioning

Now we design how to build it. This phase creates the technical foundation.

Architecture Creation

You: /create-architecture

Architect: I've reviewed your PRD. Let's design the system architecture.

           Based on your requirements, I'm considering:
           - Microservices vs Monolith: Given scale requirements...
           - Database: PostgreSQL for relational data, Redis for caching
           - API: REST with OpenAPI specification

           Let's discuss the key architectural decisions.

📄 Generated: _bmad-output/architecture.md
Enter fullscreen mode Exit fullscreen mode

Breaking Down into Epics and Stories

You: /create-epics-and-stories

PM: I'll break down the PRD into implementable units.
    [Reads PRD and Architecture]

    📁 Created Epic Structure:

    Epic 1: User Authentication (5 stories)
    Epic 2: Core API (8 stories)  
    Epic 3: Data Management (4 stories)
    Epic 4: Admin Dashboard (6 stories)

    Total: 23 stories across 4 epics

📄 Generated: _bmad-output/epics/
Enter fullscreen mode Exit fullscreen mode

Implementation Readiness Check

You: /check-implementation-readiness

Architect: I'll validate that all planning documents are cohesive
           and ready for implementation.

           Checking:
           ✅ PRD → Architecture alignment
           ✅ Architecture → Stories traceability  
           ✅ Technical feasibility of all stories
           ⚠️  Story E2-S3 references undefined API endpoint

           Recommendation: Update Architecture section 4.2
           before starting implementation.
Enter fullscreen mode Exit fullscreen mode

Phase 4: Implementation

This is where code gets written. BMAD provides structure without micromanaging.

Sprint Planning

You: /sprint-planning

SM: Let's set up sprint tracking.

    Based on your epics, I recommend:

    Sprint 1 (Foundation):
    - E1-S1: Database schema
    - E1-S2: User model
    - E1-S3: Auth endpoints

    Sprint 2 (Core Features):
    - E2-S1: API scaffolding
    - E2-S2: CRUD operations
    ...

📄 Generated: _bmad-output/sprint-status.yaml
Enter fullscreen mode Exit fullscreen mode

The Development Cycle

For each story, you follow this pattern:

# 1. Create detailed story file
/create-story E1-S1

# 2. Implement the story
/dev-story E1-S1

# 3. Review the implementation  
/code-review E1-S1
Enter fullscreen mode Exit fullscreen mode

Quick Flow: The Fast Path

For smaller work, Quick Flow condenses everything into 3 commands:

┌────────────────────────────────────────────────────────┐
│                    QUICK FLOW                          │
│                                                        │
│   /quick-spec  →  /dev-story  →  /code-review        │
│       ↓              ↓              ↓                  │
│   tech-spec.md   implement      validate              │
│   with stories   each story     quality               │
└────────────────────────────────────────────────────────┘
Enter fullscreen mode Exit fullscreen mode

When Quick Flow Shines

Bug Fixes

You: /quick-spec
     The login button doesn't work on mobile Safari.

BMAD: [Analyzes codebase, identifies issue]

      Created tech-spec with 2 stories:
      1. Fix Safari-specific CSS flexbox issue
      2. Add mobile browser testing

You: /dev-story 1

DEV: [Implements fix]
     Fixed: Updated button container to use
     -webkit-flex for Safari compatibility.

You: /code-review

DEV: ✅ Fix applied correctly
     ✅ No regression in other browsers
     ⚠️ Consider adding browser testing to CI
Enter fullscreen mode Exit fullscreen mode

Small Features

You: /quick-spec
     Add dark mode toggle to settings page.

BMAD: Created tech-spec with 4 stories:
      1. Create theme context and provider
      2. Add toggle component
      3. Persist preference to localStorage
      4. Update all components for theme awareness
Enter fullscreen mode Exit fullscreen mode

Full Planning: Building Products Right

For new products or major features, the full path ensures nothing is missed.

Complete Walkthrough: Building a Habit Tracker

Step 1: Product Brief

You: /create-product-brief

Analyst: Let's capture the essence of your product.

You: I want to build a habit tracker that uses
     gamification to keep users engaged.

Analyst: Great! Let's define the core elements:

         Problem: Users struggle to maintain habits
         Solution: Gamified tracking with rewards
         Target Users: [Let's define this...]

📄 Generated: _bmad-output/product-brief.md
Enter fullscreen mode Exit fullscreen mode

Step 2: Full PRD

You: /create-prd

PM: Building on your product brief, let's create
    comprehensive requirements.

    [Guides through 12 sections including:]
    - User Personas
    - Feature Requirements (MoSCoW prioritized)
    - User Journeys
    - Success Metrics
    - Technical Constraints
    - Risk Analysis

📄 Generated: _bmad-output/PRD.md (comprehensive 15-page doc)
Enter fullscreen mode Exit fullscreen mode

Step 3: Architecture

You: /create-architecture

Architect: I've reviewed the PRD. Here's my recommended architecture:

           Frontend: React Native (cross-platform requirement)
           Backend: Node.js + Express
           Database: PostgreSQL + Redis

           Key Decisions:
           1. Real-time sync via WebSockets
           2. Offline-first with local SQLite
           3. Push notifications via Firebase

           Let's discuss the gamification engine design...

📄 Generated: _bmad-output/architecture.md
Enter fullscreen mode Exit fullscreen mode

Step 4: Epics & Stories

You: /create-epics-and-stories

PM: Breaking down into implementable work:

    Epic 1: User Onboarding (4 stories)
    Epic 2: Habit Management (6 stories)
    Epic 3: Gamification Engine (8 stories)
    Epic 4: Social Features (5 stories)
    Epic 5: Notifications (4 stories)
    Epic 6: Analytics Dashboard (3 stories)

    Total: 30 stories, estimated 6 sprints

📄 Generated: _bmad-output/epics/*.md
Enter fullscreen mode Exit fullscreen mode

Step 5: Implementation

You: /sprint-planning
You: /create-story E1-S1
You: /dev-story E1-S1
You: /code-review
... [repeat for each story]
You: /retrospective  # After each epic
Enter fullscreen mode Exit fullscreen mode

Party Mode: Multi-Agent Collaboration

One of BMAD's most powerful features is Party Mode—bringing multiple agents together for collaborative problem-solving.

Enabling Party Mode 

You: /party-mode PM, Architect, Security

[Party Mode Activated]
PM: 👋 Product Manager here. Ready to ensure we're building the right thing.
Architect: 🏗️ Architect present. Let's make sure it's built right.
Security: 🔐 Security checking in. I'll keep us safe.

You: We're adding a payment system. What should we consider?

PM: From a product perspective:
    - What payment methods do users expect?
    - How does pricing affect conversion?
    - What's our refund policy?

Architect: Technically, I recommend:
    - Use Stripe for PCI compliance
    - Implement idempotency for reliability
    - Consider webhook handling architecture

Security: Critical considerations:
    - Never store raw card numbers
    - Implement rate limiting on payment endpoints
    - Audit logging for all transactions
    - Consider fraud detection integration
Enter fullscreen mode Exit fullscreen mode

Party Mode Use Cases

Design Review

/party-mode Architect, UX, Developer

You: Let's review the dashboard design.

UX: The layout prioritizes key metrics, but we should
    consider mobile responsiveness for field users.

Architect: The real-time data requirements mean we'll need
           WebSocket connections—let's discuss connection pooling.

Developer: I can implement this with React Query for
           optimistic updates. Estimated 2-3 days.
Enter fullscreen mode Exit fullscreen mode

Troubleshooting Session

/party-mode Developer, DevOps, DBA

You: Production is slow. Query times jumped from 50ms to 2s.

Developer: Let me check the recent code changes...
           The new feature adds a JOIN on the orders table.

DBA: That table has 10M rows without proper indexing.
     Adding a composite index should help significantly.

DevOps: I'm also seeing memory pressure on the DB instance.
        Consider scaling vertically or adding read replicas.
Enter fullscreen mode Exit fullscreen mode

Architecture Decision

/party-mode Architect, Security, PM

You: Should we use microservices or monolith?

PM: Our timeline is 3 months to MVP. How does this
    affect delivery speed?

Architect: Monolith is faster for MVP, but microservices
           scale better. Given our user projections...

Security: Microservices add attack surface but improve
          isolation. For healthcare data, I'd recommend
          at minimum separating the auth service.
Enter fullscreen mode Exit fullscreen mode

Context Management: The Secret Sauce

BMAD maintains context across sessions through file-based artifacts:

your-project/
├── _bmad/                    # BMAD configuration
│   ├── agents/               # Agent definitions
│   ├── workflows/            # Workflow configurations
│   └── core-config.yaml      # Project settings
│
└── _bmad-output/             # Your artifacts
    ├── product-brief.md      # Phase 1 output
    ├── PRD.md                # Phase 2 output
    ├── architecture.md       # Phase 3 output
    ├── epics/                # Story breakdowns
    │   ├── epic-1.md
    │   └── epic-2.md
    └── sprint-status.yaml    # Current progress
Enter fullscreen mode Exit fullscreen mode

Why This Matters:

  1. No context loss — Start a new chat, agents pick up where you left off
  2. Version control — Your planning docs are in git
  3. Team visibility — Everyone sees the same artifacts
  4. AI grounding — Agents reference concrete documents, not hallucinations

Workflow Quick Reference

Phase Workflow Command Agent Output
Analysis Brainstorming /bmad-brainstorming Analyst Ideas
Analysis Research /bmad-bmm-research Analyst Research doc
Analysis Product Brief /create-product-brief Analyst product-brief.md
Planning Quick Spec /quick-spec Auto tech-spec.md
Planning Create PRD /create-prd PM PRD.md
Solutioning Architecture /create-architecture Architect architecture.md
Solutioning Epics/Stories /create-epics-and-stories PM epics/*.md
Solutioning Readiness Check /check-implementation-readiness Architect Validation
Implementation Sprint Planning /sprint-planning SM sprint-status.yaml
Implementation Create Story /create-story SM Story file
Implementation Dev Story /dev-story DEV Code
Implementation Code Review /code-review DEV Review
Implementation Retrospective /retrospective SM Lessons

Tips for Effective Workflow Usage

1. Use Fresh Chats

Start a new chat for each major workflow. This keeps context focused and prevents confusion.

2. Trust the Process (Initially)

Follow the recommended path until you understand it. Then customize.

3. Let Agents Guide You

Agents ask questions for a reason. Answer thoughtfully—the quality of outputs depends on input quality.

4. Review Artifacts

Before moving to the next phase, review what was generated. Catch issues early.

5. Use Help When Stuck 

/bmad-help
/bmad-help I just finished the PRD, what's next?
/bmad-help How do I handle scope changes mid-sprint?
Enter fullscreen mode Exit fullscreen mode

Coming Next

Part 3: BMad Builder — Learn how to create custom agents tailored to your domain, build specialized workflows, and package them into shareable modules.

Understanding workflows is the key to unlocking BMAD's full potential. Start with Quick Flow for small work, graduate to Full Planning for products, and use Party Mode when you need diverse perspectives.

Questions about workflows? Ask in the comments!

Top comments (0)