← All posts
Post agents · 6 min read

From autocomplete to agents

JetBrains has 68% of professional developers using a coding agent every day, and Claude Code ahead of Copilot at work. The ranking is the smaller story: what changed is the axis the competition runs on.

For years we have been watching the AI coding race through the wrong metrics.

Which model writes better code?
Which autocomplete is faster?
Which tool predicts the next line more accurately?

Those questions still matter. They are no longer at the centre of the race.

New data from JetBrains Research, part of the Developer Ecosystem Survey 2026, points at a bigger shift:

The default interface for coding AI is moving from autocomplete to agents.

And the implication is larger than which product happens to be first today.

Agents are not an experiment any more

In data collected between May and July 2026, 90% of professional developers use an AI coding agent at least once a week.

The number that matters more is daily use: 68%.

At two-thirds of professional developers reaching for something every day, the adoption conversation has already moved on. The question is no longer will developers use agents. It is:

How much of the development workflow moves to agents?

That is not a small difference. Autocomplete was a feature added to an existing workflow. Agents can change the workflow itself.

The break is not adoption, it's the ranking

Used at work May–July 2026 A year ago
Claude Code 39% 18% (Jan 2026)
GitHub Copilot 21% 29%
Codex 16% –
Cursor 12% –
OpenCode 7% –

One distinction matters before reading anything into that table: these are not market share. They are self-reported usage at work among the developers JetBrains surveyed — not revenue, not active users, not the market.

The ranking still says something — and the second column says more than the first. Claude Code did not edge ahead; it went from 18% in January to 39% by midsummer. Copilot did not simply come second; it fell from 29% a year ago. In the United States the gap is wider still, with Claude Code at 47% — almost half of American developers.

For years GitHub Copilot was the natural reference point in any conversation about AI coding, and for good reason: GitHub was already where developers worked, Microsoft had enormous distribution, IDE integration came built in, and the proposition was simple — while you write, the AI predicts what comes next.

In the autocomplete era that was an extremely strong position. In the agent era the same advantages do not automatically carry.

One rising twenty-one points while the other loses eight, inside a year, is not really a contest between two products.

The axis of the competition is what changed.

Distribution was king in the autocomplete era

The product logic used to be straightforward, and the whole loop happened inside one keystroke.

Autocomplete

You write It predicts the next lines You press Tab

An agent

You hand over a task It explores, edits, runs, tests It hits an error and backtracks It works while you do something else

In the first model, being embedded in the environment the developer already uses is an enormous advantage. Nobody has to change their behaviour; the AI inserts itself quietly into an existing habit.

The second model is not a better completion. It competes as a whole system — model, context, tools, permissions, memory, orchestration, verification and the execution loop, all at once.

Put differently: in the autocomplete era AI was a feature. In the agent era AI is becoming the working environment.

Why 39% matters

The easy reading is "Claude Code won". Something more interesting is happening.

Its rise suggests developers will change established habits for a sufficiently capable agent. That is worth sitting with, because one of the founding assumptions of developer tooling has always been that moving developers away from where they already work is extremely hard. Changing IDEs is hard. Changing workflow is hard. Introducing a new toolchain is hard.

Agents are testing that assumption.

If a developer is delegating real work, where the agent lives starts to matter less. In an IDE? A terminal? A standalone app? Inside another harness? The interface matters less than how reliably the thing finishes the job.

That quietly devalues a lot of existing distribution advantage.

7% may be the most interesting number in the table

At a glance it looks small. But OpenCode has no Microsoft-scale distribution machine behind it, and JetBrains still reports 42% awareness and 7% use at work.

Distribution still matters. It may no longer be the only moat.

Developers find things fast now — GitHub, X, Hacker News, Reddit, Discord and community threads become a distribution system of their own once a tool is good enough. And the shape of agent systems is changing switching costs, because developers are no longer picking one product.

Model Harness CLI Tool integrations Memory layer Execution environment Each replaceable on its own

Which suggests this market may not consolidate around one IDE or one model. It may get more modular, not less.

The model race isn't over, but the model alone isn't enough

Recent coding benchmarks keep showing the same thing: the same model produces dramatically different results inside different agent systems.

The reason is simple. A real coding task is not only about generating good code. The system has to understand the repository, find the right files, filter irrelevant context, call tools in the right order, recover from errors, read test results, and know when to continue and when to back out — all inside token, latency and cost budgets.

So coding intelligence no longer lives entirely in the weights. Part of it lives in the architecture of the agent system. As models converge, more of the difference between products comes from context engineering, tool use, memory, orchestration, verification and execution.

For Copilot this is bigger than a ranking

Whether Copilot is second today or first again next quarter is not the story. The question underneath is: what becomes the primary way people interact with coding AI?

If the answer is autocomplete, IDE distribution stays an extraordinary moat.

If the answer is agents, the surface widens enormously — because an agent does not suggest code, it takes work. And something that takes work needs repositories, terminals, browsers, CI, issue trackers, documentation, and eventually other agents.

A coding assistant needed

  • the open file
  • a little surrounding context
  • somewhere to put a suggestion

A software engineering runtime needs

  • the repository
  • a terminal
  • a browser
  • CI
  • issue trackers
  • documentation
  • permissions
  • other agents

At that point the category stops being an assistant and starts being a software engineering runtime. The winner may not be the best model or the biggest IDE install base. It may be whichever system developers trust enough to actually hand work to.

The next fight is around the agent

What makes this data interesting is not Claude Code at 39%, and not Copilot at 21%.

It is 68% daily use.

Rankings move. Today's leader may be somewhere else in six months. Models change, prices change, limits change, benchmark leaders change.

But once developer behaviour changes, it does not change back easily.

Autocomplete made us write code faster. Agents force a different question:

Do I need to write this myself at all?

That is the real break. For years AI sat next to the keyboard.

Now it wants the keyboard.

Sources