Learning Objectives
- Understand the three generations of AI coding tools and why all three are still sold today
- Recognize where a tool runs — inside the editor, in the terminal, or in the cloud — and why that decides how it fits your work
- Judge the autonomy question honestly: how much unattended work a tool should be trusted with, and what that costs you in review
What Is AI Coding?
AI coding tools write, edit, explain and debug software using large language models. It is the most commercially mature application of AI outside chatbots, and the one with the clearest before-and-after: a developer who has used a good coding agent does not go back.
The category is easy to misread because the tools look similar and do very different amounts of work. The useful way to see it is by the unit of work each one handles — a few characters, a file, or an entire task.
💡Key Concept
The unit of work is the thing to compare. Autocomplete finishes the line you are typing. An AI-native editor rewrites a function or a file you point it at. An agent takes a written instruction — "fix this failing test", "add pagination to the admin table" — and works on its own across many files until it thinks it is done. Same underlying models, three very different relationships with the person at the keyboard.
The Three Generations
| Generation | Unit of work | What you do | Examples |
|---|---|---|---|
| Autocomplete | A line or a few lines | Keep typing; accept or ignore | GitHub Copilot's original form, Tabnine |
| AI-native editor | A function or a file | Describe the change, review the diff | Cursor, Windsurf, Google Antigravity |
| Coding agent | A whole task, many files | Write the instruction, review the result | Claude Code, OpenAI Codex, Devin, Aider |
All three still sell, because they suit different moments rather than replacing one another. Autocomplete is invisible and costs nothing to ignore. An AI-native editor is the right tool when you know roughly what you want and where. An agent earns its place on work that is well-specified but tedious — a migration, a test suite, a refactor across thirty files.
Where the Tool Runs
The second axis is location, and it matters more than the marketing suggests:
- In the editor. Cursor, Windsurf, Google Antigravity and JetBrains AI Assistant put the model where your code already is, with your open files as context. Best when you are actively working in the codebase.
- In the terminal. Claude Code, Aider, Goose and Mistral Vibe CLI run as command-line tools. They fit naturally into scripts, servers and continuous-integration pipelines, and they compose with the shell tools you already use.
- In the cloud. OpenAI Codex and Devin take a task and run it on their own machines, often against a pull request. You are not present while they work, which is the point and also the risk.
The Autonomy Question
This is the decision the category actually turns on, and vendors are not neutral about it. Every step up in autonomy trades your attention for the model's throughput — and moves the work from writing code to reviewing it.
⚠️Warning
Review does not scale the way generation does. A tool that writes ten times more code does not give you ten times more working software; it gives you ten times more code to check. Teams that get real value from agents put effort into what happens after the model finishes — tests that actually fail when something breaks, small reviewable changes rather than enormous ones, and a person who genuinely reads the diff. Autonomy without that discipline moves the bottleneck rather than removing it.
Two failure modes are worth naming. Agents are confidently wrong about their own success, reporting a task complete when tests were never run. And they take shortcuts that pass the check without solving the problem — deleting a failing assertion is, technically, a way to make tests pass.
The practical rule most teams settle on: give an agent more autonomy as the work becomes more verifiable. A task with a failing test to turn green is a good agent task, because success is machine-checkable. A task whose success is a judgement call is not.
The Tools Worth Knowing
| Tool | Best For |
|---|---|
| GitHub Copilot | The most widely deployed AI coding tool — autocomplete plus chat and an agent mode, inside the editors most teams already use |
| Cursor | The leading AI-native editor — a fork of VS Code built so the model can read and edit across your whole project |
| Claude Code | Anthropic's terminal coding agent — works across files, runs commands, and fits into scripts and pipelines |
| OpenAI Codex | OpenAI's agentic coding surface, geared toward delegating a task and reviewing the pull request it opens |
| Windsurf | AI-native editor with an agent that plans multi-step edits, a direct alternative to Cursor |
| Devin | The most autonomous of the mainstream options — takes a ticket and works end to end, aimed at delegated tasks |
| Aider | Open-source terminal agent that commits every change to git with a message, making the work easy to review and undo |
| Google Antigravity | Agent-first editor that dispatches several agents at once, for developers who want to supervise parallel work |
The catalog holds many more — enterprise-controlled options like Tabnine and GitLab Duo, model-maker entrants like Grok Build and Muse Code, and specialists like Mojo for performance work.
How to Think About AI Coding
Pick by unit of work and by where you already are, not by benchmark scores. If you write code daily inside an editor, start with an AI-native editor or Copilot and see how much of the suggestion stream you actually accept. If you find yourself describing whole tasks rather than individual edits, that is the signal to try a terminal or cloud agent. And whichever you choose, treat the review side as the part you have to build: agents make writing cheap, which makes reading the constraint.
✅Tip
Try more than one, briefly. These tools differ far more in feel than in capability, and preference is genuinely personal — the same agent that one developer finds indispensable another finds exhausting to supervise. Most offer a free tier or trial precisely because the vendors know this. Two weeks of real work is a better evaluation than any leaderboard.
Key Takeaways
- AI coding tools come in three generations that all still sell — autocomplete (a line), AI-native editors (a file), and agents (a whole task) — and the unit of work is the clearest way to compare them
- Where a tool runs decides how it fits: in the editor for active work, in the terminal for scripting and pipelines, in the cloud for tasks you delegate and review later
- The real decision is autonomy, not code quality — every step up trades your attention for the model's throughput and shifts your job from writing to reviewing
- Review does not scale the way generation does; ten times more code is ten times more to check, so tests, small changes and a person who reads the diff are what make agents pay off
- Agents can be confidently wrong about their own success and can take shortcuts that satisfy a check without solving the problem, so give more autonomy only as the work becomes more machine-verifiable
- The tools to know are GitHub Copilot, Cursor, Claude Code, OpenAI Codex, Windsurf, Devin, Aider and Google Antigravity — differing more in feel than capability, so trial two on real work
