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

┌─────────────────────────────────────────────────────────────────┐

│  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                    │

└─────────────────────────┴───────────────────────────────────────┘

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?

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

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

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

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/

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.

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

# 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

┌────────────────────────────────────────────────────────┐

│                    QUICK FLOW                          │

│                                                        │

│   /quick-spec  →  /dev-story  →  /code-review        │

│       ↓              ↓              ↓                  │

│   tech-spec.md   implement      validate              │

│   with stories   each story     quality               │

└────────────────────────────────────────────────────────┘

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

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

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

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)

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

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

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

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

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

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

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

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

/bmad-help

/bmad-help I just finished the PRD, what's next?

/bmad-help How do I handle scope changes mid-sprint?