The five levels between autocomplete and agents

Ask ten engineering leaders where their team sits on the AI coding maturity ladder and most will place themselves a level or two too high. The ladder below is the one we use to locate teams honestly. It runs from autocomplete to orchestrated agents in five levels, and the labels matter less than what has to be true before a team can climb from one to the next. The climb has a discipline behind it, agentic engineering, and this ladder is its first diagnostic.

The gap is well documented. Anthropic’s 2026 Agentic Coding Trends Report found that developers now use AI in roughly 60% of their work, yet report being able to fully delegate only 0 to 20% of their tasks. Assistance everywhere, delegation almost nowhere. That distance is where most of the unrealized value sits, and the ladder is a way to walk it deliberately.

The five AI coding maturity levels

Level one is suggestions. Inline completions in the editor. The value is real and small: typing accelerates, thinking does not change. This level requires nothing from the organization, which is why every team reaches it and why it proves nothing.

Level two is chat. Developers ask questions, paste stack traces, draft functions in a side panel, iterate on the answer. The unit of exchange is a conversation. This is where most teams actually live in 2026, including many who describe themselves as agent-first.

Level three is single-task agents. An agent takes one bounded task, works in the repository, runs the tests, and returns a reviewable diff. The developer supervises checkpoints instead of copying snippets out of a chat window. This is the first level that changes what a task costs, and the first that demands anything from the codebase.

Level four is delegated workflows. Recurring work runs through agents by default: test writing, refactors, dependency upgrades, well-specified bug fixes. The team has context files, a versioned skill library, and guardrails in CI, so delegation does not depend on who is driving. The individual trick has become a team capability.

Level five is orchestrated parallel agents. An engineer runs several agents at once on isolated tasks, usually in separate worktrees with a review queue, and spends the day specifying, arbitrating and verifying rather than implementing. The engineer’s job at this level is closer to tech lead than typist.

What moves a team up a level

From two to three, the barrier is a skill, not a tool. Delegation means writing a task well enough that an agent can finish it without you, and that is learned, deliberately, the way code review once was. We covered that jump in from chatting with AI to delegating to it. It also takes a codebase agents can operate in: context files that name the build and test commands, and tests fast enough to serve as feedback.

From three to four, the barrier is organizational. What one developer does with an agent must be written down, versioned and shared, or the team stays at level three forever with two local heroes. Skills in the repo, conventions for task framing, and guardrails in CI that hold whether a human or an agent wrote the code.

From four to five, the barrier is verification speed. Running three agents in parallel is pointless if reviewing their output takes longer than writing the code would have. Flaky tests, slow CI and vague ownership all cap a team at level four, whatever tools they buy.

Notice what is absent from every transition: model quality. The models have been good enough for level four work for a while. In our engagements the ceiling is almost always the surrounding system, which is bad news for teams waiting for the next model to fix adoption, and good news for teams willing to do the unglamorous work now.

How to locate yourself honestly

Three questions beat any self-assessment survey.

1. Of the pull requests merged last week, how many started as a task delegated to an agent end to end, rather than code typed with assistance?
2. Could a new hire use your team’s agent setup productively on day two, because the context files and skills live in the repo, or does effectiveness depend on sitting next to the right person?
3. If your two heaviest AI users left tomorrow, would the capability leave with them?

Teams that answer honestly usually find themselves at level two with pockets of three. That is fine. It is also worth knowing before you plan around a level-four story, and the only reliable way to know is a measured baseline rather than a poll.

The ladder climbs one level at a time, and each transition has a different owner: the developer for two to three, the organization for three to four, the platform for four to five. Placing a team on it, against real delivery data, is how we open every agentic engineering engagement: you cannot plan the climb without knowing the starting rung.