Coding agents

Cursor, Claude Code, GitHub Copilot, Cline, Aider, Devin. The single most-deployed agent category — and what makes them work isn't their LLM, it's their tools and guardrails.

What coding agents actually do

A coding agent reads your code, decides what change to make, makes it, runs the tests, looks at the failure, tries again — all without you touching the keyboard for each step. Cursor, Claude Code, GitHub Copilot, Aider, Devin: same idea, different ergonomics.

What makes them work isn't a magic model — it's the harness around the model. Precise diff formats so edits don't clobber files. Approval gates before destructive commands. A scoped view of the codebase so the agent doesn't hallucinate types from another project. The brain matters; the fence matters more.

That's the whole concept. Below: the major products, what separates a good harness from a dangerous one, and where these agents genuinely shine versus where they fall flat.

When you'd reach for it

Coding agents earn their keep on bounded, verifiable tasks:

• Boilerplate — scaffolding tests, components, API clients, migrations.
• Mechanical refactors — class to hooks, callbacks to async/await, framework upgrades.
• Localised debugging — when you can describe the symptom precisely.
• Code review and lint-style improvements — catching obvious bugs, missing edge cases.
• Translation — Python to TypeScript, one ORM to another.

You wouldn't reach for one on cross-cutting architectural decisions, performance tuning that needs deep understanding of the hot path, or subtle bugs in unfamiliar code. Agents excel where "right" is verifiable. They flounder where "right" is matter of taste.

How it's actually built

Strip away the marketing and a coding agent is:

Loop:
  1. The agent reads what's in front of it (your prompt + open files + recent edits).
  2. It decides on one of: read another file, run a search, propose an edit, run a command, ask you a question, or finish.
  3. You (or the harness) execute the action.
  4. The result goes back into the agent's context.
  5. Repeat until done.

The differentiator isn't the loop — it's:

• The tool surface the agent has access to.
• The diff format for edits (precise vs. lossy).
• The guardrails (does it ask before running terminal commands? before deleting files?).
• The context strategy (which files does it look at? does it summarise long ones?).
• The model running the loop (frontier vs. cheap; reasoning vs. not).

The major coding agents (mid-2026)

Cursor

A VS Code fork. Tight inline completion, Cmd-K for code generation in place, an "agent mode" that runs the full loop with file-edit and terminal access. Uses your choice of model (frontier closed or open). The most-used IDE-based coding agent today.

Claude Code

Anthropic's terminal-native coding agent. Runs as a CLI in your project; reads files, edits them with diffs, runs commands, manages git. Cleaner separation between agent thinking and your code. Good fit for terminal-comfortable engineers and complex multi-file refactors.

GitHub Copilot

Originally just inline completion (still its strongest feature). Has expanded into chat, IDE-integrated agent ("Copilot Workspace"), and PR review. Lives wherever GitHub does (VS Code, JetBrains, GitHub.com).

Cline / Continue / Aider

Open-source alternatives. Cline is a VS Code extension running the agent loop with model-of-your-choice. Continue is similar with strong customisation. Aider is a terminal CLI that uses git diffs as the edit format — minimalist and durable.

Devin (Cognition Labs)

Tries to be a more-autonomous engineer: takes a high-level task, runs in its own sandbox, reports back. Less editor-integrated, more "give it a Jira ticket and check back later." Polarising in practice — autonomy is hard.

What makes a good coding agent

Watching the products evolve, the lessons that have settled:

What they're genuinely good at vs. not

Strong

• Boilerplate (writing tests, scaffolding new components, repetitive refactors).
• Translating between languages or frameworks (Python → TypeScript, React class → hooks).
• Generating from a spec (turn this README into a starter project).
• Localised debugging when you can describe the symptom precisely.
• Code review (catching common bugs, missed edge cases, security smells).

Weak

• Cross-cutting architectural decisions (where should this live? what's the right abstraction?).
• Subtle bugs in unfamiliar code with non-obvious root causes.
• Performance tuning that requires understanding the actual hot path.
• Designing public APIs that future engineers will live with.
• Anything where "looks right" passes review but is subtly wrong.

The pattern: agents excel at bounded tasks where the right answer is verifiable. They struggle with unbounded judgement calls where "good" is matter of taste and downstream consequences.

Try it yourself (~15 minutes)

Pick any of these — they all have free tiers:

1. Cursor: download from cursor.com. Open a small project. Cmd-K → "Add a function that…". Try the agent panel.
2. Aider: pip install aider-chat. cd into a project, run aider. Ask it to add a feature; it'll show diffs; type y to apply.
3. Claude Code: install via the official guide. Run in a small repo. Watch how it asks before destructive commands.

Try the same task in two of them. Notice how they differ in: how they read your code, how they propose changes, what they ask before doing.

Further reading

• Anthropic — Building Effective Agents — design principles all coding agents follow.
• Cursor docs — features and .cursorrules system.
• Claude Code docs — CLI-based agent with guardrails.
• Aider — open-source CLI coding agent — minimalist alternative, well-documented.
• SWE-bench leaderboard — independent benchmark of coding agents on real GitHub issues.