Autocomplete, Chat, Agent
The same prediction engine ships as three very different tools. Knowing which mode you are in tells you what it can see, what it can touch, and how it will fail.
The same prediction engine from last lesson reaches you through three very different vehicles. You probably use all three in a single day without noticing the switch. Start noticing, because each mode has its own answer to three questions: what can it see, what can it touch, and how does it fail?
1. Autocomplete (Copilot-style inline suggestions): predicts the next chunk as you type, right in the editor. Fast, constant, low ceremony. 2. Chat (an assistant in a panel or browser): you write a request, it writes back code and explanations. You copy things across the boundary yourself. 3. Agent (Claude Code, Cursor's agent mode, and similar): you give it a goal; it reads files, edits them, runs commands, sees the output, and iterates, in a loop, until it decides it is done.Same engine, wildly different blast radius. Autocomplete can waste a line. Chat can waste an afternoon. An agent can modify fourteen files while you get coffee.
Here is the working comparison to keep on hand:
| | Autocomplete | Chat | Agent |
|---|---|---|---|
| Sees | Current file, some open tabs | What you paste or attach (IDE panels also auto-include your open file) | Files it chooses to read, command output |
| Touches | The line under your cursor | Nothing (you paste its output) | Many files, plus your terminal |
| Speed of harm | One bad line at a time | One bad block at a time | Whole bad changesets |
| Typical failure | Plausible line you accept on reflex | Confident answer about code it has not seen | Wrong direction executed thoroughly |
| Your review unit | Each suggestion | Each pasted block | Each diff, before it lands |
Two rows deserve a second look. Sees: a browser chat knows nothing you didn't paste, an IDE chat panel usually auto-attaches your open file or selection and nothing more, and autocomplete knows roughly your open editor, not your repo (Module 3 makes these rules precise). Typical failure: notice each mode fails along the dimension it controls. Autocomplete fails a line at a time; agents fail a changeset at a time.
You need to (a) convert 40 similar lines to a new format as you retype them, (b) understand why a coworker's regex works, and (c) rename a config key everywhere it appears across 30 files and re-run the tests. Which mode fits each task best?
- A(a) autocomplete, (b) chat, (c) agent
- B(a) agent, (b) autocomplete, (c) chat
- C(a) chat, (b) agent, (c) autocomplete
- DAll three tasks are best done in chat, since it is the most flexible mode
Now the failure profiles, because "how it fails" decides how you review each mode.
Autocomplete fails by momentum. Suggestions arrive mid-thought, look locally right, and train your reflex to hit Tab. The classic incident is not one terrible line; it is twenty slightly-wrong accepted lines discovered a week later. Chat fails by invisible ignorance. It answers about YOUR code while seeing only what you pasted. Ask "why is my function slow?" without the function, and you get fluent, generic advice wearing the costume of a diagnosis. Agent fails by thorough wrongness. An agent that misreads the goal doesn't produce one bad line; it produces a coherent, multi-file implementation of the wrong thing, and may even "verify" its work by criteria you never chose. Module 8 covers steering and intervention in depth.One pattern unifies all three: the failure grows with the autonomy. More capability per action means more inspection per sign-off. The general contractor checks a delivered wall differently than a delivered wing of the building.
Which failure story is characteristic of AGENT mode specifically, rather than autocomplete or chat?
- AThe tool misunderstood the goal and produced a coherent set of edits across many files, all confidently implementing the wrong thing
- BYou accepted a stream of plausible one-line suggestions on reflex, and a subtle bug slipped in among them
- CThe tool gave a fluent diagnosis of your bug while never having seen the function in question
- DThe tool's suggestion had a typo that broke the build immediately
A last habit to build: mode choice is a decision, not a default. Most developers use whatever is open. Better: match the mode to the task's size and risk.
- Reach for autocomplete when you already know what the code should be and want it typed faster. You are the author; it is the keyboard.
- Reach for chat when you need understanding, options, or a draft to react to, and you want a hard boundary between suggestion and codebase. Nothing lands without you moving it.
- Reach for an agent when the task is well-specified, spans files, or needs a tool loop (edit, run, check), and you are prepared to review a diff rather than a line.
Notice the trade you are making each time: the agent's power comes from removing the copy-paste boundary that made chat safe. That boundary was doing quiet review work for you. When you remove it, the review has to become deliberate. The rest of this course, honestly, is about doing that well.
You are about to make a risky change to payment-handling code. You know exactly what the three-line fix should be. According to this lesson's mode-choice habit, what is the best-fitting approach?
- AType it yourself with autocomplete assistance at most, since you know the code and the risk calls for a tight review unit
- BGive an agent the goal "fix the payment bug" and review the resulting changeset
- CAsk chat to regenerate the whole payment module so the fix is definitely included
- DUse the agent, because agents are the newest and therefore most reliable mode
- Three modes, one engine: autocomplete (inline lines), chat (request and response across a copy-paste boundary), agent (a loop that reads, edits, runs, and iterates).
- Each mode has its own sees / touches / fails profile; chat sees only what you paste, agents touch many files and your terminal.
- Failure grows with autonomy: momentum-accepts (autocomplete), invisible ignorance (chat), thorough wrongness (agent).
- Choose the mode per task: known small change = small tool; understanding = chat; well-specified multi-file work = agent, reviewed as a diff.
Next: the question underneath all three modes: what can the tool actually SEE right now? The answer is a window, and the window is the tool.