Open-Source AI Coding Agents: Cline, OpenHands, Aider and Continue

There's a real difference between an AI that autocompletes your next line and one you hand a task to. The second category — agents that read your codebase, plan a change, edit multiple files and run your tests — became genuinely usable recently, and the open-source options are competitive with the paid ones.

This is what's worth using, how they differ, and the working habits that decide whether they help or make a mess.

Star counts are from GitHub at the time of writing.

Cline — the one most people should start with

cline/cline · ~67,000 stars · TypeScript · Apache-2.0

Cline runs inside VS Code and works through a plan-then-act loop: it proposes what it intends to change, you approve, it executes. It reads files, edits them, runs terminal commands, and can use a browser to check its own work.

The approval step is the design decision that makes it trustworthy. You see the diff before it lands. In practice you spend your time reviewing rather than typing, which is a better use of attention and keeps you responsible for what enters the codebase.

Bring your own API key — Anthropic, OpenAI, or a local model through Ollama. Apache-2.0 licensed, actively developed, and it also ships as an SDK and CLI now.

OpenHands — the most autonomous

All-Hands-AI/OpenHands · ~86,000 stars · TypeScript · MIT

OpenHands (formerly OpenDevin) aims higher: give it an issue, let it work. It runs in a sandboxed environment with a terminal, a browser and a code editor, and it iterates — writing code, running it, reading the error, trying again.

Give it a well-specified task with a clear success condition — "make this failing test pass," "add this endpoint matching the existing pattern" — and it's genuinely impressive. Give it something vague and you'll get a confident, elaborate, wrong answer.

The sandbox matters. An agent that runs commands autonomously should not have direct access to your machine. OpenHands defaults to containers, which is the right call.

Aider — terminal-native, and check the dates

Aider-AI/aider · ~49,000 stars · Python · Apache-2.0

Aider pioneered a lot of what the others now do. It works in the terminal, integrates tightly with git — committing each change with a sensible message — and uses a repository map to give the model structural context without pasting your whole codebase into the prompt.

The git integration is still its best feature. Every change is a commit, so reverting a bad suggestion is git reset, not manual surgery. That single design choice removes most of the anxiety about letting an agent edit your files.

One thing to weigh: at the time of writing, its last significant push was several months back, while Cline, OpenHands and Continue are all committing daily. The tool works and the approach remains sound. But in a field moving this fast, momentum is worth checking before you build a workflow around something.

Continue — autocomplete plus chat, in your editor

continuedev/continue · ~36,000 stars · TypeScript · Apache-2.0

Continue is the open alternative to Copilot: inline autocomplete, chat with codebase context, and highlight-to-edit. Works in VS Code and JetBrains, and connects to any model including local ones through Ollama.

Different category from the agents above. Continue makes you faster at code you're writing. Cline and OpenHands do work while you review. Most people end up wanting both.

Being able to point it at a local model is the standout feature — if your codebase can't leave your machine for policy reasons, this plus Ollama is a genuinely private setup.

How to actually work with these

The difference between people who find agents transformative and people who find them useless is mostly method, not model choice.

Commit before you start. Always. A clean working tree means any mess is one git reset --hard away. This is the single highest-value habit.

Give context, not just instructions. "Fix the login bug" is a bad prompt. "Login fails with a 500 when the email has a plus sign — the handler is in auth/route.ts, and there's a similar working case in signup/route.ts" is a good one. You know things the agent doesn't. Say them.

Small tasks beat big ones. Ask for one coherent change. Agents given sprawling tasks drift, and reviewing a 40-file diff you didn't plan is worse than writing it yourself.

Make tests the success condition. An agent with a failing test to fix has an objective, checkable goal. An agent asked to "improve error handling" has an opinion contest it will win by writing a lot of code.

Read every diff. This is the part people skip and then regret. You're responsible for the code. An agent will confidently produce something plausible that misunderstands your intent, and the only defence is reading it.

Where they're strong and weak

Reliably good: boilerplate, mechanical refactors across many files, writing tests for existing code, translating between languages, adding a feature that closely mirrors an existing pattern, and explaining unfamiliar code.

Unreliable: novel architecture, subtle concurrency, performance work needing profiling, anything where the right answer depends on business context nobody wrote down, and debugging that requires understanding why rather than what.

The pattern: they're strong where the answer is inferable from the codebase, weak where it depends on knowledge only in your head.

The security part

An agent that executes commands is a real capability with real risk. Some discipline is warranted.

Prefer sandboxed execution for anything autonomous. Never point one at a repo containing production credentials — and if you have secrets in .env files, understand that an agent reading your project may read them. Review any command touching your filesystem outside the project. Be careful with agents that fetch from the internet: content pulled from a web page can contain text crafted to steer the agent, and a tool that reads a page and then runs commands is a path worth respecting.

None of this is a reason not to use them. It's a reason to run them with the same care you'd apply to running a script someone sent you.

Choosing

Cline if you want one thing to try: good balance of capability and control, review before every change.

OpenHands for well-specified, self-contained tasks you want done while you do something else.

Aider if you live in the terminal and value the git-per-change workflow — with awareness of its slower release cadence.

Continue if what you want is faster typing rather than delegated work.

All four are free and take bring-your-own keys, so the real cost is API usage. Try two on the same task and the difference will be obvious within an hour.