The AI Coding Levels Model
Five stages of AI-native software development. The jumps to Level 4 and 5 are decided by architecture, not by tooling.
“Do you use AI in development?” is the wrong question. Almost every team now uses some form of AI assistance. The differences lie in how much responsibility the AI carries and which control mechanisms secure it. The Levels model makes these differences nameable: five stages, from autocomplete to autonomous development.
What makes the model useful is less the classification than what follows from it: each stage demands different safeguards. Running Level-4 autonomy with Level-2 controls produces fast, unverifiable code. Running Level-2 usage with Level-4 processes wastes speed.
Autocomplete
AI completes lines and snippets in the editor. The developer writes, the AI speeds up typing. No process risk, but no process gain either. Control stays fully with the human.
Chat Assistance
Code generation in dialogue: the developer describes, copies, checks, pastes. Productivity gains on boilerplate and research. The risk is silently adopted mistakes, because the review burden rests entirely on the human, with no structural safeguard.
Agentic Single Tasks
An agent works directly in the repository: it reads code, edits files, and runs tests, per task and with human approval of every step. The first real delegation. It requires a solid test suite, otherwise nobody can review the results efficiently.
Autonomous Development with Human Oversight
Agents implement entire features spec-driven: specification → plan → implementation → verification. The human defines contracts and reviews outcomes, not every step. This only holds up with the right infrastructure: prompt contracts, verification loops, hooks and guard-rails directly in CI/CD, and cost controls.
Autonomous Agent Teams
Multi-agent systems plan, implement, and verify on their own; the human sets goals and owns the outcomes. Without a governance architecture, this stays a demo. With prompt contracts, verification loops, and guard-rails in CI/CD, it is my daily practice: I set goals, my agent teams deliver, and every step stays auditable.
The economically interesting jump is the one from Level 2/3 to Level 4 and 5. It is also where most teams fail, on missing verification infrastructure rather than on the model. An agent whose results nobody can systematically check automates nothing; it only produces risk faster.
I build this infrastructure, and I work with it myself at Level 5. The process below shows what that looks like.
How I work at Level 5
At Level 5, every step has its own agent with a fixed brief. Every result is checked before the next step starts.
Specification
An agent turns the requirement into a specification with acceptance criteria. I approve it.
Architecture review
A second agent checks the specification against the existing architecture and records the decisions.
Implementation
Backend and frontend agents work in parallel from the approved plan.
Tests
A dedicated agent writes the tests against the acceptance criteria from step 1.
Security review
An agent checks against the OWASP Top 10, a second model checks independently. Critical findings send the work back to implementation.
Approval
Only what I approve via pull request reaches the main branch. The tooling hard-blocks local merges.
- Prompt contracts:
- Every agent gets a fixed brief with a checkable result.
- Verification loops:
- No result counts until a test or another agent has checked it.
- Guard-rails:
- Locks in the tooling that an agent cannot bypass.
What level does your team work at?
Six questions to locate your team in the Levels model.
How does your team use AI when writing code?
FAQ on the Levels Model
What teams ask about the AI Coding Levels Model and adopting it.
What is the AI Coding Levels Model?
A maturity model with five stages of AI-native software development: from Level 1 (autocomplete) through AI-assisted refactoring and agentic single tasks to Level 5 (orchestrated agent teams under human goal-setting). It makes measurable how far a team can responsibly push AI-assisted development.
Which level should my team aim for?
Not the highest by default. The right target level depends on codebase quality, test coverage and verification infrastructure. Without solid verification loops and guard rails, jumping to Level 4–5 backfires: error costs rise faster than throughput.
How is Level 5 different from plain vibe coding?
Level 5 means: I set goals, agent teams deliver. But every change runs through prompt contracts, automated verification and hooks/guard rails right in CI/CD. The difference from uncontrolled prompting is the verification: every change stays traceable and reproducible.
How do I roll the model out across a team, and how long does it take?
Incrementally: determine your current level, build verification and guard-rail infrastructure, then move up level by level. I guide that path across architecture, CI/CD integration and mentoring, focused on production readiness rather than demo speed. How long it takes depends mostly on how reliable the tests and pipelines already are. One reference point from my current engagement: the team started at Level 1 at most. Four months later it works at Level 5 and is the benchmark for the other teams in the corporate group.