Roo Code, The Cline Fork With Modes And Custom Agents
Roo's mode-switching workflow versus stock Cline, my read after a week running both
Roo Code (formerly Roo Cline) is the most active fork of Cline. The team kept the agent loop and added a mode-switching layer that lets you flip between Code, Architect, Ask, and Debug agents without switching extensions. I ran Roo on my Linux box for a week against the same projects I had been using stock Cline on. This is what I learned, and the projects where each is the better pick.
What you'll build
Roo Code installed in VS Code, signed in with an Anthropic API key, with a custom mode (a "Reviewer" agent) added on top of the stock four. Roughly 15 minutes.
Caption: Roo's mode picker, four stock modes plus my custom Reviewer.
Prerequisites
- VS Code 1.95+ on Linux, Mac, or Windows
- An Anthropic API key (Roo also supports OpenAI, Ollama, and OpenRouter)
- A project to test against
- 8GB RAM (16GB if you also run Ollama for the local model path)
If you are coming from stock Cline, you can run both side by side; the extensions do not conflict.
Step 1, install Roo
In VS Code, open Extensions (Ctrl+Shift+X), search "Roo Code", install. The official one is RooVeterinaryInc.roo-cline.
The activity-bar icon is a kangaroo. Click it; the Roo panel opens with a model-provider prompt.
Step 2, configure the model
In Roo's settings panel, choose Anthropic as the provider, paste your API key, pick claude-sonnet-4-6 as the default model.
For the inline tools (autocomplete, tab-suggest), Roo uses the same model by default. You can override in settings if you want a faster model for inline.
Step 3, explore the four stock modes
Roo ships with four modes:
- Code: edits files (the default Cline behaviour)
- Architect: plans without editing, useful for big-picture decisions
- Ask: read-only Q&A about the code, no edits
- Debug: runs and reads errors, doesn't write fixes unless you confirm
Switch modes via the panel dropdown.
I find Architect the most useful addition; it gives you a plan you can refine before any code is touched.
Step 4, write a custom mode
The custom-mode story is where Roo extends past Cline. Open Roo settings → Modes → New, define a Reviewer mode:
name: Reviewer
description: Reviews diffs without editing, focused on bugs and security
system_prompt: |
You are a senior code reviewer. Read the staged diff and give:
1. A list of concrete bugs with line numbers.
2. Security concerns (SQL injection, secret leaks, race conditions).
3. Style nits (one section, optional).
Do not edit the files. Output as a markdown report.
permissions:
- read_file
- run_command # for git diff
Save. The new mode shows up in the dropdown alongside the four stock ones.
Step 5, run the Reviewer mode
Stage some changes (git add -p), open Roo, switch to Reviewer mode, prompt:
> review the staged diff for bugs and security issues
Roo runs git diff --cached, reads the output, returns a structured review without touching any files.
First run
A typical mixed session for me:
[Architect mode]
You: I want to add streaming responses to my FastAPI Claude wrapper
Roo: Plan:
1. Switch endpoint from POST to GET with SSE
2. Use StreamingResponse from FastAPI
3. Iterate over the Anthropic stream object
4. Handle disconnect cleanly
[I review the plan, agree]
[Switch to Code mode]
You: implement that plan against src/api/chat.py
Roo: [edits the file with the plan as guide]
[shows diff, I approve]
[Switch to Reviewer mode]
You: review my staged change
Roo: [reads diff, returns review with one bug found]
The mode switch keeps the conversation context; you do not lose history when switching.
What broke for me
Two issues. First, the custom-mode YAML schema is undocumented in the visible UI. I had to read the Roo source to figure out which fields the parser accepts. The settings UI accepts the YAML but silently drops fields it does not recognise. The fix is checking the Roo logs in ~/.config/Code/logs/ after saving a custom mode; any dropped fields show up as warnings.
Second, Roo's tool-permission model is per-mode but not per-project. A custom mode that allows run_command allows it everywhere, including in projects where you would rather it did not. There is no per-project override. I worked around this by keeping run_command only on modes I trust, and using the Ask-mode for any project where I do not want shell execution.
What it costs
| Item | Cost |
|---|---|
| VS Code | Free |
| Roo Code | Free (Apache 2.0) |
| Anthropic API | $3/M input + $15/M output (Sonnet 4.6) |
| OpenRouter (alt) | Marginal markup over direct API |
| Local Ollama (alt) | Free |
A normal Roo session is comparable to Cline on cost. The custom-mode and Architect-first workflow does not change the API spend meaningfully.
When NOT to use this
Skip Roo if you only want the stock Cline behaviour. The maintainer overhead of two similar extensions is real; pick one.
Skip if you do not need custom modes. The four stock modes are useful but if Code mode covers your work, the upgrade does not justify the switch from Cline.
Indian operator angle
The Architect mode is the underrated win for Indian dev shops doing client work. Many gigs need a written plan before any code is touched (the client wants a deliverable before kickoff). Architect mode produces exactly that, in a format you can paste into a doc and send. It saved me a half-hour of write-up on the last small client project I did.
Forex billing is the same as the other Anthropic API paths. The Roo extension itself is free and Apache-licensed; for an Indian startup wanting to ship an internal coding-assistant fork, Roo is a cleaner base than stock Cline because the mode system gives you somewhere to add company-specific guardrails.
Related
More AI Coding
Building a Custom MCP Server in Python: Claude Reaches My Stack
Claude Code is sharp until it hits the edge of your machine and your private tools. I wrote three small MCP servers in Python to close that gap. Here is the real pattern, the real gotcha that bit me, and what it costs.
Claude Code Subagents in Practice: Fork Flag, Cache Leak, Worktree Trap
Fanning out subagents in Claude Code looks free until you hit the cap or your forks clobber each other's commits. These are the real fixes I learned running fanouts: the fork env flag that shares the parent's cache, the WebFetch cache leak, and the worktree pattern for parallel writers.
I Gave My AI Agents a Memory With SQLite FTS5 (No Vector DB)
Most agent-memory setups reach for Pinecone or pgvector by reflex. I put 2000+ markdown files behind SQLite FTS5 with BM25 ranking, and my agents now answer their own 'who is X' questions in under a second for zero tokens. Here is the schema, the query, and the one place lexical search loses.