Agents vs Assistants
"AI coding tool" covers four different machines with four different supervision models. Mixing them up causes both failure modes: babysitting an agent keystroke-by-keystroke, or letting autocomplete-level trust govern a 40-file autonomous change.
| Autocomplete (Copilot-style) | Chatbot (ChatGPT-in-a-tab) | Pair programmer (Cursor-style) | Agent (Claude Code) | |
|---|---|---|---|---|
| Unit of work | Line / block | Snippet, explanation | Edit within files you have open | Task: multi-file change, verified |
| Context | Current file + neighbors | What you paste | Open files + retrieved repo chunks | Whole repo on demand + CLAUDE.md + command output |
| Acts on your machine | No | No | Applies edits you accept | Reads, edits, runs tests, builds, git — inside a permission model |
| Failure surface | One wrong line, caught at a glance | Stale/hallucinated API, caught when you integrate | Wrong edit in code you're watching | Coherent wrong system: plausible diff across 15 files, passing its own tests |
| Supervision model | Continuous, subsecond | Per-answer | Per-edit | Per-milestone: plan review, diff review, verification gates |
| When to use | Typing speed on code you're authoring | Concepts, unfamiliar APIs, throwaway snippets | Focused edits where you want to steer live | Delegable tasks with checkable outcomes: features, refactors, migrations, debugging |
The load-bearing row is failure surface. Autocomplete errors are cheap because review is instant and local. Agent errors are expensive because the output is large, internally consistent, and looks finished — the review cost moves from "glance" to "engineering review of a junior's PR". That's why agents demand specs, quality gates, and review workflows that the other tools never needed. See Why Agents Fail and Reviewing AI PRs.
The agentic loop
What makes Claude Code an agent rather than a chat window is the loop it runs autonomously:
- Read — explores the repo (grep, file reads,
CLAUDE.md) to build context. - Plan — decomposes the task; in plan mode, presents the plan for approval before touching anything.
- Edit — makes multi-file changes.
- Run — executes tests, builds, linters; reads real error output.
- Iterate — feeds failures back into the loop until done or stuck.
Cursor-style tools run a shorter loop (retrieve → propose edit → you accept) with a human in every iteration. Copilot runs no loop at all. The longer the autonomous loop, the more your leverage shifts from steering during to specifying before and verifying after — which is the core argument of Prompts vs Specs and Responsibility Split.
These aren't competitors; they're different altitudes. Plenty of engineers run Copilot for authoring, a chat tab for API questions, and Claude Code for delegated tasks — same day, same repo. Pick per task by asking one question: how much unreviewed work am I willing to let accumulate before I look? One line → autocomplete. One edit → pair programmer. One task → agent.
Related
- Mental Models — the fast-junior-with-zero-memory model that governs how much to trust the loop.
- Why Agents Fail — the failure surface row expanded: plausible-but-wrong systems.
- Responsibility Split — what per-milestone supervision means in practice.
- Prompt Anatomy — structuring task-level instructions once the unit of work is a task, not a line.
- Reviewing AI PRs — the review workflow that agent-scale output requires.