ros/BMAD-METHOD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: add docs

Browse Source
This commit is contained in:
Brian Madison
2025-06-15 01:18:55 -05:00
parent 6c661adaff
commit 48ef875f5e
6 changed files with 643 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
README.md
View File

@@ -251,6 +251,15 @@ cd bmad-method
npm install
```
## Documentation & Guides
### Workflow Guides
- 📚 [Universal BMAD Workflow Guide](docs/bmad-workflow-guide.md) - Core workflow that applies to all IDEs
- 🎯 [Cursor Guide](docs/cursor-guide.md) - Complete workflow for Cursor users
- 🤖 [Claude Code Guide](docs/claude-code-guide.md) - Complete workflow for Claude Code users
- 🌊 [Windsurf Guide](docs/windsurf-guide.md) - Complete workflow for Windsurf users
- 🦘 [Roo Code Guide](docs/roo-code-guide.md) - Complete workflow for Roo Code users
## Support
- 💬 [Discord Community](https://discord.gg/g6ypHytrCB)

149
docs/bmad-workflow-guide.md Normal file
View File

@@ -0,0 +1,149 @@
# BMAD Method Universal Workflow Guide
This guide outlines the core BMAD workflow that applies regardless of which AI-powered IDE you're using.
## Overview
The BMAD Method follows a structured approach to AI-assisted software development:
1. **Install BMAD** in your project
2. **Plan with Gemini** using team-fullstack
3. **Organize with bmad-master** (document sharding)
4. **Develop iteratively** with SM → Dev cycles
## The Complete Workflow
### Phase 1: Project Setup
1. **Install BMAD in your project**:
```bash
npx bmad-method install
```
- Choose "Complete installation"
- Select your IDE (Cursor, Claude Code, Windsurf, or Roo Code)
2. **Verify installation**:
- `.bmad-core/` folder created with all agents
- IDE-specific integration files created
- All agent commands/rules/modes available
### Phase 2: Ideation & Planning (Gemini)
Use Google's Gemini for collaborative planning with the full team:
1. **Open [Google AI Studio](https://aistudio.google.com/)**
2. **Load team-fullstack**:
- Copy contents of: `/Users/brianmadison/dev/BMAD-METHOD/.bmad-core/web-bundles/teams/team-fullstack.txt`
- Paste into new Gemini chat
3. **Collaborate with the team**:
- Business Analyst: Requirements gathering
- Product Manager: Feature prioritization
- Solution Architect: Technical design
- UX Expert: User experience design
### Example Gemini Sessions:
```text
"I want to build a [type] application that [core purpose].
Help me brainstorm features and create a comprehensive PRD."
"Based on this PRD, design a scalable technical architecture
that can handle [specific requirements]."
```
4. **Export planning documents**:
- Save PRD as `docs/prd.md`
- Save architecture as `docs/architecture.md`
### Phase 3: Document Organization (IDE)
Switch back to your IDE for document management:
1. **Load bmad-master agent** (syntax varies by IDE)
2. **Shard the PRD**:
```
*shard-doc docs/prd.md prd
```
3. **Shard the architecture**:
```
*shard-doc docs/architecture.md architecture
```
**Result**: Organized folder structure:
- `docs/prd/` - Broken down PRD sections
- `docs/architecture/` - Broken down architecture sections
### Phase 4: Iterative Development
Follow the SM → Dev cycle for systematic story development:
#### Story Creation (Scrum Master)
1. **Start new chat/conversation**
2. **Load SM agent**
3. **Execute**: `*create` (runs create-next-story task)
4. **Review generated story** in `docs/stories/`
5. **Update status**: Change from "Draft" to "Approved"
#### Story Implementation (Developer)
1. **Start new chat/conversation**
2. **Load Dev agent**
3. **Agent asks**: Which story to implement
4. **Follow development tasks**
5. **Complete implementation**
6. **Update status**: Change to "Done"
#### Repeat Until Complete
- **SM**: Create next story → Review → Approve
- **Dev**: Implement story → Complete → Mark done
- **Continue**: Until all features implemented
## IDE-Specific Syntax
### Agent Loading Syntax by IDE:
- **Claude Code**: `/agent-name` (e.g., `/bmad-master`)
- **Cursor**: `@agent-name` (e.g., `@bmad-master`)
- **Windsurf**: `@agent-name` (e.g., `@bmad-master`)
- **Roo Code**: Select mode from mode selector (e.g., `bmad-bmad-master`)
### Chat Management:
- **Claude Code, Cursor, Windsurf**: Start new chats when switching agents
- **Roo Code**: Switch modes within the same conversation
## Available Agents
### Core Development Agents:
- **bmad-master**: Universal task executor, document management
- **sm**: Scrum Master for story creation and agile process
- **dev**: Full-stack developer for implementation
- **architect**: Solution architect for technical design
### Specialized Agents:
- **pm**: Product manager for planning and prioritization
- **analyst**: Business analyst for requirements
- **qa**: QA specialist for testing strategies
- **po**: Product owner for backlog management
- **ux-expert**: UX specialist for design
## Key Principles
1. **Agent Specialization**: Each agent has specific expertise and responsibilities
2. **Clean Handoffs**: Always start fresh when switching between agents
3. **Status Tracking**: Maintain story statuses (Draft → Approved → InProgress → Done)
4. **Iterative Development**: Complete one story before starting the next
5. **Documentation First**: Always start with solid PRD and architecture
## Common Commands
Every agent supports these core commands:
- `*help` - Show available commands
- `*status` - Show current context/progress
- `*exit` - Exit the agent mode
## Success Tips
- **Use Gemini for big picture planning** - The team-fullstack bundle provides collaborative expertise
- **Use bmad-master for document organization** - Sharding creates manageable chunks
- **Follow the SM → Dev cycle religiously** - This ensures systematic progress
- **Keep conversations focused** - One agent, one task per conversation
- **Review everything** - Always review and approve before marking complete
This workflow ensures systematic, AI-assisted development following agile principles with clear separation of concerns and consistent progress tracking.

112
docs/claude-code-guide.md Normal file
View File

@@ -0,0 +1,112 @@
# BMAD Method Guide for Claude Code
This guide walks you through the complete BMAD workflow using Claude Code as your AI-powered IDE.
## Step 1: Install BMAD in Your Project
1. Navigate to your project directory
2. Run the BMAD installer:
```bash
npx bmad-method install
```
3. When prompted:
- **Installation Type**: Choose "Complete installation (recommended)"
- **IDE**: Select "Claude Code"
This creates a `.bmad-core` folder with all agents and a `.claude/commands` folder with agent commands.
## Step 2: Set Up Team Fullstack in Gemini
For ideation and planning, use Google's Gemini with the team-fullstack configuration:
1. Open [Google AI Studio (Gemini)](https://aistudio.google.com/)
2. Create a new chat
3. Copy the contents of `/Users/brianmadison/dev/BMAD-METHOD/.bmad-core/web-bundles/teams/team-fullstack.txt`
4. Paste this content into Gemini to set up the team
### Gemini Planning Phase
In Gemini, ask the BMAD team to help you:
- **Ideate** your project concept
- **Brainstorm** features and requirements
- **Create a PRD** (Product Requirements Document)
- **Design the architecture**
Ask questions like:
- "Help me brainstorm a [type of application] that does [core functionality]"
- "Create a comprehensive PRD for this concept"
- "Design the technical architecture for this system"
Copy the PRD and architecture documents that Gemini creates into your project's `docs/` folder:
- `docs/prd.md`
- `docs/architecture.md`
## Step 3: Back to Claude Code - Document Sharding
Once you have your PRD and architecture documents in the `docs/` folder:
1. **Start a new chat in Claude Code**
2. **Load the bmad-master agent**: Type `/bmad-master`
3. **Shard the PRD**: Type `*shard-doc docs/prd.md prd`
4. **Shard the architecture**: Type `*shard-doc docs/architecture.md architecture`
This creates organized folders:
- `docs/prd/` - Contains broken down PRD sections
- `docs/architecture/` - Contains broken down architecture sections
## Step 4: Story Development Cycle
Now begin the iterative development cycle:
### Create Stories (Scrum Master)
1. **Start a new chat**
2. **Load SM agent**: Type `/sm`
3. **Create story**: Type `*create` (this runs the create-next-story task)
4. **Review the generated story**
5. **If approved**: Set story status to "Approved" in the story file
### Implement Stories (Developer)
1. **Start a new chat**
2. **Load Dev agent**: Type `/dev`
3. **The agent will ask which story to implement**
4. **Follow the development tasks** the agent provides
5. **When story is complete**: Mark status as "Done"
### Repeat the Cycle
1. **Start a new chat with SM agent** (`/sm`)
2. **Create next story**: Type `*create`
3. **Review and approve**
4. **Start new chat with Dev agent** (`/dev`)
5. **Implement the story**
6. **Repeat until project complete**
## Available Commands in Claude Code
All BMAD agents are available as Claude Code commands:
- `/bmad-master` - Universal task executor
- `/sm` - Scrum Master for story creation
- `/dev` - Full-stack developer for implementation
- `/architect` - Solution architect for design
- `/pm` - Product manager for planning
- `/analyst` - Business analyst for requirements
- `/qa` - QA specialist for testing
- `/po` - Product owner for prioritization
- `/ux-expert` - UX specialist for design
## Key Workflow Principles
1. **Always start new chats** when switching agents to avoid context confusion
2. **Use Gemini for initial planning** and ideation with the team-fullstack bundle
3. **Use bmad-master for document management** (sharding, templates, etc.)
4. **Follow the SM → Dev cycle** for consistent story development
5. **Review and approve stories** before implementation begins
## Tips for Success
- **Keep chats focused**: Each chat should have one agent and one primary task
- **Use *help command**: Every agent supports `*help` to see available commands
- **Review generated content**: Always review and approve stories before marking them ready
- **Maintain status updates**: Keep story statuses current (Draft → Approved → InProgress → Done)
This workflow ensures systematic, AI-assisted development following agile principles with clear handoffs between planning, story creation, and implementation phases.

120
docs/cursor-guide.md Normal file
View File

@@ -0,0 +1,120 @@
# BMAD Method Guide for Cursor
This guide walks you through the complete BMAD workflow using Cursor as your AI-powered IDE.
## Step 1: Install BMAD in Your Project
1. Navigate to your project directory
2. Run the BMAD installer:
```bash
npx bmad-method install
```
3. When prompted:
- **Installation Type**: Choose "Complete installation (recommended)"
- **IDE**: Select "Cursor"
This creates a `.bmad-core` folder with all agents and a `.cursor/rules` folder with agent rules.
## Step 2: Set Up Team Fullstack in Gemini
For ideation and planning, use Google's Gemini with the team-fullstack configuration:
1. Open [Google AI Studio (Gemini)](https://aistudio.google.com/)
2. Create a new chat
3. Copy the contents of `/Users/brianmadison/dev/BMAD-METHOD/.bmad-core/web-bundles/teams/team-fullstack.txt`
4. Paste this content into Gemini to set up the team
### Gemini Planning Phase
In Gemini, ask the BMAD team to help you:
- **Ideate** your project concept
- **Brainstorm** features and requirements
- **Create a PRD** (Product Requirements Document)
- **Design the architecture**
Ask questions like:
- "Help me brainstorm a [type of application] that does [core functionality]"
- "Create a comprehensive PRD for this concept"
- "Design the technical architecture for this system"
Copy the PRD and architecture documents that Gemini creates into your project's `docs/` folder:
- `docs/prd.md`
- `docs/architecture.md`
## Step 3: Back to Cursor - Document Sharding
Once you have your PRD and architecture documents in the `docs/` folder:
1. **Start a new chat in Cursor**
2. **Load the bmad-master agent**: Type `@bmad-master`
3. **Shard the PRD**: Type `*shard-doc docs/prd.md prd`
4. **Shard the architecture**: Type `*shard-doc docs/architecture.md architecture`
This creates organized folders:
- `docs/prd/` - Contains broken down PRD sections
- `docs/architecture/` - Contains broken down architecture sections
## Step 4: Story Development Cycle
Now begin the iterative development cycle:
### Create Stories (Scrum Master)
1. **Start a new chat**
2. **Load SM agent**: Type `@sm`
3. **Create story**: Type `*create` (this runs the create-next-story task)
4. **Review the generated story**
5. **If approved**: Set story status to "Approved" in the story file
### Implement Stories (Developer)
1. **Start a new chat**
2. **Load Dev agent**: Type `@dev`
3. **The agent will ask which story to implement**
4. **Follow the development tasks** the agent provides
5. **When story is complete**: Mark status as "Done"
### Repeat the Cycle
1. **Start a new chat with SM agent** (`@sm`)
2. **Create next story**: Type `*create`
3. **Review and approve**
4. **Start new chat with Dev agent** (`@dev`)
5. **Implement the story**
6. **Repeat until project complete**
## Available Agent Rules in Cursor
All BMAD agents are available as Cursor rules (use `@` prefix):
- `@bmad-master` - Universal task executor
- `@sm` - Scrum Master for story creation
- `@dev` - Full-stack developer for implementation
- `@architect` - Solution architect for design
- `@pm` - Product manager for planning
- `@analyst` - Business analyst for requirements
- `@qa` - QA specialist for testing
- `@po` - Product owner for prioritization
- `@ux-expert` - UX specialist for design
## Cursor-Specific Features
- **Agent rules are stored in**: `.cursor/rules/` as `.mdc` files
- **Auto-completion**: Cursor will suggest `@agent-name` as you type
- **Rule activation**: Rules activate automatically when you mention `@agent-name`
- **Context awareness**: Agents have access to your current file context
## Key Workflow Principles
1. **Always start new chats** when switching agents to avoid context confusion
2. **Use Gemini for initial planning** and ideation with the team-fullstack bundle
3. **Use bmad-master for document management** (sharding, templates, etc.)
4. **Follow the SM → Dev cycle** for consistent story development
5. **Review and approve stories** before implementation begins
## Tips for Success
- **Keep chats focused**: Each chat should have one agent and one primary task
- **Use *help command**: Every agent supports `*help` to see available commands
- **Review generated content**: Always review and approve stories before marking them ready
- **Maintain status updates**: Keep story statuses current (Draft → Approved → InProgress → Done)
- **Leverage Cursor's context**: Agents can see your current file selection for better assistance
This workflow ensures systematic, AI-assisted development following agile principles with clear handoffs between planning, story creation, and implementation phases.

133
docs/roo-code-guide.md Normal file
View File

@@ -0,0 +1,133 @@
# BMAD Method Guide for Roo Code
This guide walks you through the complete BMAD workflow using Roo Code as your AI-powered IDE.
## Step 1: Install BMAD in Your Project
1. Navigate to your project directory
2. Run the BMAD installer:
```bash
npx bmad-method install
```
3. When prompted:
- **Installation Type**: Choose "Complete installation (recommended)"
- **IDE**: Select "Roo Code"
This creates a `.bmad-core` folder with all agents and a `.roo/.roomodes` file with custom modes.
## Step 2: Set Up Team Fullstack in Gemini
For ideation and planning, use Google's Gemini with the team-fullstack configuration:
1. Open [Google AI Studio (Gemini)](https://aistudio.google.com/)
2. Create a new chat
3. Copy the contents of `/Users/brianmadison/dev/BMAD-METHOD/.bmad-core/web-bundles/teams/team-fullstack.txt`
4. Paste this content into Gemini to set up the team
### Gemini Planning Phase
In Gemini, ask the BMAD team to help you:
- **Ideate** your project concept
- **Brainstorm** features and requirements
- **Create a PRD** (Product Requirements Document)
- **Design the architecture**
Ask questions like:
- "Help me brainstorm a [type of application] that does [core functionality]"
- "Create a comprehensive PRD for this concept"
- "Design the technical architecture for this system"
Copy the PRD and architecture documents that Gemini creates into your project's `docs/` folder:
- `docs/prd.md`
- `docs/architecture.md`
## Step 3: Back to Roo Code - Document Sharding
Once you have your PRD and architecture documents in the `docs/` folder:
1. **Open your project in Roo Code**
2. **Select the bmad-master mode** from the mode selector (usually in status bar)
3. **Shard the PRD**: Type `*shard-doc docs/prd.md prd`
4. **Shard the architecture**: Type `*shard-doc docs/architecture.md architecture`
This creates organized folders:
- `docs/prd/` - Contains broken down PRD sections
- `docs/architecture/` - Contains broken down architecture sections
## Step 4: Story Development Cycle
Now begin the iterative development cycle:
### Create Stories (Scrum Master)
1. **Start a new chat or conversation**
2. **Switch to SM mode**: Select `bmad-sm` from the mode selector
3. **Create story**: Type `*create` (this runs the create-next-story task)
4. **Review the generated story**
5. **If approved**: Set story status to "Approved" in the story file
### Implement Stories (Developer)
1. **Start a new conversation**
2. **Switch to Dev mode**: Select `bmad-dev` from the mode selector
3. **The agent will ask which story to implement**
4. **Follow the development tasks** the agent provides
5. **When story is complete**: Mark status as "Done"
### Repeat the Cycle
1. **Switch to SM mode** (`bmad-sm`)
2. **Create next story**: Type `*create`
3. **Review and approve**
4. **Switch to Dev mode** (`bmad-dev`)
5. **Implement the story**
6. **Repeat until project complete**
## Available Custom Modes in Roo Code
All BMAD agents are available as custom modes:
- `bmad-bmad-master` - 🧙 Universal task executor
- `bmad-sm` - 🏃 Scrum Master for story creation
- `bmad-dev` - 💻 Full-stack developer for implementation
- `bmad-architect` - 🏗️ Solution architect for design
- `bmad-pm` - 📋 Product manager for planning
- `bmad-analyst` - 📊 Business analyst for requirements
- `bmad-qa` - 🧪 QA specialist for testing
- `bmad-po` - 🎯 Product owner for prioritization
- `bmad-ux-expert` - 🎨 UX specialist for design
## Roo Code-Specific Features
- **Custom modes are stored in**: `.roo/.roomodes` file
- **Mode switching**: Use the mode selector in Roo Code's interface
- **File permissions**: Each agent has specific file access permissions
- **Documentation agents** (SM, PM, PO, Analyst): Limited to `.md` and `.txt` files
- **Technical agents** (Dev, Architect, Master): Full file access
- **QA agents**: Access to test files and documentation
- **UX agents**: Access to design-related files
- **Context preservation**: Modes maintain context within conversations
## Key Workflow Principles
1. **Switch modes instead of starting new chats** - Roo Code handles context better with mode switching
2. **Use Gemini for initial planning** and ideation with the team-fullstack bundle
3. **Use bmad-master mode for document management** (sharding, templates, etc.)
4. **Follow the SM → Dev mode cycle** for consistent story development
5. **Review and approve stories** before implementation begins
## Tips for Success
- **Use mode selector effectively**: Switch modes as needed for different tasks
- **Respect file permissions**: Agents can only edit files they have permission for
- **Use *help command**: Every mode supports `*help` to see available commands
- **Review generated content**: Always review and approve stories before marking them ready
- **Maintain status updates**: Keep story statuses current (Draft → Approved → InProgress → Done)
- **Leverage Roo's context**: Modes can maintain context across the conversation
## File Permission Summary
- **bmad-analyst, bmad-pm, bmad-po, bmad-sm**: `.md`, `.txt` files only
- **bmad-architect**: `.md`, `.txt`, `.yml`, `.yaml`, `.json` files
- **bmad-qa**: Test files (`.test.js`, `.spec.ts`, etc.) and `.md` files
- **bmad-ux-expert**: `.md`, `.css`, `.scss`, `.html`, `.jsx`, `.tsx` files
- **bmad-dev, bmad-bmad-master, bmad-orchestrator**: Full file access
This workflow ensures systematic, AI-assisted development following agile principles with clear handoffs between planning, story creation, and implementation phases.

120
docs/windsurf-guide.md Normal file
View File

@@ -0,0 +1,120 @@
# BMAD Method Guide for Windsurf
This guide walks you through the complete BMAD workflow using Windsurf as your AI-powered IDE.
## Step 1: Install BMAD in Your Project
1. Navigate to your project directory
2. Run the BMAD installer:
```bash
npx bmad-method install
```
3. When prompted:
- **Installation Type**: Choose "Complete installation (recommended)"
- **IDE**: Select "Windsurf"
This creates a `.bmad-core` folder with all agents and a `.windsurf/rules` folder with agent rules.
## Step 2: Set Up Team Fullstack in Gemini
For ideation and planning, use Google's Gemini with the team-fullstack configuration:
1. Open [Google AI Studio (Gemini)](https://aistudio.google.com/)
2. Create a new chat
3. Copy the contents of `/Users/brianmadison/dev/BMAD-METHOD/.bmad-core/web-bundles/teams/team-fullstack.txt`
4. Paste this content into Gemini to set up the team
### Gemini Planning Phase
In Gemini, ask the BMAD team to help you:
- **Ideate** your project concept
- **Brainstorm** features and requirements
- **Create a PRD** (Product Requirements Document)
- **Design the architecture**
Ask questions like:
- "Help me brainstorm a [type of application] that does [core functionality]"
- "Create a comprehensive PRD for this concept"
- "Design the technical architecture for this system"
Copy the PRD and architecture documents that Gemini creates into your project's `docs/` folder:
- `docs/prd.md`
- `docs/architecture.md`
## Step 3: Back to Windsurf - Document Sharding
Once you have your PRD and architecture documents in the `docs/` folder:
1. **Start a new chat in Windsurf**
2. **Load the bmad-master agent**: Type `@bmad-master`
3. **Shard the PRD**: Type `*shard-doc docs/prd.md prd`
4. **Shard the architecture**: Type `*shard-doc docs/architecture.md architecture`
This creates organized folders:
- `docs/prd/` - Contains broken down PRD sections
- `docs/architecture/` - Contains broken down architecture sections
## Step 4: Story Development Cycle
Now begin the iterative development cycle:
### Create Stories (Scrum Master)
1. **Start a new chat**
2. **Load SM agent**: Type `@sm`
3. **Create story**: Type `*create` (this runs the create-next-story task)
4. **Review the generated story**
5. **If approved**: Set story status to "Approved" in the story file
### Implement Stories (Developer)
1. **Start a new chat**
2. **Load Dev agent**: Type `@dev`
3. **The agent will ask which story to implement**
4. **Follow the development tasks** the agent provides
5. **When story is complete**: Mark status as "Done"
### Repeat the Cycle
1. **Start a new chat with SM agent** (`@sm`)
2. **Create next story**: Type `*create`
3. **Review and approve**
4. **Start new chat with Dev agent** (`@dev`)
5. **Implement the story**
6. **Repeat until project complete**
## Available Agent Rules in Windsurf
All BMAD agents are available as Windsurf rules (use `@` prefix):
- `@bmad-master` - Universal task executor
- `@sm` - Scrum Master for story creation
- `@dev` - Full-stack developer for implementation
- `@architect` - Solution architect for design
- `@pm` - Product manager for planning
- `@analyst` - Business analyst for requirements
- `@qa` - QA specialist for testing
- `@po` - Product owner for prioritization
- `@ux-expert` - UX specialist for design
## Windsurf-Specific Features
- **Agent rules are stored in**: `.windsurf/rules/` as `.md` files
- **Rule activation**: Rules activate when you mention `@agent-name` in chat
- **Collaborative workflow**: Windsurf's collaborative features work well with BMAD's agent-switching pattern
- **Context awareness**: Agents have access to your project context
## Key Workflow Principles
1. **Always start new chats** when switching agents to avoid context confusion
2. **Use Gemini for initial planning** and ideation with the team-fullstack bundle
3. **Use bmad-master for document management** (sharding, templates, etc.)
4. **Follow the SM → Dev cycle** for consistent story development
5. **Review and approve stories** before implementation begins
## Tips for Success
- **Keep chats focused**: Each chat should have one agent and one primary task
- **Use *help command**: Every agent supports `*help` to see available commands
- **Review generated content**: Always review and approve stories before marking them ready
- **Maintain status updates**: Keep story statuses current (Draft → Approved → InProgress → Done)
- **Leverage Windsurf's collaboration**: Use the collaborative features for team reviews
This workflow ensures systematic, AI-assisted development following agile principles with clear handoffs between planning, story creation, and implementation phases.