Describe what a coding agent does that a code-completion model (e.g. GitHub Copilot's inline suggestion) cannot. Which phases of the software development loop does a coding agent own autonomously?
Free · 2 AI evals / day
A **code-completion model** predicts the next tokens given whatever is in your editor right now. It sees the open file, maybe a few neighbours, and guesses the continuation at your cursor. It is fast and useful, but it runs once and stops. It never executes the code it wrote and never finds out whether the suggestion was correct.
A coding agent is the system around the model, not the model itself. It is given tools: read a file, write a file, run a shell command, run the tests. The agent uses these tools in a loop. It reads the relevant files, makes an edit, runs the test suite, and reads the output that comes back.
That output is the key. When a test fails, the error message and stack trace come back into the agent's context as an observation. The agent then reasons about the failure and decides the next edit. It repeats read, edit, run, repair until the tests pass or it runs out of budget.
So the agent owns the whole edit, test, debug loop. Completion owns one cursor position. The agent can verify its own work; completion cannot.
A **code-completion model** runs a single forward pass over a static context, usually the open file plus a little surrounding code, and predicts the next tokens. It cannot run the code it suggests, cannot read test output, and cannot react to its previous edit.
A coding agent is an LLM placed in a loop with tools. It owns the full edit, test, and debug cycle. Each turn it reads files, writes an edit, runs the suite, and captures the result. The loop looks like this:
$$\text{edit}_t \rightarrow \text{run tests} \rightarrow \text{observe output} \rightarrow \text{repair}_{t+1}$$
The defining difference is execution feedback. Test failures, stack traces, and compiler errors return into the agent's context as observations. The next reasoning step is grounded in what the code actually did, not in what the model predicted.
This is exactly the workflow SWE-bench measures. An agent gets a real GitHub issue and a repository. It must navigate the code, edit it, and produce a patch that makes the hidden tests pass. Devin, the Cursor agent, Aider, and Claude Code all implement this loop. Completion tools like Copilot inline suggestions do not.
Quick reference
TL;DR
A completion model predicts the next tokens in a static file. A coding agent reads files, edits, runs tests, reads the output, and repairs until the suite passes.
Imagine two helpers writing a letter for you. The first is a great autocomplete: you start a sentence and it guesses the rest, but it never reads the finished letter or checks if it makes sense. The second helper actually reads your whole desk of papers, writes the letter, mails a draft, waits for a reply, and rewrites it based on what comes back. A code-completion model is the first helper. It fills in the next few lines wherever your cursor sits. A coding agent is the second one. It opens the project files, makes a change, runs the tests, reads the errors that come back, and fixes them, looping until the tests pass. The loop and the feedback are the difference. One guesses once; the other tries, checks, and tries again.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
The developer just wants fast inline suggestions while typing in a single file. A completion model gives sub-second latency, while an agent loop adds many seconds per turn.
The change is a trivial one line edit the developer already knows how to make. Spinning up a tool-using loop and a test run is far more cost and latency than typing it.
There is no test suite or runnable verification for the code being changed. Without execution feedback the agent loses its grounding signal and degrades toward blind generation.
Every code change must be reviewed and approved before it touches the repository. A fully autonomous loop is hard to audit, so a human in the loop step fits the control needs better.
Quick scan · 2–4 min
Everything important, quickly.
Open with the architectural contrast: a single forward pass over static context versus an LLM in a loop with tools. Name the read, edit, run tests, repair cycle, stress execution feedback as the defining capability, then cover repo navigation, diff-grounded edits, and sandboxed execution, and close on what a SWE-bench harness actually scores.
Real-world examples
Real products, models, and research that use this idea.
1SWE-bench gives an agent a real GitHub issue and repository and scores whether its patch passes the hidden test suite, which is now the headline metric for coding agents.
2Cursor's agent mode and Claude Code both read files, apply diff-based edits, run the test runner in a shell, and loop on the failures until the suite is green.
3Aider grounds every edit in the real file by applying unified diffs against current line ranges and commits passing changes to git, so a bad edit is easy to revert.
4Devin runs its edit, test, and debug loop inside a sandboxed workspace with its own shell, browser, and editor, isolating model-generated commands from the host.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow does a coding agent find the right files to edit in a repository far larger than its context window?
Sign in or go Pro to see the approach for this follow-up.
QWhy must edits be applied as diffs against the real file rather than as full-file rewrites from the model's memory?
Sign in or go Pro to see the approach for this follow-up.
QA SWE-bench agent makes all visible tests pass but the fix is still wrong. What went wrong and how do you catch it?
Sign in or go Pro to see the approach for this follow-up.
QHow do you safely execute the shell commands a coding agent generates?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Calling Copilot inline suggestions an agent. Completion is a single forward pass over a static buffer. It never runs the code or reacts to test output, so there is no repair loop.