BMAD-METHOD/docs/commands/quick-reference.md

Commands Quick Reference

Complete reference for all BMad Method commands with contextual usage guidance and real-world scenarios.

!!! tip "Interactive Help" Type /help in any BMad session to get context-aware command suggestions and usage examples.

Core Commands

Orchestrator Commands

Command	Description	When to Use	Example
/help	Show available commands and context-aware suggestions	When starting a session or unsure about next steps	/help
/agents	List all available personas with descriptions	When choosing which persona to activate	/agents
/context	Display current session context and memory insights	Before switching personas or when resuming work	/context
/yolo	Toggle YOLO mode for comprehensive execution	When you want full automation vs step-by-step control	/yolo
/core-dump	Execute enhanced core-dump with memory integration	When debugging issues or need complete system status	/core-dump
/exit	Abandon current agent with memory preservation	When finished with current persona or switching contexts	/exit

Agent Switching Commands

Command	Description	Best Used For	Typical Workflow Position
/pm	Switch to Product Manager (Jack)	Requirements, strategy, stakeholder alignment	Project start, major decisions
/architect	Switch to Architect (Mo)	Technical design, system architecture	After requirements, before development
/dev	Switch to Developer (Alex)	Implementation, coding, debugging	During active development phases
/po	Switch to Product Owner (Sam)	Backlog management, user stories	Sprint planning, story refinement
/sm	Switch to Scrum Master (Taylor)	Process improvement, team facilitation	Throughout project, retrospectives
/analyst	Switch to Business Analyst (Jordan)	Research, analysis, requirements gathering	Project initiation, discovery phases
/design	Switch to Design Architect (Casey)	UI/UX design, user experience	After requirements, parallel with architecture
/quality	Switch to Quality Enforcer (Riley)	Quality assurance, standards enforcement	Throughout development, reviews

Memory-Enhanced Commands

Command	Description	Usage Context	Impact
/remember {content}	Manually add important information to memory	After making key decisions or discoveries	Improves future recommendations
/recall {query}	Search memories with natural language queries	When you need to remember past decisions or patterns	Provides historical context
/udtm	Execute Ultra-Deep Thinking Mode	For major decisions requiring comprehensive analysis	Provides systematic analysis
/anti-pattern-check	Scan for anti-patterns	During development and review phases	Identifies problematic code patterns
/suggest	AI-powered next step recommendations	When stuck or want validation of next steps	Provides contextual guidance
/handoff {persona}	Structured persona transition with memory briefing	When switching personas mid-task	Ensures continuity
/bootstrap-memory	Initialize memory for brownfield projects	When starting work on existing projects	Builds historical context
/quality-gate {phase}	Run quality gate validation	At key project milestones	Ensures quality standards
/brotherhood-review	Initiate peer validation process	Before major decisions or deliverables	Enables collaborative validation
/checklist {name}	Run validation checklist	To ensure completeness and quality	Systematic validation

Contextual Usage Scenarios

Scenario 1: Starting a New Project

Context: You've just created a new project directory and want to begin using BMad Method.

Before: Unclear where to start, no structure or guidance

Project created but no clear next steps
Need to understand requirements and approach
Unsure which persona to use first

Command Sequence:

/help                    # Get oriented
/context                 # Check current state
/agents                  # See available personas
/analyst                 # Start with analysis

After: Clear project structure and analysis begun

BMad Method activated with proper context
Business analysis persona engaged
Requirements gathering process initiated
Clear next steps identified

Scenario 2: Switching from Planning to Development

Context: You've completed requirements and architecture, ready to start coding.

Before: Architecture complete but need to transition to implementation

Technical design finalized
Development environment needs setup
Need to switch from design thinking to implementation
Ready to begin coding phase

Command Sequence:

/context                 # Review current state
/remember "Architecture approved: microservices with React frontend"
/handoff dev            # Structured transition to developer
/insights               # Get development-specific guidance

After: Smooth transition to development phase

Developer persona activated with full context
Architecture decisions remembered for reference
Development-specific recommendations provided
Implementation phase ready to begin

Scenario 3: Quality Review Process

Context: Development phase complete, need quality validation before deployment.

Before: Code written but quality unknown

Features implemented but not validated
Need comprehensive quality assessment
Potential issues not identified
Deployment readiness uncertain

Command Sequence:

/quality                 # Switch to quality enforcer
/consult quality-assessment  # Multi-persona quality review
/patterns               # Check for known quality issues
/consensus-check        # Validate team agreement

After: Comprehensive quality validation complete

Quality standards validated
Multi-persona review completed
Known issues identified and addressed
Deployment confidence established

Scenario 4: Emergency Response

Context: Production issue detected, need immediate response and resolution.

Before: Critical issue affecting users

Production system experiencing problems
Root cause unknown
Need rapid response and coordination
Multiple stakeholders need updates

Command Sequence:

/diagnose               # Quick system health check
/consult emergency-response  # Activate emergency team
/remember "Production issue: API timeout starting 10:30 AM"
/suggest                # Get immediate action recommendations

After: Coordinated emergency response in progress

Emergency team assembled and coordinated
Root cause analysis initiated
Stakeholders informed and aligned
Action plan with immediate steps identified

Command Combinations & Workflows

Common Command Patterns

1. Project Kickoff Pattern

# Discovery and Analysis
/context → /insights → /analyst → /remember → /pm

# Strategic Planning  
/pm → /recall → /handoff architect → /remember

# Technical Foundation
/architect → /handoff design → /consult design-review

2. Development Cycle Pattern

# Sprint Planning
/po → /recall → /handoff sm → /dev

# Implementation
/dev → /remember → /quality → /patterns

# Review and Integration  
/consult technical-feasibility → /consensus-check → /learn

3. Quality Assurance Pattern

