From Autocomplete to Agents: The Shift That Changes Everything

The AI that helps you write code has evolved. If you look inside your editor, it might not seem like much has changed—you type something, the model suggests what comes next, and you decide whether to accept.

But there’s a fundamental difference between tools that suggest and tools that act.

The Tools Before Agents

Autocomplete predicts the next token from what’s before the cursor. It’s fast, cheap, and great for line-level or function-level coding. But its capabilities are limited by the context the model sees. It’s not designed to understand tasks spanning multiple files or navigate repository structure.

Put simply: autocomplete reads the buffer, not the project.

Chat goes a step further. You can paste a stack trace and ask why it failed, or share code for explanation. But the pattern remains: input → text → output → text. When the answer requires checking the actual repository, you must bring that context to the model yourself.

Inline Edit moves closer to agents. You select code, describe what you want, and get a diff back. But the tool proposes changes, and you decide whether to apply them.

All three share something in common: the human is still the only agent in the loop.

Nothing changes in your environment until you take action.

What Agents Actually Do

The easiest way to understand an agent is not as “a better model.”

Think of it as a loop.

The developer defines a goal. Then the agent works in rounds—gathering context, planning, acting, checking results, and deciding what to do next—until the task is complete, the loop halts, or human help is needed.

The key insight: agents don’t just “generate text.” They can call tools:

• read — read files
• grep — search code
• edit — modify files
• bash — run commands
• run:test — run tests

Each tool call produces new information for the next loop iteration. The agent reads the result of one action, then uses that to decide what to do next.

This is what the industry calls a harness or scaffold.

The harness is the software layer around the language model—tools, permission boundaries, execution loops, context strategy, state management. It transforms a stateless model that can’t act on the outside world into a system capable of multi-step work.

Quality Lives in the Loop

Here’s a striking fact: the same model can score 71% in one harness and 52% in another on SWE-bench Verified.

The model didn’t change.

What changed was the system around it:

• How it retrieves context
• What tools it has access to
• What order it reads files
• How it gets results back
• How many times it can retry
• How it knows the task is done
• When it decides to run tests
• When it decides to stop

This is why this book focuses on the system around the model as much as the model itself.

The harness isn’t a detail of the agent.

The harness is the program that makes the model an agent.

And when the agent is a program, we treat it like any other program: we design it, scope it, verify it, and measure it.

The Human Role Shifts, Not Disappears

The second impact is equally important:

Agents don’t eliminate the human role—they move it.

Developers gradually shift from code writer to task definer, process supervisor, and final result reviewer.

This isn’t consolation to make us feel better about AI taking over.

It’s a workload shift.

When code generation becomes cheap, the work that still requires time and expertise is supervision, verification, review, and recovery from mistakes.

The hard part of the work doesn’t disappear.

It moves location.

The One Sentence to Remember

Every technique in this book rests on a single hypothesis:

Agents are productive, not authoritative.

Agents can generate code faster than you can review it.

That’s not a problem to solve.

It’s a fact to design systems around.

Agent output should be treated as work under your control—something to verify, validate, review, and roll back.

You don’t give authority to an agent just because you assign it a task.

You’re assigning execution.

Responsibility remains with you.

The discipline of maintaining this distinction is the heart of Agentic Coding.

---

This article is adapted from Chapter 1 of the Agentic Coding book.