Agentic coding tools
Autocomplete vs. agent mode
Autocomplete finishes your line. An agent finishes your task — reading files, editing several of them, running commands, and checking its own work.
1Learn the idea
Read
The four differences that matter
1. Scope. Autocomplete operates on one file, usually one function, at the position of your cursor. An agent operates on your whole repository — it can open, search, and edit anything it decides is relevant, unprompted by where your cursor happens to be.
2. Initiative. Autocomplete is reactive: it waits for you to start typing, then guesses. An agent is proactive: given a goal, it decides the plan and the sequence of steps on its own, without you specifying each edit.
3. Tool use. Autocomplete only produces text. An agent can run shell commands — install a package, run a test, start a server, check a linter — and read the result back into its own reasoning. That closes a loop autocomplete never had: the agent can find out whether its change actually worked, not just whether it looks plausible.
4. Duration. A single autocomplete suggestion resolves in seconds. An agent task can run for minutes, working through a multi-step plan, retrying failed steps, and adjusting as it learns more about your codebase along the way.
Read
Why this shift happened now
Three things had to line up before agent mode became practical. First, models got reliably good at multi-step planning and at correctly calling tools (running commands, reading their output, deciding what to do next) rather than just generating plausible-looking text. Second, editors and CLIs built the scaffolding — safe file-editing APIs, sandboxed command execution, permission prompts — needed to let a model act on a real filesystem without constant hand-holding. Third, context windows grew large enough that an agent can hold a meaningful slice of a real codebase — not just the ten lines around your cursor — while it reasons about a change.
The result is a genuinely different working relationship. With autocomplete, you're always the one driving; the tool fills in gaps. With an agent, you can hand over a whole bounded task and come back to review a finished (or in-progress) attempt — closer to delegating to a fast, literal-minded junior teammate than to using a smarter typewriter.
Read
Where the line blurs
Most tools today aren't purely one or the other — inline autocomplete and an agent mode usually live in the same product, and you choose per task. Fixing a single obvious typo doesn't need an agent; asking it to "wire up this whole feature" doesn't fit in a single suggestion. Recognizing which mode a task calls for is itself a skill, and it's the one this topic builds page by page: how the agent loop actually works, how to write a task it can succeed at, how to review what it produced, and how to decide when it should stop and ask you first.
Go deeper
Before you start
Why this matters
For years, "AI coding help" meant one thing: you typed, and a suggestion appeared — a finished line, sometimes a whole function, based on the few lines around your cursor. That's still useful, and it's still there in every modern editor. But it's a narrow kind of help. It only sees what's near your cursor, it only writes code, and it stops the moment you accept or reject the suggestion.
Agent mode is a different shape of tool entirely. Instead of reacting to your cursor position, an agent takes a goal — "add a /health endpoint and a test for it" — and works the goal, not the line. It searches your repository to find relevant files, decides what needs to change, edits multiple files in sequence, runs your test suite or linter, reads the output, and keeps going until the goal is met or it needs your input. You supervise a small project, not a single suggestion.
In the wild
See how this idea shows up as a product and a company — then come back to the lesson. Skills transfer across vendors.