Autocomplete, Chat, Agent: Three Modes of AI Coding

The three modes, as the vendors define them themselves

There are five labels in the table, but three modes behind them: they pair up by authority. The inline suggestion is completion itself. Chat and inline chat are the same mode in two places — one in the conversation panel, the other right where the cursor is — but in both of them you ask, and you decide what ends up in the file. Agent and plan mode are a pair as well: plan mode is the agent with the brakes on, exploring first and waiting for your approval before it touches your sources. The ordering is worth noticing: it does not grow by capability, it grows by authority. The first suggests, the second talks, the third does.

One terminology change that trips a lot of people up: the phrase "chat mode" has fallen out of use. Vendor documentation today writes that custom agents "were previously known as chat modes". If you are reading an older description, translate it for yourself.

The first mode is no longer what it used to be

The word "autocomplete" is misleading. On the vendor's own description, today's completion changes multiple lines, adds missing imports, and suggests coordinated edits across related pieces of code — and it even predicts edits across files, based on your recent changes, the surrounding code and the linter's errors.

So the boundary of the first mode has blurred towards the third. What we call "completion" today would have been called "refactoring" a few years ago.

That has a practical consequence: pressing Tab is a bigger decision today than it used to be. The same keystroke, but it changes more.

The agent: this is where the real difference starts

This is the part worth understanding precisely, because it is not a matter of taste but of permissions.

By default an agent works like this:

DOES NOT ASK:
  reading a file, searching the codebase
  (in the working directory and in explicitly added folders)

ASKS:
  running a shell command  (except a narrow, read-only command set)
  writing and modifying a file
  fetching a web page      (except a pre-approved set of docs domains)
  web search

And then the approval modes — these names differ from tool to tool, but the logic is the same:

• Manual. Asks the first time each tool is used. This is the default.
• Accept edits. Automatically accepts file changes and the usual filesystem commands, and asks about everything else.
• Plan. Reads and runs read-only commands, but does not rewrite your sources. For exploration this is the right mode.
• Auto, with a safety check. Approves on its own, but a separate classifier reviews whether the operation matches the request.
• Skip everything. The vendor's own warning: "only use it in an isolated environment, such as a container or a virtual machine, where it cannot cause harm."

In another tool family the same thing appears as sandbox levels: the default level reads, writes and runs inside the working directory — with no network access — next to it there is a read-only level, and there is a "no sandbox, no approval" level.

This line is worth remembering: having the network off by default is not an inconvenience, it is the most important protection there is. An agent that cannot call out can break far less.

An IDE agent and a cloud agent are not the same thing

The vendors themselves distinguish between these two, yet in professional conversation they get blurred together.

• IDE agent: runs on your machine, in your working copy. Whatever it breaks, you see, and you undo it with git checkout.
• Cloud agent: a server-side service that explores the repo, writes a plan, commits to a branch and opens a PR. Whatever it breaks lands in a pull request.

The two have different risk profiles, and different approval models. In the cloud version the network is typically off by default during the agent phase — precisely because there you are not watching what it does live.

Which mode is good for what?

Here we have to be honest: we found no controlled measurement matching task types to modes. What exists is practical experience and vendor recommendations. The usable split looks like this:

INLINE SUGGESTION
  familiar code, familiar pattern, typing work
  you know what you want - you just want it written faster

CHAT
  "what does this function do", "why won't it compile",
  "what is the difference between the two approaches"
  -> understanding and deciding, not doing

AGENT
  a well-bounded, MULTI-FILE, BORING change
  one that has tests, that you can revert, and that you
  can read through at the end

WHAT BELONGS IN NONE OF THEM
  the change where you cannot say what the correct result
  is. That one you have to settle for yourself first.

On how widespread they are, though, there is fresh data from a large sample: in a survey of 15,000+ professional developers in the summer of 2026, 90% used a coding agent at least weekly and 68% daily.

And an instructive side number from the same survey, set against its wave six months earlier: the leading pack has been reshuffled. One tool came up from 3% to 16%, another from 18 to 39, while the previous market leader fell from 29 to 21. If you pick a tool now, count on the field looking different in six months — the choosing a coding setup post goes into that in detail.

The acceptance rate, and what we do not know about it

The most frequently quoted figure: users accept roughly 30% of code suggestions. The sample is enormous, 934,533 users — but there are two things to know alongside it.

One is that it is vendor telemetry with no published methodology: it is not clear whether "acceptance" means the moment of insertion, or that the code was still there afterwards. There is a big difference between the two.

The other is that this is the 2022–2023 state of affairs. We found no comparably credible, recent, public figure — even though completion itself has been transformed since.

Common misconceptions

• "The agent uses a smarter model." The same model runs in all three. The difference is in the authority, not in the capability.
• "Autocomplete is harmless." Today's completion changes multiple lines, adds imports, and suggests across files too. Tab is a bigger decision today than it used to be.
• "Plan mode is a wasted round." It is the only mode that does not rewrite your sources while it explores. On an unfamiliar codebase this is where to start.
• "I turn off the approvals, it is faster that way." The vendor's own documentation says this is only allowed in an isolated environment. That is not excessive caution: the warning is on the product.
• "A cloud agent is the same thing, just running elsewhere." Its risk and its approval model are both different. Whatever it breaks arrives as a PR, not on your screen.

What to take away

The three modes differ in their authority, not in their capability. Choose by how much you are willing to undo: with completion one line, with chat one paste, with an agent a whole commit. And the agent's approval setting is no detail — it decides when the shell and the filesystem pass into the tool's hands.

How big to make that first agent task is what the first task with an agent post sizes up, with numbers; for the wider picture of what actually changed, read the balance sheet on programming post, end to end.