Why it matters
Coding tools differ less in model quality than in how much of the loop they own. A completion model proposes the next few lines and the developer accepts or rejects. An agent takes the keyboard, chooses files, runs commands and decides when it is finished. That shift changes the failure mode, the cost per task and the review burden, so the decision is an interface and risk decision before it is a model decision.
Mental model
It is a gearbox with manual, assisted and automatic modes, all moving the same car. The metaphor breaks because the agent can change gear mid-task without announcing it, and the only record of the route is the trace it chose to keep, which is often shorter than the drive.
How it works
Step 1 of 4
Start from reversibility
Classify by what a wrong change costs to undo before choosing a mode. A rename and a schema migration do not belong in the same mode.
Blast radius: low · Stopping check: low
Standard · Inline completion
Keeps you on every token; no multi-file reasoning.
The ordinary mode for a small edit. Autonomy here buys nothing the developer cannot check in a glance.
Axes
- Blast radius
- one line → a schema or migration
- Stopping check
- nothing catches it → a test or spec
Figure. The mode follows what a wrong change costs to undo and whether a check can stop the run. Inline completion is the ordinary case; a bounded agent is right for a scoped change with a verifiable stop, and conditional when the change is cross-cutting.
What to notice. The axes are ordered, not scored: the figure does not price a token or measure a diff. “Cheap to undo” means the change can be reverted without data loss, and the stopping check is whatever the repository can actually run. The figure does not claim autonomy is never right on irreversible work — it claims that work needs a review and a rollback on top of the check.
Text version
A two-by-two decision map. The horizontal axis is blast radius, from one line on the left to a schema or migration on the right. The vertical axis is the stopping check, from nothing catches it at the bottom to a test or spec at the top. Bottom left, a one-line change with no check: inline completion, the ordinary mode, because autonomy buys nothing the developer cannot check in a glance. Bottom right, an irreversible change with no check: an assistant edits a named region and the developer approves the diff, because when no check exists the reviewer is the check. Top left, a scoped change a test can stop: a bounded agent with tests, with the stopping condition named up front. Top right, a cross-cutting change a test can stop: a bounded agent behind a review gate, conditional because the blast radius still needs a review and a rollback. Four steps walk the cells in that order, starting from reversibility.
- Classify the task by reversibility first, because a rename is cheap to undo and a schema migration is not.
- For completion, keep the context window small enough to meet a keystroke latency budget.
- For assistant edits, require an explicit selection or file target and return a diff instead of writing in place.
- For agent runs, name the stopping condition up front, such as a failing test, a lint rule or a reviewable patch.
- Record which mode produced each change so review can weight the evidence differently.
Trade-offs
| Choice | Good for | Cost | Fails when |
|---|---|---|---|
| Inline completion | Keystroke latency, low risk | No multi-file reasoning | The change spans several files |
| Chat assistant with diff | Developer keeps control of scope | Manual context selection | Task needs exploration of an unfamiliar repo |
| Bounded agent with tests | Multi-file changes, verifiable stop | Tokens, latency, review load | No test or spec exists to stop on |
| Long-running autonomous agent | Large mechanical migrations | Blast radius, hard-to-audit traces | Work is irreversible or poorly specified |
Good for
Keystroke latency, low risk
Cost
No multi-file reasoning
Fails when
The change spans several files
- The change spans several files
- Task needs exploration of an unfamiliar repo
- No test or spec exists to stop on
- Work is irreversible or poorly specified
Figure. Each choice with what it buys, what it costs, and the case where it loses.
What to notice. The fourth column is the decision: if the losing case describes your situation, the choice is wrong.
Text version
Four trade-offs: Inline completion is good for Keystroke latency, low risk, costs No multi-file reasoning, and fails when The change spans several files. Chat assistant with diff is good for Developer keeps control of scope, costs Manual context selection, and fails when Task needs exploration of an unfamiliar repo. Bounded agent with tests is good for Multi-file changes, verifiable stop, costs Tokens, latency, review load, and fails when No test or spec exists to stop on. Long-running autonomous agent is good for Large mechanical migrations, costs Blast radius, hard-to-audit traces, and fails when Work is irreversible or poorly specified
Failure modes
- Autonomy mismatch. A completion tool is asked for a refactor and returns fragments that never compile. Debug: check whether the request needed a file-level edit and re-run with a mode that can execute the build.
- Silent scope creep. An assistant edits files the developer never selected because the tool widened its target. Debug: log files touched per turn and compare with the files the user named.
- Review debt. Agent patches arrive faster than anyone reads them and approvals become rubber stamps. Debug: measure review time per patch against patch size.
In production
Track acceptance rate per mode, edit distance after acceptance and how often agent patches are reverted. Cap agent runs by wall-clock time and diff size, and surface the mode in the review UI.
Common misconceptions
People think: Agentic means better.
Actually: Autonomy changes the failure mode rather than the ceiling; a bounded assistant with good context often beats an agent on a small edit.
People think: Completion and agents share one cost model.
Actually: Completion is priced per keystroke context, while agents spend most of their tokens on exploration, tool output and retries.
Interview angle
Separate the modes by who decides the next action and what stops the run. A strong answer names reversibility, review cost and the task classes worth delegating, then explains why an autonomous run needs a verifiable stop. Saying agentic is better without naming who checks the result, or how a bad patch is undone, leaves the important part unsaid.
Sources
- Anthropic, Building effective agents — the distinction between workflows and agents.
- GitHub, Copilot documentation — the completion and chat surfaces in an IDE.
- Yang et al., SWE-agent — an agent-computer interface built for repository tasks.