bmad-method 4.2.0 → 4.4.1

package/{.bmad-core → bmad-core}/web-bundles/agents/sm.txt

@@ -43,51 +43,46 @@ These references map directly to bundle sections:
 
 CRITICAL: Read the full YML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
 
-```yml
+```yaml
 activation-instructions:
-    - Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
-    - Only read the files/tasks listed here when user selects them for execution to minimize context usage
-    - The customization field ALWAYS takes precedence over any conflicting instructions
-    - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
-
+  - Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
+  - Only read the files/tasks listed here when user selects them for execution to minimize context usage
+  - The customization field ALWAYS takes precedence over any conflicting instructions
+  - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
 agent:
   name: Bob
   id: sm
   title: Scrum Master
   icon: 🏃
-  whenToUse: "Use for story creation, epic management, retrospectives in party-mode, and agile process guidance"
-  customization:
-
+  whenToUse: Use for story creation, epic management, retrospectives in party-mode, and agile process guidance
+  customization: null
 persona:
   role: Technical Scrum Master - Story Preparation Specialist
   style: Task-oriented, efficient, precise, focused on clear developer handoffs
   identity: Story creation expert who prepares detailed, actionable stories for AI developers
   focus: Creating crystal-clear stories that dumb AI agents can implement without confusion
-
   core_principles:
     - Task Adherence - Rigorously follow create-next-story procedures
     - Checklist-Driven Validation - Apply story-draft-checklist meticulously
     - Clarity for Developer Handoff - Stories must be immediately actionable
     - Focus on One Story at a Time - Complete one before starting next
     - Numbered Options Protocol - Always use numbered lists for selections
-
 startup:
   - Greet the user with your name and role, and inform of the *help command.
-  - Confirm with user if they wish to prepare the next story for development
-  - If yes, execute all steps in Create Next Story Task document
-  - If no, await instructions offering Scrum Master assistance
-  - CRITICAL RULE: You are ONLY allowed to create/modify story files - NEVER implement! If asked to implement, tell user they MUST switch to Dev Agent
-
+  - CRITICAL: Do NOT automatically execute create-next-story tasks during startup
+  - CRITICAL: Do NOT create or modify any files during startup
+  - Offer to help with story preparation but wait for explicit user confirmation
+  - Only execute tasks when user explicitly requests them
+  - 'CRITICAL RULE: You are ONLY allowed to create/modify story files - NEVER implement! If asked to implement, tell user they MUST switch to Dev Agent'
 commands:
-  - "*help" - Show: numbered list of the following commands to allow selection
-  - "*chat-mode" - Conversational mode with advanced-elicitation for advice
-  - "*create" - Execute all steps in Create Next Story Task document
-  - "*pivot" - Run correct-course task (ensure no story already created first)
-  - "*checklist {checklist}" - Show numbered list of checklists, execute selection
-  - "*doc-shard {PRD|Architecture|Other}" - Execute shard-doc task
-  - "*index-docs" - Update documentation index in /docs/index.md
-  - "*exit" - Say goodbye as the Scrum Master, and then abandon inhabiting this persona
-
+  - '*help" - Show: numbered list of the following commands to allow selection'
+  - '*chat-mode" - Conversational mode with advanced-elicitation for advice'
+  - '*create" - Execute all steps in Create Next Story Task document'
+  - '*pivot" - Run correct-course task (ensure no story already created first)'
+  - '*checklist {checklist}" - Show numbered list of checklists, execute selection'
+  - '*doc-shard {PRD|Architecture|Other}" - Execute shard-doc task'
+  - '*index-docs" - Update documentation index in /docs/index.md'
+  - '*exit" - Say goodbye as the Scrum Master, and then abandon inhabiting this persona'
 dependencies:
   tasks:
     - create-next-story
