Roo Commander

Roo Commander integrates with Roo Code by adding an entry to your .roomodes file.

When running roo-commander init, the tool performs a merge operation rather than an overwrite. This ensures that if you have existing custom modes defined in your .roomodes file, they are preserved while the Roo Commander mode is appended. If the .roomodes file does not exist, the tool creates a new one containing only the Roo Commander entry.

When planning features, Roo Commander follows a consistent layered breakdown to ensure stability and testability. A typical feature is split into these four phases:

1. Phase A: Data Layer: Database schema changes, migrations, and data access functions.
2. Phase B: API Layer: Route handlers, validation, and business logic.
3. Phase C: UI Layer: Components, state management, and user interactions.
4. Phase D: Integration: Connecting the UI to the API, testing, and error handling.

Roo Commander orchestrates projects through a structured lifecycle. Instead of jumping straight to coding, the system encourages moving through distinct stages to ensure feasibility, planning, and safe execution. Understanding these stages helps you know which command to use at any given time.

The 7 Stages:

1. EXPLORATION (/explore-idea): Researching tech stacks and validating ideas.
2. PLANNING (/plan-project): Creating roadmaps and implementation phases for new projects.
3. EXECUTION: Working through the planned phases (technical implementation).
4. WRAP (/wrap-session): Checkpointing progress and saving state.
5. RESUME (/continue-session): Loading context from a previous session.
6. FEATURE (/plan-feature): Planning new additions to an existing project.
7. RELEASE (/release): Running safety checks before deployment.

Roo Commander operates by analyzing user requests and delegating to specialized modes. When delegating, the command must include a structured message to ensure the worker mode has the necessary context, as modes do not inherit parent context.

Delegation Message Pattern:

Task: [description]

Before implementing, check skill: run `roo-commander read <skill-name>`

Context: [details]

Expected: [deliverables]

Mode Selection Logic:

• Code mode: For implementation tasks, file creation, or editing.
• Architect mode: For planning, high-level design, or reviews.
• Debug mode: For troubleshooting and fixing errors.

Roo Commander operates as a lightweight orchestrator mode rather than an execution mode. It uses a three-part system to bridge Claude Code skills into Roo Code:

1. The CLI Tool: Provides access to skills stored in ~/.claude/skills/.
2. Custom Instructions: Files in .roo/rules/ (like 01-skills-index.md) make all Roo modes (Code, Architect, Debug) aware of available skills.
3. Roo Commander Mode: A specialized mode that analyzes user requests, matches them to skills via the index, and delegates the actual work to built-in execution modes (Code, Architect, or Debug).

Delegation Pattern: Instead of writing code, the Roo Commander mode sends a message to a Code mode like: "Load skill: roo-commander read <skill-name>, then implement <task>".

Roo Commander is a lightweight orchestrator mode designed to make your Roo Code AI agent skill-aware.

Mental Model

Instead of performing direct file edits, Roo Commander acts as a high-level planner that:

1. Analyzes your request.
2. Discovers relevant production-tested skills by checking the .roo/rules/01-skills-index.md.
3. Delegates the actual implementation to specialized modes (Code, Architect, or Debug) along with specific instructions on which skills to load.

When to use it

• Starting new features (utilizes auto skill discovery).
• Complex multi-step workflows.
• When you are unsure which specific skill is required.

When to bypass it

• For simple edits (use Code mode directly).
• When you already know the specific skill needed (load it manually using /load-skill).

Roo Commander includes 9 slash commands designed to assist with workflows.

Important Mental Model: Slash commands are instruction templates, not full automation. They provide structured, proven workflows and instruction sets to help you execute tasks, but they are not intended to replace heavy automation tools like Claude Code. They are designed to work in a hybrid workflow alongside Roo Code.

Use skills to leverage production-tested patterns and prevent common errors. Skills are significantly more token-efficient than web searching and trial-and-error.

Use Skills when:

• Setting up specific technologies (Cloudflare, Tailwind, OpenAI, Clerk, etc.).
• Implementing common patterns (authentication, databases, chat UIs, forms).
• Handling production-critical code (security, payments).

Skip Skills (Manual Implementation) when:

• Performing trivial tasks (renaming variables, adding comments, formatting code).
• Creating simple utilities (< 20 lines).
• Implementing highly specific project-specific business logic or unique algorithms.

The skills index (.roo/rules/01-skills-index.md) is formatted for compatibility with the Roo Code markdown parser. It follows this structure:

• Categories: Organized by domain using H2 (##) headers and emojis (e.g., ## 🤖 AI & LLM).
• Skill Entries: Bulleted lists where each entry follows the pattern: - **skill-name**: Description [Keywords: keyword1, keyword2].
• Usage Instructions: A section at the bottom of the file providing guidance on how to interact with skills via the CLI.

Example entry format: - **cloudflare-d1**: Cloudflare D1 database driver [Keywords: database, sql, d1]