The levels of agentic engineering (from someone who's led the climb twice) | zach wills
Zach Wills lays out seven stages for moving a software team from writing code by hand to running a shared system of AI agents that builds, tests, and ships features. The organizing idea is that at each stage you find the part of the loop you still do yourself and figure out how to hand it off.
- Most teams can reach the first two levels, where engineers use tools like Claude Code locally, but stall when it comes to running agents in the cloud and making the setup usable by the whole team.
- Each level shifts the human role: from writing code, to explaining architecture, to checking tests, to defining what "done" means in terms of business value rather than a merged PR.
- CI is the best enforcement point for agent guidance, since every change passes through it, and agents tend to produce filler unit tests, so teams need to judge which tests are worth keeping, with end-to-end tests as the stronger target.
Zach Wills argues that most "levels of agentic engineering" lists read like a ladder of tools, and he'd rather frame the climb around one question: what part of the loop are you still doing by hand? Each level is the same move repeated. Find the manual step, then figure out how to remove yourself from it. He also insists you find the next level by actually shipping work with your team, because running into the infrastructure, review, and compliance friction yourself is the only reliable way to learn where the walls are.
The levels run roughly like this. At Level 1, you stop dictating code and hand Claude Code a whole ticket instead of "build this class." At Level 2, you stop explaining the architecture yourself by leaving lean AGENTS.md or CLAUDE.md pointers in each directory, since the harnesses load them progressively and overstuffed files work against you. He warns that skills can become too prescriptive, especially with frontier models like Opus 5.5 where a short, goal-oriented skill or none at all works better. Level 3 moves verification out of your head: the agent loops on logs and tests, records proof, and CI agents check pull requests, since CI is the one place every change passes through. He cautions that agents generate filler unit tests that protect nothing, so he pushes toward end-to-end tests that prove the feature works. Level 4 gets the work off your laptop, with agents running in the cloud and triggered by messages, emails, alerts, or logs, and tickets in tools like Linear assigned to agent workers. Level 5 closes the loop: a release watcher checks production behavior and sends work back to the board if it didn't deliver, because "merged" and "done" are different things.
The final stage he describes, Level 6, is making the factory multiplayer. Usually one engineer's setup becomes the factory, and the goal is for the whole team to feed it: product drops in work, support files bugs that get picked up, and engineers spend their time improving the loops rather than doing the tickets themselves. The useful takeaway for a reader is the diagnostic itself. Before adopting any new tool, ask which step you're still personally babysitting, and that step tells you what the next level is.