diff --git a/README.md b/README.md
index 8e24fb6c..4d9fee77 100644
--- a/README.md
+++ b/README.md
@@ -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)
diff --git a/docs/bmad-workflow-guide.md b/docs/bmad-workflow-guide.md
new file mode 100644
index 00000000..924186ff
--- /dev/null
+++ b/docs/bmad-workflow-guide.md
@@ -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.
\ No newline at end of file
diff --git a/docs/claude-code-guide.md b/docs/claude-code-guide.md
new file mode 100644
index 00000000..2bb94499
--- /dev/null
+++ b/docs/claude-code-guide.md
@@ -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.
\ No newline at end of file
diff --git a/docs/cursor-guide.md b/docs/cursor-guide.md
new file mode 100644
index 00000000..5624f67a
--- /dev/null
+++ b/docs/cursor-guide.md
@@ -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.
\ No newline at end of file
diff --git a/docs/roo-code-guide.md b/docs/roo-code-guide.md
new file mode 100644
index 00000000..61d5b36e
--- /dev/null
+++ b/docs/roo-code-guide.md
@@ -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.
\ No newline at end of file
diff --git a/docs/windsurf-guide.md b/docs/windsurf-guide.md
new file mode 100644
index 00000000..8c96126c
--- /dev/null
+++ b/docs/windsurf-guide.md
@@ -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.
\ No newline at end of file