# Initial Quality Check
/quality → /diagnose → /patterns

# Comprehensive Review
/consult quality-assessment → /recall → /insights

# Validation and Learning
/consensus-check → /remember → /learn

4. Problem Resolution Pattern

# Issue Identification
/diagnose → /context → /recall

# Solution Development
/consult emergency-response → /suggest → /remember

# Implementation and Learning
/dev → /quality → /learn

Persona-Specific Command Recommendations

🎯 Product Manager (Jack) Context

Primary Commands: /recall, /remember, /insights, /handoff

Typical Workflow:

/recall "previous market research"     # Check past insights
/insights                             # Get market-driven recommendations  
/remember "stakeholder feedback: prefers mobile-first"
/handoff architect                    # Transition to technical design

Best Practices:

• Always /recall relevant market research before major decisions
• Use /remember to capture stakeholder feedback immediately
• /insights provides market-driven recommendations
• /handoff architect when transitioning from strategy to technical design

🏗️ Architect (Mo) Context

Primary Commands: /context, /recall, /consult, /remember

Typical Workflow:

/context                              # Understand requirements context
/recall "architecture decisions"      # Review past technical choices
/consult technical-feasibility        # Validate with team
/remember "Decision: PostgreSQL for data consistency requirements"

Best Practices:

• Start with /context to understand business requirements
• Use /recall to learn from previous architectural decisions
• /consult technical-feasibility for complex technical decisions
• Document all major decisions with /remember

💻 Developer (Alex) Context

Primary Commands: /patterns, /quality, /recall, /suggest

Typical Workflow:

/recall "coding standards"            # Check established patterns
/patterns                            # Identify potential issues
/quality                             # Run quality checks
/suggest                             # Get implementation guidance

Best Practices:

• Use /patterns to identify anti-patterns early
• Regular /quality checks throughout development
• /recall coding standards and architecture decisions
• /suggest when stuck on implementation approaches

📊 Business Analyst (Jordan) Context

Primary Commands: /insights, /remember, /recall, /handoff

Typical Workflow:

/insights                            # Get analysis-driven recommendations
/remember "User feedback: wants simpler navigation"
/recall "previous user research"      # Build on past analysis
/handoff pm                          # Transition to product strategy

Best Practices:

• Use /insights to surface data-driven recommendations
• Capture all user feedback with /remember
• Build on previous analysis with /recall
• Transition findings to product strategy with /handoff pm

Advanced Command Usage

Memory-Driven Development

Pattern: Leveraging memory for continuous improvement

# Before starting any major task
/context                             # Understand current state
/recall "similar projects"           # Learn from past experience
/insights                           # Get proactive recommendations

# During work
/remember "Decision rationale: chose React for team familiarity"
/patterns                           # Check for emerging issues

# After completion
/learn                              # Update system intelligence

Multi-Persona Collaboration

Pattern: Coordinating complex decisions across personas

# Initiate collaboration
/consult design-review              # Bring together relevant personas

# During consultation
/context                           # Ensure shared understanding
/recall "previous design decisions" # Leverage institutional knowledge
/consensus-check                   # Validate agreement

# After consultation
/remember "Design decision: mobile-first approach approved by all personas"

Emergency Response Coordination

Pattern: Rapid response to critical issues

# Immediate assessment
/diagnose                          # Quick system health check
/consult emergency-response        # Assemble response team

# Coordinated action
/suggest                           # Get immediate recommendations
/remember "Issue timeline and actions taken"

# Resolution and learning
/learn                             # Update system for future prevention

Tips & Best Practices

🎯 Persona Selection Strategy

!!! success "Start Right" - New projects: Begin with /analyst for requirements discovery - Technical challenges: Use /architect for system design - Implementation: Switch to /dev for coding tasks - Quality concerns: Engage /quality for validation

🧠 Memory Usage Patterns

!!! tip "Memory Best Practices" - Use /remember immediately after important decisions - Start complex sessions with /recall to get context - Use /insights when you want proactive guidance - Run /patterns regularly to identify improvement opportunities

⚡ Workflow Optimization

!!! warning "Common Mistakes" - Don't skip /context when switching personas mid-task - Don't forget /remember for important decisions - Don't ignore /patterns warnings about potential issues - Don't use /yolo mode without understanding implications

🤝 Collaboration Commands

!!! note "Team Coordination" - Use /consult for decisions requiring multiple perspectives - Always /handoff when transferring work between personas - Run /consensus-check before major commitments - Use /diagnose for systematic problem assessment

Context-Aware Help Examples

When You're Stuck

Scenario: Mid-development, unsure about next steps

/suggest                           # Get AI-powered recommendations
/patterns                         # Check for potential blockers
/recall "similar implementation"   # Learn from past experience
/consult technical-feasibility    # Get team input if needed

When Starting Work

Scenario: Beginning a new work session

/context                          # Understand where you left off
/recall "previous session"        # Get relevant historical context
/insights                         # Surface relevant recommendations
/help                            # Get context-specific command suggestions

When Switching Contexts

Scenario: Moving from one project phase to another

/handoff {new-persona}           # Structured transition with memory
/context                         # Confirm new context is correct
/insights                        # Get phase-specific recommendations

When Things Go Wrong

Scenario: Unexpected issues or problems

/diagnose                        # Systematic problem assessment
/patterns                        # Check for known issue patterns
/consult emergency-response      # Engage appropriate team
/remember "Issue and resolution for future reference"

Getting More Help

• In-session help: Type /help for context-aware assistance
• Persona-specific help: Each persona provides specialized guidance
• Memory search: Use /recall to find relevant past experiences
• Pattern recognition: Use /patterns to identify improvement opportunities
• Community support: GitHub Issues

---

Next Steps:

• Try your first project
• Learn about personas
• Explore workflows