Skip to content
AI Engineer Guide.

concept · coding · intermediate · concept 1 of 30

Completion vs assistant vs agent

0 of 30 complete

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

Autonomy follows two conditionsInteractive
highStopping checklow
one linea schema or migration
Blast radius →
VerdictChoose· recommended hereConditional· with the named costStandard· the ordinary case

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
Step 1/4 · Start from reversibility

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.

  1. Classify the task by reversibility first, because a rename is cheap to undo and a schema migration is not.
  2. For completion, keep the context window small enough to meet a keystroke latency budget.
  3. For assistant edits, require an explicit selection or file target and return a diff instead of writing in place.
  4. For agent runs, name the stopping condition up front, such as a failing test, a lint rule or a reviewable patch.
  5. Record which mode produced each change so review can weight the evidence differently.

Trade-offs

ChoiceGood forCostFails when
Inline completionKeystroke latency, low riskNo multi-file reasoningThe change spans several files
Chat assistant with diffDeveloper keeps control of scopeManual context selectionTask needs exploration of an unfamiliar repo
Bounded agent with testsMulti-file changes, verifiable stopTokens, latency, review loadNo test or spec exists to stop on
Long-running autonomous agentLarge mechanical migrationsBlast radius, hard-to-audit tracesWork is irreversible or poorly specified
Trade-off mapInteractive

Good for

Keystroke latency, low risk

Cost

No multi-file reasoning

Fails when

The change spans several files

  1. The change spans several files
  2. Task needs exploration of an unfamiliar repo
  3. No test or spec exists to stop on
  4. 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