Cline + Roo Code — Configuration Agentique pour VS Code

What's in this pack

You already use VS Code. You don't want to switch to Cursor, Windsurf, or a terminal-only CLI. You just want the agentic coding loop — read the repo, edit files, run commands, browse docs — to happen inside VS Code with human-in-the-loop approval.

There are exactly two extensions that do this seriously in 2026: Cline (the original, 60K+ stars) and Roo Code (a Cline fork that added per-mode specialists and boomerang orchestration, 22K+ stars). Everything else is either an inline-completion tool (Copilot, Continue's chat) or an external CLI pretending to be an extension.

This pack covers: how to pick between them, the rule files that steer their behavior, and the four MCP servers that pair well with either. Same MCP wiring works for both, so you can switch (or run both) without re-plumbing.

Who this is for: a VS Code user who wants real agentic coding (multi-step, tool-using, file-creating) without leaving the editor — and wants to make the choice once instead of trying every extension on the marketplace.

Install in this order

1. Cline — Autonomous AI Coding Agent for VS Code — Install this first as your default. Search "Cline" in the VS Code marketplace, click Install, paste an Anthropic or OpenAI API key. 60K+ stars, the largest user base, the most stable. Every action requires your approval — Cline never edits or runs without you clicking "Approve."
2. Cline — VS Code Autonomous AI Coding Extension — The MCP-config variant of the same extension. Use this entry as your reference for connecting MCP servers to Cline's settings JSON (slightly different syntax from Roo's, which we'll cover below).
3. .clinerules — Project Behavior File for Cline AI Agent — Drop a .clinerules file in your repo root before you start any real work. It's the project-memory equivalent of CLAUDE.md: tech stack, conventions, hard NOs. Cline reads it on every task. Crucially, Roo Code reads the same file — so when you try Roo later, your rules carry over for free.
4. Roo Code — AI Coding Team Inside VS Code — Install Roo as your second extension (yes, both can live in VS Code at once — they don't conflict). Roo is a Cline fork with the same core capabilities plus per-mode specialists and boomerang task orchestration. You'll want it eventually; install now so you can A/B test.
5. Roo Code — AI Coding Agent with Custom Modes — Same extension, different reference entry — covers the custom-modes UX in detail. Modes are Roo's headline feature: you define agent specialists with their own system prompts and tool whitelists.
6. Roo Code Modes — Architect, Code, Ask & Debug Agents — The four built-in Roo modes that ship out of the box. Architect plans, Code writes, Ask reads, Debug investigates. Use this entry to learn the boomerang pattern (Architect kicks off a multi-step task, hands subtasks to Code, gets results back). Cline has no equivalent — this is Roo's main differentiator.
7. AI Coding Agent Comparison 2026 — Complete Guide — The decision document. Covers Claude Code, Cursor, Codex, Gemini CLI, Cline, Roo Code, Windsurf, and Aider with feature matrices. Read it once after step 1 to confirm Cline is the right starting point, then again after step 6 to decide whether Roo earns its second slot.
8. MCP Reference Servers — Official Collection — The Anthropic-maintained baseline: filesystem, git, memory, fetch, sequential thinking. Wire these into Cline first; they're battle-tested and zero-config. Once these work, you trust the MCP pipe and can add more aggressive ones with confidence.
9. Playwright MCP — Browser Automation Server — The single highest-leverage MCP for both extensions. Lets the agent take browser snapshots, click links, fill forms — so it can debug your frontend, scrape docs, or QA a deployed page without you screen-sharing. Add it second, after the official reference servers prove the pipe works.
10. Git MCP — Version Control Server for AI Agents — Cline and Roo can already run git via the terminal, but Git MCP gives them structured access — branch lists, diff summaries, log queries as typed responses instead of shell output to parse. Worth it for any non-trivial repo.
11. awesome-mcp-servers — MCP Directory & Index — Your monthly browse target. Once you have 3-4 MCPs wired and working, this curated index is where you discover the next one. Don't install from here on day one; come back when you've felt the limits of the four above.

How they fit together

         VS Code (your editor, unchanged)
              │
   ┌──────────┴──────────┐
   │                     │
Cline (#1, #2)       Roo Code (#4, #5)
  default            second opinion
   │                     │
   │   reads same file:  │
   └──── .clinerules (#3) ────┘
                │
         (project memory)
                │
   ┌────────────┴────────────┐
   │       Roo only:         │
   │  Modes (#6) — Architect │
   │  / Code / Ask / Debug   │
   │  + boomerang routing    │
   └─────────────────────────┘
                │
         MCP protocol layer
      (same wire for both extensions)
                │
   ┌────────┬───┴────┬──────────┐
   │        │        │          │
Reference  Playwright Git MCP  awesome-mcp
Servers    MCP (#9)  (#10)    catalog (#11)
(#8)
filesystem browser   structured monthly
git/memory snapshots git ops    browse
fetch/seq  click/    diff/log
thinking   fill

   ↑                                ↑
   start here                       come back monthly
   (zero-config, official)          (after you've felt limits)

   AI Coding Agent Comparison 2026 (#7)
      └── decision document, read twice:
            • after #1 to confirm Cline
            • after #6 to decide on Roo

The non-obvious win: .clinerules is read by both extensions, so you can switch between Cline and Roo without retyping conventions. Same with MCPs — wire them once at the system level, both extensions see the same servers.

Tradeoffs you'll hit (Cline vs Roo Code)

This is the section the pack exists for. Read it before you pick.

• Stability vs flexibility — Cline is the upstream, more conservative, larger user base, fewer surprise breakages on extension updates. Roo ships features faster (custom modes, boomerang, cloud agents) but also breaks more often. If you can't afford a Tuesday-morning "my agent stopped working" incident, default to Cline. If you tinker for fun, default to Roo.
• One mode vs many — Cline has one agent personality with one system prompt. Roo has Architect / Code / Ask / Debug (and you can define unlimited custom modes), each with its own prompt and tool whitelist. One-personality is enough for 80% of tasks. Custom modes earn their complexity when you have a real multi-step workflow — e.g., "Architect plans the migration, Code executes each step, Debug runs after every failure." Don't add modes preemptively; you'll just maintain more YAML.
• Boomerang vs linear — Roo's boomerang orchestration lets one mode kick off a task in another mode, get the result back, and continue. Cline runs the whole task in one context. Boomerang is genuinely useful for >30-minute tasks (context stays clean, sub-agent failures don't poison the parent). For 5-minute edits, it's overhead.
• Cost per task — Both burn the same API tokens for the model itself. Roo's modes can drive cost up (multi-mode tasks make more LLM calls) or down (cheaper model on the Ask/Debug modes, expensive one only on Architect). Configure mode-level models early or you'll bleed money.
• Ecosystem maturity — Cline has more third-party MCP guides, more YouTube tutorials, more Reddit threads. Roo's docs are sharper but the community is smaller. Start with Cline if you Google your way out of problems; start with Roo if you prefer reading source.
• MCP compatibility — Identical. Both speak the protocol. Every MCP in this pack works with both. You wire the server once at the system level; both extensions see it. This is why running both extensions in parallel is cheap — there's no duplicate plumbing.
• Approval fatigue — Both ask for approval on every action by default. Cline's approval UI is faster (fewer clicks). Roo's is more granular (you can pre-approve patterns per mode). After a week, you'll want pre-approvals for git status, ls, cat; do this carefully and only for read-only commands.
• The honest summary — Cline is the iPhone (stable, mainstream, what you recommend to your boss). Roo is the Android (more customizable, faster-moving, what you recommend to the engineer who likes config files). Run Cline as your default; install Roo and try modes on a side project for two weeks; keep both if you can justify it, drop one if you can't.

Common pitfalls

• Installing Roo without trying Cline first — You'll have no baseline for what "normal" feels like. The modes / boomerang features are real, but you can't tell whether you need them until you've hit Cline's limits. Two weeks on Cline, then evaluate.
• Wiring MCPs into one extension and forgetting the other — Cline's settings live in its extension config; Roo's live in its. Wire each MCP twice (or use the system-level config at ~/.config/mcp/ if your OS supports it). If a server seems to work in Cline but not Roo, you forgot to add it on the Roo side.
• .clinerules over-engineering — Same trap as CLAUDE.md: people paste their architecture doc and burn 4K tokens every task. Keep it under 100 lines: stack, commands, conventions, hard NOs. Both extensions read it on every turn.
• Approve-all clicking — Both extensions show "Auto-approve" toggles. Don't enable them globally on day one. Whitelist specific read-only commands (git status, ls, pwd) and stay manual on writes / deletes / network calls until you trust the model on your codebase.
• Skipping the comparison guide (#7) — It's the boring document but it's the one that prevents the "why did I install all four of these?" moment. Read it once, decide which extensions earn permanent slots, uninstall the rest.
• Treating Playwright MCP as optional — It's the MCP that makes the agent useful for frontend work. Without it, Cline / Roo can edit your React component but can't tell whether the page renders. With it, the loop closes.