The last post made a claim: maturity is where trust lives, not how much AI you use. A claim like that is only useful if you can point at a map and find yourself on it.
Here is the map. Five levels. One axis. A wall at the end of each one that decides whether you climb or park.
The axis is trust, not tooling# #
Every level below is defined by the same question, asked of a different mechanism: what establishes that this AI-produced work is correct, and does that mechanism scale?
Prohibition
Experimentation
Assistance
Delegation
Operationalization
Notice what moves as you climb, level to level, in the trust mechanism. It is never the tooling. It is always the answer to "who, or what, is allowed to say this is correct."
Level 0: Prohibition is zero visibility, not zero usage# #
An organization at Level 0 has usually not achieved zero AI usage. It has achieved zero visibility into the AI usage that is happening anyway. Engineers paste code into personal accounts. They run local agents on side monitors. They expense a tool under a line item nobody scrutinizes closely enough to ask what it does. The policy did not prevent risk. It forfeited governance over risk that exists regardless, because the people doing the work found the policy slower than the deadline.
Almost every organization that believes it is at Level 0 is secretly at Level 1 with the lights off. The genuine exceptions are the rare environments where egress is physically controlled, air-gapped networks, classified systems, where prohibition is enforced by the network and not by a memo.
Audit check: run an anonymous survey and pull the egress logs. They will disagree with the policy, and the size of the disagreement is your actual Level 0 population.
Level 1: Experimentation, where nothing compounds# #
Trust here is whatever each individual privately decides it is. Productivity claims are anecdotal, sincere, and unfalsifiable: someone found a workflow that saves them two hours a day, and there is no way to check, transfer, or scale that claim. The unit of AI work is the prompt: personal, ephemeral, unversioned, gone the day that person changes teams or leaves.
This is the level where a company can have real, individually impressive AI usage and zero organizational capability, because none of it is written down anywhere the organization can find it again.
Audit check: look for a single shared, versioned AI artifact anywhere in the organization, a prompt library, a skill, a template, that survives the departure of the person who wrote it. If none exists, you're at Level 1 regardless of how many people are quietly excellent at prompting.
Level 2: Assistance is where maturity goes to feel finished# #
This is where the typical enterprise sits, and it earns that position honestly, because Level 2 feels like maturity from the inside. Licenses procured. Policy written. Copilots deployed across engineering. A RAG-powered "chat with our docs" tool shipped to positive reviews. Giphy filled fights over which harness is best play out in various slack channels. Usage dashboards, every one of them, green.
The trust mechanism underneath all of that activity is identical to the one the organization used before any of this AI infrastructure existed: a human reads everything before it counts. AI scaled production, but it did not scale verification. Those two things were supposed to move together and didn't, so review queues balloon, and the pressure has to go somewhere. Some of it goes to hiring reviewers, linearly, against output that scales with compute. Some of it goes to throttling the agents, which quietly caps the ROI the program was funded to deliver. And a great deal of it goes to the place that absorbs pressure without ever showing up on a chart: reviewers quietly stop reading in full and start approving blindly.
Your copilots made you feel mature. The review bottleneck says otherwise.
That is not a hypothetical for later. It's a live condition at most companies running this playbook right now, and the standard adoption metrics improve as it happens: acceptance rate climbs, cycle time drops, throughput per engineer looks fantastic. Every number the transformation program reports gets better while the mechanism that was supposed to catch mistakes quietly disappears.
Audit check: confirm that no AI-produced change reaches production without a human reading it in full, then measure whether that's still true. Pull last quarter's AI-assisted changes and plot review duration against diff size. A growing cluster of large diffs approved in under a minute is the review bottleneck showing up in the data before it shows up in an incident. The incident is just a ticking time bomb waiting to happen.
Level 3: Delegation is the structural break# #
This is the level where trust actually relocates, and it's the only one on this list that requires the organization to build something rather than buy or staff something. Trust migrates from human attention to machine gates: executable tests frozen before implementation exists, contracts the builder is mechanically prevented from arguing with, and fresh contexts chartered to refute the work rather than assess it, what the ADLC calls prosecution when the work in question is code.
Humans don't disappear from this picture. They concentrate at the two places their judgment is actually load-bearing: approving the spec before work starts and accepting the running behavior after it's built. Everything between those two moments is machine-gated, which is the entire point. Agents are delegated whole tasks here, not keystrokes, because the verification underneath them finally scales the way the capability does.
Audit check: find a change an agent produced that reached production with no human reading the diff, and name the specific gate(s) that made that safe. If you can't name the gate, you're not at Level 3 yet, whatever your capability or token spend suggests.
Level 4: Operationalization is the level that improves itself# #
Level 4 is not "more Level 3." It's a different kind of system, one that gets cheaper and stricter at the same time, because the gates themselves are the object of continuous improvement. Recurring findings from review get converted into deterministic controls. Observed work gets mined into versioned organizational skills. Gates get calibrated with planted defects so "we have review" becomes "we know our review catches this percentage of this category of mistake." The unit economic that matters at this level is cost per merged, verified change, and it falls, quarter over quarter, because the system is designed to make it fall.
The closest concrete example I can point you to is the one I built for practitioners: the Agentic Development Lifecycle is the reference implementation of Level 4 for software development specifically. It is not the only way to get there. It's proof the destination exists.
Audit check: ask for the distillation log, the list of controls that exist today because a gate caught something last quarter, and the trendline of cost per verified change. If neither exists, the organization is somewhere south of Level 4, no matter what the capability roadmap says.
What dissolves each wall# #
Every wall above has exactly one keystone unlock, the specific investment that dissolves it rather than merely postponing it.
| Transition | Wall being dissolved | Keystone unlock |
|---|---|---|
| 0 → 1 | Shadow usage | Amnesty plus visibility: acknowledge the usage, make it observable |
| 1 → 2 | Nothing compounds | Sanctioned tooling, the first shared skills, usage telemetry |
| 2 → 3 | The review bottleneck | Adversarial review plus frozen rails, trust migration from human attention to machine gates |
| 3 → 4 | Flat unit costs | Skill mining plus gate calibration, the distillation loop |
There is no keystone unlock listed for what comes after Level 4, because there isn't a wall waiting there. The whole design of the level is that it keeps dissolving its own walls before they finish forming.
The spine is not the whole model# #
Underneath these five levels sit five tracks, capability, verification, knowledge, observability, and economics, each climbing its own five-stage ladder in step with the level above. This post only covers the spine on purpose. The tracks are worth an article each, and they're coming.
Of those five tracks, one is doing the load-bearing work: verification. Every capability rung on this ladder is only safe once the verification rung underneath it has actually been built, not purchased, built. That relationship between the two, and the precise shape of what goes wrong when an organization gets it backwards, is the subject of the next post.