If you want to see where agentic AI has gone furthest, look at software development. Coding is text, it’s testable, and developers are early adopters, so it was always going to be first. In 2026 it crossed the line from “interesting experiment” to “how the job is done”.
The numbers
JetBrains’ Developer Ecosystem Survey 2026, covering more than 15,000 professional developers worldwide, found that:
- 90% use AI coding agents at work at least weekly
- 68% use them every day
The tool landscape has shifted quickly too. Agent-style tools that work across a whole project, such as Claude Code, GitHub Copilot, OpenAI’s Codex and Cursor, have overtaken simple autocomplete as the way most developers use AI.
From autocomplete to teammate
The first wave of AI coding tools suggested the next line as you typed. Useful, but you were still driving.
Today’s coding agents work more like a junior teammate. You describe a task (“add pagination to the orders page and update the tests”), and the agent will:
- Read the relevant parts of the codebase
- Edit several files at once
- Run the tests and the build
- Read the errors and fix them
- Hand back a set of changes for you to review
The unit of work has moved from a line of code to a task.
The new bottleneck: verification
Here’s the twist. The flood of AI-generated code hasn’t automatically turned into the huge productivity gains some predicted. Surveys this year, including Sonar’s State of Code developer report, point to a verification bottleneck: when code can be written faster than ever, the slow part becomes checking it.
Teams now spend more of their time on:
- Code review. Is this change correct, readable and maintainable?
- Testing. Does it actually do what was asked, including the edge cases?
- Security. Has the agent introduced a vulnerability or pulled in a risky dependency?
Developers in the JetBrains survey rated agents most effective at writing documentation and generating tests, with automated code review further behind. That’s a good hint about where humans still add the most value.
The developer’s job is moving up a layer
Developers are not being replaced. The work is shifting up a level of abstraction:
- Writing clear specifications. A vague request gets vague code.
- Designing the architecture. Agents follow patterns; humans decide which patterns.
- Reviewing and testing output, with the same rigour you’d apply to a colleague’s pull request.
- Owning quality and security. The agent wrote it, but your name is on the commit.
How to get better results from a coding agent
- Give context. Point it at the relevant files, conventions and an example of “good” in your codebase.
- Ask for tests with the code. Then check the tests actually test something.
- Keep tasks small. Many small, reviewable changes beat one giant one.
- Always read the diff. Never merge code you don’t understand.
- Keep project instructions in the repo. Most tools support a file of standing instructions (build commands, style rules), which saves repeating yourself.
Wrapping up
AI coding agents are now the default, not the exception. The developers who thrive will be the ones who get good at the parts agents can’t do well yet: deciding what to build, and making sure what was built is right.
