Planning Phase Guide

Complete guide to the planning phase of BMad Method. Use this phase to create comprehensive specifications before development begins.

Platform: Web AI platforms (ChatGPT, Claude, Gemini) Duration: 1-4 hours depending on project complexity Output: PRD, Architecture, Frontend Spec (if UI), Sharded documents

Overview

The planning phase creates complete, validated specifications before coding starts. This eliminates planning inconsistency and ensures development has complete context.

Prerequisites

• BMad Method installed (npx bmad-method install)
• Web bundles generated (optional but recommended)
• Project idea or requirements
• Access to web AI platform (ChatGPT, Claude, or Gemini)

Phase Structure

Analyst → PM → UX Expert → Architect → PO
   ↓       ↓        ↓          ↓        ↓
 Brief    PRD    UI Spec   Architecture  Validation
                                            & Sharding

Step-by-Step Workflow

Step 1: Load Planning Team

For full-stack projects:

Load: web-bundles/teams/team-fullstack.txt

For backend-only projects:

Load: web-bundles/teams/team-no-ui.txt

Copy entire file contents and paste into your web AI platform.

Step 2: Orchestrator Initialization

*help
*workflow-guidance

Answer orchestrator's questions:

• New or existing project? New
• Project type? Full-stack / Backend-only / Frontend-only

Orchestrator recommends appropriate workflow.

Step 3: Create Project Brief (Analyst)

*agent analyst
*create-project-brief

Elicitation Topics:

1. Project Overview: Name, description, purpose
2. Problem Statement: What problem does this solve?
3. Goals and Objectives: What success looks like
4. Success Criteria: Measurable metrics
5. Stakeholders: Who is involved?
6. Constraints: Budget, timeline, technical
7. Assumptions: What we're assuming is true

Interactive Elicitation: For each section, analyst presents draft and offers:

1. Proceed to next section 2-9. Elicitation methods (SCAMPER, 5 Whys, Jobs-to-be-Done, etc.)

Output: docs/project-brief.md

Optional Advanced Tasks:

• *perform-market-research: Market analysis
• *create-competitor-analysis: Competitive landscape
• *brainstorm: Structured brainstorming session

Step 4: Create PRD (Product Manager)

*agent pm
*create-prd

PRD Structure:

1. Product Overview: Vision, goals, success metrics
2. User Personas: Target users, needs, pain points
3. Epics and Stories: Organized feature sets
   • Epic format: Epic N: {Title}
   • Story format: Story N.M: As a {role}, I want {action}, so that {benefit}
   • Acceptance criteria for each story
4. Non-Functional Requirements: Performance, security, scalability
5. Dependencies: External systems, APIs
6. Risks: Potential issues and mitigation
7. Glossary: Terms and definitions

Interactive Elicitation: Same 1-9 format as project brief.

Key Principles:

• Each epic contains multiple related stories
• Stories follow user story format
• Acceptance criteria are specific and testable
• Technical requirements included

Output: docs/prd.md

Step 5: Create Frontend Specification (UX Expert) - If UI Needed

*agent ux-expert
*create-frontend-spec

Frontend Spec Structure:

1. UI/UX Overview: Design philosophy, user experience goals
2. Design System: Colors, typography, spacing, components
3. Component Specifications: Detailed component designs
4. User Flows: Step-by-step user journeys
5. Wireframes/Mockups: Visual representations
6. Interaction Patterns: How users interact
7. Responsive Design: Mobile, tablet, desktop
8. Accessibility: WCAG compliance, a11y features

Output: docs/front-end-spec.md

Optional: Generate v0/Lovable prompts

*generate-ui-prompt

Step 6: Create Architecture (Architect)

*agent architect
*create-architecture

Architecture Document Structure:

For Full-Stack Projects:

1. System Overview: High-level architecture
2. Tech Stack: Frontend, backend, database, infrastructure
3. Frontend Architecture: UI, state, routing, components, styling
4. Backend Architecture: API, business logic, data access, auth
5. Database Architecture: Schema, models, migrations
6. API Specifications: REST endpoints, request/response, auth
7. Integration Points: External services, APIs
8. Unified Project Structure: Directory structure, file organization
9. Deployment Architecture: Frontend, backend, database, CI/CD
10. Coding Standards: Frontend and backend conventions
11. Testing Strategy: Unit, integration, E2E testing

For Backend-Only Projects:

1. System Overview
2. Tech Stack
3. System Components
4. Data Models
5. API Specifications
6. Security Architecture
7. Deployment Architecture
8. Coding Standards
9. Testing Strategy

For Frontend-Only Projects:

1. Frontend Overview
2. Tech Stack
3. Component Architecture
4. State Management
5. Routing Strategy
6. API Integration
7. Project Structure
8. Styling Approach
9. Performance Optimization
10. Testing Strategy

Output:

• Full-stack: docs/fullstack-architecture.md
• Backend: docs/architecture.md
• Frontend: docs/front-end-architecture.md

Optional: Architecture review

*review-architecture

Step 7: PRD Update (if needed)

If architect identifies inconsistencies with PRD:

*agent pm
*update-prd

PM updates PRD based on architecture feedback.

Step 8: Validation and Sharding (Product Owner)

*agent po
*shard-doc

PO Actions:

1. Validates all artifacts against checklists
2. Shards PRD into individual epic files
3. Shards architecture into section files

Sharding Output:

docs/prd/
├── index.md
├── epic-1-{name}.md
├── epic-2-{name}.md
└── epic-3-{name}.md

docs/architecture/
├── index.md
├── tech-stack.md
├── unified-project-structure.md
├── coding-standards.md
├── testing-strategy.md
├── data-models.md
├── database-schema.md
├── backend-architecture.md
├── rest-api-spec.md
├── frontend-architecture.md
├── components.md
└── core-workflows.md

Validation Commands:

*validate-story-draft   # Validate story structure
*correct-course         # Adjust if off track

Planning Phase Complete

At this point you have:

• ✅ Complete project brief
• ✅ Comprehensive PRD with epics and stories
• ✅ (Optional) Frontend specification
• ✅ Detailed architecture document
• ✅ Sharded documents for development

Handoff to Development Phase

Transfer to desktop IDE with sharded documents:

1. Documents Created: docs/ directory with PRD and architecture
2. Sharded Documents: docs/prd/ and docs/architecture/ directories
3. Configuration: .bmad-core/core-config.yaml already configured
4. Ready for Development: SM can now create stories with complete context

Next Steps

Continue with Development Phase Guide

Troubleshooting Planning Phase

Problem: Elicitation overwhelming Solution: Use YOLO mode (*yolo) for faster generation

Problem: PRD too long Solution: Break into more epics, focus on MVP

Problem: Architecture unclear Solution: Use *review-architecture for completeness check

Problem: Sharding fails Solution: Check markdownExploder setting in core-config.yaml

Best Practices

1. Complete Each Step: Don't skip agents - each builds on previous work
2. Use Elicitation: Engage with elicitation methods for better requirements
3. Reference Previous Work: PM references project brief, Architect references PRD
4. Validate Before Sharding: PO validates before sharding to catch issues early
5. Keep Context: Save all planning work - development phase references it

Related Documentation

• Development Phase Guide
• Agent Reference
• Workflow Reference
• Template Reference