RooPrompts/mode-quick-reference.md

Roo Mode Quick Reference Guide

Mode Selection Criteria

When to Use Each Mode

Mode	Use When	Key Indicators
💻 Code	Writing new code, implementing features, refactoring	"Build", "Create", "Implement", "Add feature"
❓ Ask	Seeking explanations, understanding concepts	"Explain", "What is", "How does", "Why"
🪲 Debug	Fixing bugs, resolving errors, troubleshooting	"Error", "Bug", "Not working", "Fix"
🏗️ Architect	Designing systems, planning architecture	"Design", "Architecture", "Structure", "Plan system"
🪃 Orchestrator	Managing complex multi-step projects	"Complex project", "Multiple phases", "Coordinate"
Code Reviewer	Reviewing code quality, security, best practices	"Review code", "Check quality", "Audit"
Deep Thinker	Analyzing complex problems, strategic thinking	"Analyze deeply", "Strategic", "Complex analysis"
Enhanced Planning	After 3 failed attempts or complex planning needs	Auto-triggered on failures, "Detailed plan"
Deep Research	In-depth research using web resources	"Research", "Find information", "Investigate"
QA Tester	Testing, test planning, quality assurance	"Test", "QA", "Verify", "Test plan"
Haskell God	Advanced Haskell development	"Haskell", "Functional programming", "Type system"
ReScript Master	ReScript monorepo development	"ReScript", "ReasonML", "BuckleScript"

Tool Access Permissions

Core Modes

💻 Code Mode

• ✅ All file operations (read, write, apply_diff)
• ✅ Execute commands
• ✅ Browser actions
• ✅ Search and list operations
• ✅ MCP tools (Context7, Brave Search)

❓ Ask Mode

• ✅ Read files
• ✅ Search operations
• ✅ List operations
• ❌ Write/modify files
• ❌ Execute commands
• ✅ MCP tools for research

🪲 Debug Mode

• ✅ All file operations
• ✅ Execute commands
• ✅ Browser actions for testing
• ✅ Search operations
• ✅ MCP tools for debugging

🏗️ Architect Mode

• ✅ Read files
• ✅ Write markdown files only
• ❌ Code file modifications
• ✅ Search and list operations
• ✅ MCP tools for research

Specialized Modes

🪃 Orchestrator Mode

• ✅ Mode switching
• ✅ Task delegation
• ✅ Read operations
• ✅ Write planning documents
• ❌ Direct code modifications

Code Reviewer Mode

• ✅ Read all files
• ✅ Write review.md only
• ❌ Modify code files
• ✅ Search operations
• ✅ Static analysis tools

Deep Thinker Mode

• ✅ Read operations
• ✅ Write analysis documents
• ❌ Code modifications
• ✅ Sequential Thinking MCP

Enhanced Planning Mode

• ✅ All research MCP tools
• ✅ Read operations
• ✅ Write planning documents
• ✅ Sequential Thinking MCP

Domain-Specific Modes

Deep Research Mode

• ✅ Context7 MCP (required)
• ✅ Brave Search MCP (required)
• ✅ Playwright MCP (required)
• ✅ Read operations
• ✅ Write research documents

QA Tester Mode

• ✅ All file operations
• ✅ Execute test commands
• ✅ Browser automation
• ✅ Write test files
• ✅ Testing MCP tools

Haskell God Mode

• ✅ All Haskell file operations
• ✅ Cabal/Stack commands
• ✅ GHC operations
• ✅ Advanced type system tools

ReScript Master Mode

• ✅ All ReScript file operations
• ✅ Build system commands
• ✅ Monorepo operations
• ✅ ReScript toolchain

Mode Switching Guidelines

Automatic Switching Triggers

1. To Enhanced Planning

   • After 3 failed attempts at solving an issue
   • When explicitly requested for complex planning

2. To Code Reviewer

   • When code review is explicitly requested
   • After major feature completion

3. To Debug

   • When errors are encountered during Code mode
   • When troubleshooting is needed

Manual Switching Best Practices

1. From Code → Architect

   • When implementation reveals design issues
   • Before starting major refactoring

2. From Any → Orchestrator

   • When task becomes multi-faceted
   • When coordination between modes is needed

3. From Any → Deep Research

   • When external information is needed
   • When current knowledge is insufficient

4. From Debug → Enhanced Planning

   • When debugging reveals systemic issues
   • When simple fixes aren't working

Integration Points

Mode Handoff Patterns

graph LR
    A[Architect] -->|Design Complete| C[Code]
    C -->|Errors Found| D[Debug]
    C -->|Review Needed| R[Code Reviewer]
    D -->|Complex Issue| EP[Enhanced Planning]
    EP -->|Plan Ready| C
    O[Orchestrator] -->|Delegates| A
    O -->|Delegates| C
    O -->|Delegates| QA[QA Tester]
    DR[Deep Research] -->|Info Found| A
    DR -->|Info Found| C

Context Preservation

• All modes share Memory Bank access
• Context is preserved through:
  • currentTask.md updates
  • activeContext.md maintenance
  • Mode-specific handoff notes

Best Practices for Mode Selection

1. Start with the right mode - Avoid unnecessary switching
2. Use Orchestrator for complex projects - Let it delegate
3. Trust automatic triggers - They prevent repeated failures
4. Preserve context during switches - Update Memory Bank
5. Complete mode-specific tasks - Before switching

Quick Decision Tree

Is it a multi-part complex project?
├─ Yes → Orchestrator Mode
└─ No → Continue
    │
    Is it about understanding/explaining?
    ├─ Yes → Ask Mode
    └─ No → Continue
        │
        Is it fixing an error/bug?
        ├─ Yes → Debug Mode
        └─ No → Continue
            │
            Is it system design/architecture?
            ├─ Yes → Architect Mode
            └─ No → Continue
                │
                Is it code review?
                ├─ Yes → Code Reviewer Mode
                └─ No → Continue
                    │
                    Is it deep analysis?
                    ├─ Yes → Deep Thinker Mode
                    └─ No → Continue
                        │
                        Need external research?
                        ├─ Yes → Deep Research Mode
                        └─ No → Code Mode (default)

Emergency Mode Selection

If unsure, consider:

1. Code Mode - Most versatile, good default
2. Orchestrator Mode - When complexity is high
3. Ask Mode - When clarification is needed first