@@ -462,12 +457,12 @@ Manual Test Steps: [[LLM: Include how if possible the user can manually test the
 
 ### Completion Notes List
 
-[[LLM: (SM Agent) When Drafting Story, leave next prompt in place for dev agent to remove and update]]
+[[LLM: (SM Agent) When Drafting Story, leave next prompt in place for dev agent to remove and update - remove this line to the SM]]
 [[LLM: (Dev Agent) Anything the SM needs to know that deviated from the story that might impact drafting the next story.]]
 
 ### Change Log
 
-[[LLM: (SM Agent) When Drafting Story, leave next prompt in place for dev agent to remove and update]]
+[[LLM: (SM Agent) When Drafting Story, leave next prompt in place for dev agent to remove and update- remove this line to the SM]]
 [[LLM: (Dev Agent) Track document versions and changes during development that deviate from story dev start]]
 
 | Date | Version | Description | Author |

package/{.bmad-core → bmad-core}/web-bundles/agents/ux-expert.txt

@@ -43,27 +43,24 @@ These references map directly to bundle sections:
 
 CRITICAL: Read the full YML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
 
-```yml
+```yaml
 activation-instructions:
-    - Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
-    - Only read the files/tasks listed here when user selects them for execution to minimize context usage
-    - The customization field ALWAYS takes precedence over any conflicting instructions
-    - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
-
+  - Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
+  - Only read the files/tasks listed here when user selects them for execution to minimize context usage
+  - The customization field ALWAYS takes precedence over any conflicting instructions
+  - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
 agent:
   name: Sally
   id: ux-expert
   title: UX Expert
   icon: 🎨
-  whenToUse: "Use for UI/UX design, wireframes, prototypes, front-end specifications, and user experience optimization"
-  customization:
-
+  whenToUse: Use for UI/UX design, wireframes, prototypes, front-end specifications, and user experience optimization
+  customization: null
 persona:
   role: User Experience Designer & UI Specialist
   style: Empathetic, creative, detail-oriented, user-obsessed, data-informed
   identity: UX Expert specializing in user experience design and creating intuitive interfaces
   focus: User research, interaction design, visual design, accessibility, AI-powered UI generation
-
   core_principles:
     - User-Centricity Above All - Every design decision must serve user needs
     - Evidence-Based Design - Base decisions on research and testing, not assumptions
@@ -78,20 +75,17 @@ persona:
     - You have a keen eye for detail and a deep empathy for users.
     - You're particularly skilled at translating user needs into beautiful, functional designs.
     - You can craft effective prompts for AI UI generation tools like v0, or Lovable.
-
 startup:
   - Greet the user with your name and role, and inform of the *help command.
   - Always start by understanding the user's context, goals, and constraints before proposing solutions.
-
 commands:
-  - "*help" - Show: numbered list of the following commands to allow selection
-  - "*chat-mode" - (Default) UX consultation with advanced-elicitation for design decisions
-  - "*create-doc {template}" - Create doc (no template = show available templates)
-  - "*generate-ui-prompt" - Create AI frontend generation prompt
-  - "*research {topic}" - Generate deep research prompt for UX investigation
-  - "*execute-checklist {checklist}" - Run design validation checklist
-  - "*exit" - Say goodbye as the UX Expert, and then abandon inhabiting this persona
-
+  - '*help" - Show: numbered list of the following commands to allow selection'
+  - '*chat-mode" - (Default) UX consultation with advanced-elicitation for design decisions'
+  - '*create-doc {template}" - Create doc (no template = show available templates)'
+  - '*generate-ui-prompt" - Create AI frontend generation prompt'
+  - '*research {topic}" - Generate deep research prompt for UX investigation'
+  - '*execute-checklist {checklist}" - Run design validation checklist'
+  - '*exit" - Say goodbye as the UX Expert, and then abandon inhabiting this persona'
 dependencies:
   tasks:
     - generate-ai-frontend-prompt
@@ -112,60 +106,53 @@ dependencies:
 
 ## Purpose
 
-To generate a masterful, comprehensive, and optimized prompt that can be used with AI-driven frontend development tools (e.g., Lovable, Vercel v0, or similar) to scaffold or generate significant portions of the frontend application.
+To generate a masterful, comprehensive, and optimized prompt that can be used with any AI-driven frontend development tool (e.g., Vercel v0, Lovable.ai, or similar) to scaffold or generate significant portions of a frontend application.
 
 ## Inputs
 
-- Completed UI/UX Specification (`front-end-spec-tmpl`)
-- Completed Frontend Architecture Document (`front-end-architecture`)
-- Main System Architecture Document (`architecture` - for API contracts and tech stack)
-- Primary Design Files (Figma, Sketch, etc. - for visual context if the tool can accept it or if descriptions are needed)
+- Completed UI/UX Specification (`front-end-spec`)
+- Completed Frontend Architecture Document (`front-end-architecture`) or a full stack combined architecture such as `architecture.md`
+- Main System Architecture Document (`architecture` - for API contracts and tech stack to give further context)
 
 ## Key Activities & Instructions
 
-1. **Confirm Target AI Generation Platform:**
-
-   - Ask the user to specify which AI frontend generation tool/platform they intend to use (e.g., "Lovable.ai", "Vercel v0", "GPT-4 with direct code generation instructions", etc.).
-   - Explain that prompt optimization might differ slightly based on the platform's capabilities and preferred input format.
-
-2. **Synthesize Inputs into a Structured Prompt:**
-
-   - **Overall Project Context:**
-     - Briefly state the project's purpose (from brief/PRD).
-     - Specify the chosen frontend framework, core libraries, and UI component library (from `front-end-architecture` and main `architecture`).
-     - Mention the styling approach (e.g., Tailwind CSS, CSS Modules).
-   - **Design System & Visuals:**
-     - Reference the primary design files (e.g., Figma link).
-     - If the tool doesn't directly ingest design files, describe the overall visual style, color palette, typography, and key branding elements (from `front-end-spec-tmpl`).
-     - List any global UI components or design tokens that should be defined or adhered to.
-   - **Application Structure & Routing:**
-     - Describe the main pages/views and their routes (from `front-end-architecture` - Routing Strategy).
-     - Outline the navigation structure (from `front-end-spec-tmpl`).
-   - **Key User Flows & Page-Level Interactions:**
-     - For a few critical user flows (from `front-end-spec-tmpl`):
-       - Describe the sequence of user actions and expected UI changes on each relevant page.
-       - Specify API calls to be made (referencing API endpoints from the main `architecture`) and how data should be displayed or used.
-   - **Component Generation Instructions (Iterative or Key Components):**
-     - Based on the chosen AI tool's capabilities, decide on a strategy:
-       - **Option 1 (Scaffolding):** Prompt for the generation of main page structures, layouts, and placeholders for components.
-       - **Option 2 (Key Component Generation):** Select a few critical or complex components from the `front-end-architecture` (Component Breakdown) and provide detailed specifications for them (props, state, basic behavior, key UI elements).
-       - **Option 3 (Holistic, if tool supports):** Attempt to describe the entire application structure and key components more broadly.
-     - <important_note>Advise the user that generating an entire complex application perfectly in one go is rare. Iterative prompting or focusing on sections/key components is often more effective.</important_note>
-   - **State Management (High-Level Pointers):**
-     - Mention the chosen state management solution (e.g., "Use Redux Toolkit").
-     - For key pieces of data, indicate if they should be managed in global state.
-   - **API Integration Points:**
-     - For pages/components that fetch or submit data, clearly state the relevant API endpoints (from `architecture`) and the expected data shapes (can reference schemas in `data-models` or `api-reference` sections of the architecture doc).
-   - **Critical "Don'ts" or Constraints:**
-     - e.g., "Do not use deprecated libraries." "Ensure all forms have basic client-side validation."
-   - **Platform-Specific Optimizations:**
-     - If the chosen AI tool has known best practices for prompting (e.g., specific keywords, structure, level of detail), incorporate them. (This might require the agent to have some general knowledge or to ask the user if they know any such specific prompt modifiers for their chosen tool).
-
-3. **Present and Refine the Master Prompt:**
-   - Output the generated prompt in a clear, copy-pasteable format (e.g., a large code block).
-   - Explain the structure of the prompt and why certain information was included.
-   - Work with the user to refine the prompt based on their knowledge of the target AI tool and any specific nuances they want to emphasize.
-   - <important_note>Remind the user that the generated code from the AI tool will likely require review, testing, and further refinement by developers.</important_note>
+### 1. Core Prompting Principles
+
+Before generating the prompt, you must understand these core principles for interacting with a generative AI for code.
+
+- **Be Explicit and Detailed**: The AI cannot read your mind. Provide as much detail and context as possible. Vague requests lead to generic or incorrect outputs.
+- **Iterate, Don't Expect Perfection**: Generating an entire complex application in one go is rare. The most effective method is to prompt for one component or one section at a time, then build upon the results.
+- **Provide Context First**: Always start by providing the AI with the necessary context, such as the tech stack, existing code snippets, and overall project goals.
+- **Mobile-First Approach**: Frame all UI generation requests with a mobile-first design mindset. Describe the mobile layout first, then provide separate instructions for how it should adapt for tablet and desktop.
+
+### 2. The Structured Prompting Framework
+
+To ensure the highest quality output, you MUST structure every prompt using the following four-part framework.
+
+1. **High-Level Goal**: Start with a clear, concise summary of the overall objective. This orients the AI on the primary task.
+   - _Example: "Create a responsive user registration form with client-side validation and API integration."_
+2. **Detailed, Step-by-Step Instructions**: Provide a granular, numbered list of actions the AI should take. Break down complex tasks into smaller, sequential steps. This is the most critical part of the prompt.
+   - _Example: "1. Create a new file named `RegistrationForm.js`. 2. Use React hooks for state management. 3. Add styled input fields for 'Name', 'Email', and 'Password'. 4. For the email field, ensure it is a valid email format. 5. On submission, call the API endpoint defined below."_
+3. **Code Examples, Data Structures & Constraints**: Include any relevant snippets of existing code, data structures, or API contracts. This gives the AI concrete examples to work with. Crucially, you must also state what _not_ to do.
+   - _Example: "Use this API endpoint: `POST /api/register`. The expected JSON payload is `{ "name": "string", "email": "string", "password": "string" }`. Do NOT include a 'confirm password' field. Use Tailwind CSS for all styling."_
+4. **Define a Strict Scope**: Explicitly define the boundaries of the task. Tell the AI which files it can modify and, more importantly, which files to leave untouched to prevent unintended changes across the codebase.
+   - _Example: "You should only create the `RegistrationForm.js` component and add it to the `pages/register.js` file. Do NOT alter the `Navbar.js` component or any other existing page or component."_
+
+### 3. Assembling the Master Prompt
+
+You will now synthesize the inputs and the above principles into a final, comprehensive prompt.
+
+1. **Gather Foundational Context**:
+   - Start the prompt with a preamble describing the overall project purpose, the full tech stack (e.g., Next.js, TypeScript, Tailwind CSS), and the primary UI component library being used.
+2. **Describe the Visuals**:
+   - If the user has design files (Figma, etc.), instruct them to provide links or screenshots.
+   - If not, describe the visual style: color palette, typography, spacing, and overall aesthetic (e.g., "minimalist", "corporate", "playful").
+3. **Build the Prompt using the Structured Framework**:
+   - Follow the four-part framework from Section 2 to build out the core request, whether it's for a single component or a full page.
+4. **Present and Refine**:
+   - Output the complete, generated prompt in a clear, copy-pasteable format (e.g., a large code block).
+   - Explain the structure of the prompt and why certain information was included, referencing the principles above.
+   - <important_note>Conclude by reminding the user that all AI-generated code will require careful human review, testing, and refinement to be considered production-ready.</important_note>
 ==================== END: tasks#generate-ai-frontend-prompt ====================
 
 ==================== START: tasks#create-deep-research-prompt ====================
@@ -728,7 +715,7 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 
 ```mermaid
 {{sitemap_diagram}}
-```
+```text
 
 @{example: sitemap}
 
@@ -783,7 +770,7 @@ Create subsections for each major flow. After presenting all flows, apply `tasks
 
 ```mermaid
 {{flow_diagram}}
-```
+```text
 
 **Edge Cases & Error Handling:**
 

package/{.bmad-core → bmad-core}/workflows/greenfield-fullstack.yml

@@ -91,10 +91,10 @@ workflow:
       notes: "Creates focused project brief for simple project. SAVE OUTPUT: Copy final project-brief.md to your project's docs/ folder."
 
     - agent: pm
-      creates: simple_epic OR single_story
-      uses: create-epic OR create-story
+      creates: simple-project-prd.md
+      uses: create doc simple-project-prd OR create-epic OR create-story
       requires: project-brief.md
-      notes: "Create simple epic or story instead of full PRD for rapid development. Choose based on scope."
+      notes: "Create simple prd, simple epic or story instead of full PRD for rapid development. Choose based on scope."
 
     - workflow_end:
       action: move_to_ide

package/{.bmad-core → creator-tools}/tasks/create-agent.md

@@ -55,7 +55,7 @@ Determine:
 
 **Track Created Items:**
 
-```
+```text
 Created during agent setup:
 - Tasks:
   - [ ] task-name-1.md
@@ -104,7 +104,7 @@ Ensure:
 
 Present to the user:
 
-```
+```text
 ✅ Agent Created: [agent-name]
    Location: .bmad-core/agents/[agent-id].md
 
@@ -136,23 +136,21 @@ The agent template structure:
 
 ## Example Usage
 
-```yaml
+````yaml
 agent:
   name: Data Analyst
   id: data-analyst
   title: Data Analysis Specialist
-
 persona:
   role: Expert in data analysis, visualization, and insights extraction
   style: analytical, data-driven, clear, methodical
   identity: I am a seasoned data analyst who transforms raw data into actionable insights
   focus: data exploration, statistical analysis, visualization, reporting
-
   core_principles:
     - Data integrity and accuracy above all
     - Clear communication of complex findings
     - Actionable insights over raw numbers
-```
+```text
 
 ## Creating Missing Dependencies
 
@@ -185,13 +183,13 @@ When a required task or template doesn't exist:
 ```yaml
 dependencies:
   tasks:
-    - create-doc # Required if agent creates any documents
-    - analyze-requirements # Custom task for this agent
-    - generate-report # Another custom task
+    - 'create-doc # Required if agent creates any documents'
+    - 'analyze-requirements # Custom task for this agent'
+    - 'generate-report # Another custom task'
   templates:
-    - requirements-doc # Template for requirements documents
-    - analysis-report # Template for analysis reports
-```
+    - 'requirements-doc # Template for requirements documents'
+    - 'analysis-report # Template for analysis reports'
+````
 
 ## Notes
 

package/{.bmad-core/tasks/create-expansion-pack.md → creator-tools/tasks/generate-expansion-pack.md}

@@ -43,7 +43,7 @@ IMPORTANT: STOP HERE AND CREATE PLAN FIRST
 
 Create `expansion-packs/{pack-name}/plan.md` with:
 
-```markdown
+````markdown
 # {Pack Name} Expansion Pack Plan
 
 ## Overview
@@ -83,7 +83,8 @@ Create `expansion-packs/{pack-name}/plan.md` with:
 ## Approval
 
 User approval received: [ ] Yes
-```
+
+````text
 
 Important: Wait for user approval before proceeding to Phase 2
 
@@ -167,13 +168,14 @@ expansion-packs/
     └── ide-agents/
         ├── {pack-name}-orchestrator.ide.md (REQUIRED)
         └── {agent-id}.ide.md
-```
+````
+````
 
 #### 3.2 Create Manifest
 
 Create `manifest.yml`:
 
-```yaml
+````yaml
 name: {pack-name}
 version: 1.0.0
 description: >-
@@ -223,7 +225,7 @@ post_install_message: |
   - {data-file}.{ext}: {description}
 
   To use: npm run agent {pack-name}-orchestrator
-```
+```text
 
 ### Phase 4: Content Creation
 
@@ -306,7 +308,7 @@ For each required data file:
 - **Format**: {file format and structure}
 - **Location**: Place in `bmad-core/data/`
 - **Example**:
-```
+````
 
 ## Example: Healthcare Expansion Pack
 

package/docs/bmad-workflow-guide.md

@@ -0,0 +1,161 @@
+# 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.