Cline

Last reviewed Aug 26, 2026 · 802 words

Cline costs nothing and locks you into nothing — no subscription, no proprietary editor, no mandated model — and that combination is why an extension first released in 2024 already sits at 66,853 GitHub stars. It's an Apache-2.0 coding agent that lives inside stock VS Code, reads your codebase, proposes edits as reviewable diffs, and runs terminal commands, with you approving each consequential step. The money question moves rather than disappears: instead of Cursor's roughly $20/month or Copilot's $10, you pay per-token API costs, which for heavy agentic use can be less, similar, or considerably more depending entirely on how you drive it. This guide is mostly about driving it well.

Approval gates are what make an agent usable

Autonomy without checkpoints is how an AI rewrites the wrong module while you get coffee. Cline's loop is built around consent: it plans, then presents file edits as diffs you accept or reject, and asks before executing terminal commands. The practical rhythm is Plan mode for working out the approach (cheap, read-only, conversational), then Act mode to execute it, which keeps the expensive autonomous phase pointed at an agreed target. Reviewing diffs sounds slower than autocomplete-style tools and is, per step; it wins on net because you catch the misunderstanding at step 2 instead of untangling it at step 12. For where this workflow fits among the other AI-assisted styles, see the AI pair-programming workflow.

Any backend, including one that never leaves your LAN

Cline speaks to the major hosted providers directly, to aggregators like OpenRouter, and, most relevantly for this directory, to local endpoints. Point it at Ollama or any OpenAI-compatible server on your own hardware and no code leaves your infrastructure, which is the difference between "the vendor promises not to train on it" and "it never left the building". The honest caveat: agentic coding is the most demanding LLM workload there is, chaining tool calls and long contexts, and small local models fail at it in frustrating ways. In 2026 the strongest open-weight coding models are genuinely usable for this, but they want serious VRAM. My working split is a frontier API model for the agent, local models for anything where confidentiality outranks capability.

The token bill is the real cost, so manage it like one

"API costs add up" is the catalogue's con, and it's the one users hit first. An agent re-reads files, keeps long histories, and iterates — a single ambitious task can consume hundreds of thousands of tokens. Three habits keep the bill boring. Scope tasks tightly: "fix the pagination bug in api/list.ts" burns a fraction of "improve the API". Use Plan mode to converge before Act mode spends. Route by difficulty — a cheap model handles renames and boilerplate; save the expensive one for architecture and debugging. Cline shows per-request cost as you go, which is more than most subscription tools tell you; watch it for a week and your instincts calibrate.

MCP support means the agent isn't sealed inside the editor

Cline speaks the Model Context Protocol, so you can attach external tools as first-class capabilities: a database it can query, a browser it can drive, an internal API, your issue tracker. This is where it stops being a code-completion competitor and becomes closer to a small automation platform with your codebase at the centre — and MCP servers are simple enough that teams routinely write their own for internal tooling. Start with zero MCP servers, add one when a task obviously wants it.

VS Code only, and the neighbours worth knowing

The hard limitation: Cline is a VS Code extension, full stop. JetBrains, Neovim, and terminal loyalists need different tools — Aider is the strongest terminal-based equivalent and pairs with any editor. Within VS Code, Continue sits closer to the chat-and-autocomplete end of the spectrum if full agentic autonomy is more than you want. Cline's niche is specifically "maximum agency, human veto, any model" inside VS Code, and in that niche it's the default recommendation.

What I'd do

Install Cline from the marketplace, connect the best model you have access to, and give it a real bounded task (a bug with a known reproduction is ideal), using Plan first, Act second, reading every diff. Check the cost readout after a week and set up model routing before habit sets in. If you handle code that mustn't leave the building, stand up Ollama with a large open-weight coding model and keep that as your confidential lane. The free-and-open route to agentic coding is no longer the compromise option; with Cline it's the flexible one.