This is the first of a three-part series.
The program review was going well until the quietest person in the room spoke.
A team lead had just walked us through their AI rollout. The slide was impressive: their meeting-capture workflow had reached what they called “level four” — the AI no longer suggested notes for someone to write up. It wrote them, filed them, and logged the follow-ups on its own. No human in the loop. The team had climbed the ladder in under a quarter, and the lead was rightly proud of the climb.
Then a senior architect near the end of the table asked the only question that mattered. “Are the notes any good?”
The lead started to answer and stopped. He gestured at the slide. “It’s fully autonomous.”
“That’s not what I asked.”
Nobody in the room — including me — had a crisp answer. We knew, with precision, how much the system was trusted to act on its own. We had levels for that, telemetry for that, a roadmap for that. We could not say, with anything like the same precision, whether the work it produced was good. The two questions had quietly folded into one somewhere along the way, and the room had been reporting the first as if it answered the second.
That moment sent me back to the whiteboard, and the whiteboard produced the single most useful drawing in our AI-native program: two axes, not one.
The two axes
Here is the distinction, stated as plainly as I can manage.
Autonomy is the x-axis: how much the AI acts on its own. Does it suggest, so a person still does the work? Does it draft, so a person edits and ships? Does it act with review, so a person approves? Or does it act and log, so a person finds out afterward? Moving right along this axis is what most organizations mean when they say an AI capability is “maturing.”
Quality is the y-axis: how good the output is before a person ever sees it. Does the work clear a defined bar — accuracy, structure, audience fit, completeness — before it surfaces for approval or ships to a customer? That axis is measured by a different mechanism, and many organizations haven’t built it yet. Some don’t picture it as a separate axis at all.
Although the two are related, they are independent. A workflow can sit far right on autonomy and stay flat on quality — that’s how you end up with a CRM full of confidently filed but subpar work. A workflow can be tightly reviewed and still turn out mediocre output, because a human rubber-stamping weak drafts is review theater, not a quality bar. Keeping the two axes separate, and designing a distinct mechanism for each, is what keeps an AI program honest.
The plainest version of this is how we govern driving. A learner’s permit, a provisional license, a full license — that ladder describes how much we trust the driver to operate alone. The vehicle inspection describes whether the car is fit for the road. No licensing authority confuses the two. A fully licensed driver can be sitting in a car that fails inspection; a fifteen-year-old with a permit can be sitting in a flawless one. Trust in the operator and fitness of the output are simply different questions, and the system that governs driving asks them separately, with separate tests, on separate schedules.
Most AI programs are handing out licenses and never inspecting the cars.
Why we conflate them
The conflation isn’t carelessness. It’s inheritance.
The maturity language most of us absorbed comes from autonomous vehicles — the SAE levels, L1 through L5. That framework measures one thing: how much the human can take their hands off the wheel. It says little about whether the car is going anywhere worth going. When enterprise AI arrived, we imported the one-dimensional ladder more or less wholesale, because it was the ladder we had.
Vendors reinforced it, because autonomy demos beautifully and quality doesn’t. “Watch the agent do the whole thing end-to-end” is a two-minute video. “The output cleared a nine-point rubric calibrated to an executive audience” is nearly invisible — you’d have to read the output slowly, against a standard, which is precisely what nobody does in a demo.
But the deeper reason is that single-axis thinking is comfortable, and moving to two axes has a track record of being the correction we tend to need. Amy Edmondson spent years dismantling the one-dimensional view of psychological safety — the assumption that safety and standards sat on a single slider, where more comfort meant less rigor. Her answer was a 2x2: psychological safety on one axis, performance standards on the other, and the learning zone only where both run high. The insight wasn’t either variable on its own. It was the orthogonality — that you can be high on one and low on the other, and that the failure modes live in exactly those off-diagonal quadrants.
Patty McCord made a similar move at Netflix with “context, not control.” Autonomy there was never a gift, and it was never the goal by itself. People earned freedom as they demonstrated judgment, while the quality bar — what excellent work looked like — was held firmly and separately. Freedom went up. The bar didn’t move down. Two axes.
AI-native operations, I’d argue, need the same correction, for the same reason: every interesting failure lives off the diagonal.
Three moves to separate the axes
1. Plot every workflow on both axes before you deploy anything else.
Take every AI workflow you run today and place it on the grid: autonomy across, quality gating up. Four quadrants fall out, and each one tells you something different.
- Low autonomy, no gate — a human reviews everything, against no defined standard. This is where a lot of programs actually live, and it may be the most deceptive quadrant, because it feels safe: the human in the loop is absorbing cost without enforcing a bar.
- Low autonomy, strong gate — good output, expensive to produce; a fine place to start, a costly place to stay.
- High autonomy, no gate — the risky quadrant, where confident mediocrity ships at machine speed.
- High autonomy, strong gate — the quadrant worth aiming at, where the system acts on its own and nothing surfaces below the bar.
The audit takes an afternoon. In our program, honestly placing the existing workflows was worth more than any roadmap we’d drawn, because it exposed how many things we’d called “mature” that were only unsupervised.
2. Make autonomy earned, not configured.
The x-axis should be climbed on a defined ladder — in our framework the rungs are suggest, draft, act-with-review, act-and-log — and the climb should be paid for with evidence, not enthusiasm. The mechanism we use: once a person has approved a workflow’s drafts a meaningful number of times without editing, the system itself offers the promotion — “Want me to just post these from now on?” Trust gets evidenced rather than assumed.
Two design choices matter here. Maturity is a vector, not a single number — a person can run level four on low-risk internal logging and deliberately hold level two on anything that drafts customer-facing language, and that asymmetry is judgment, not inconsistency. And the ceiling is held by the framework, not left to discipline: customer-facing work may never auto-act, no matter how much trust it has accrued internally. A rule you rely on people to remember is a rule you don’t really have.
3. Gate quality outside the workflow, not inside the prompt.
Here is where the y-axis gets its own machinery. The instinct is to stuff quality into the producing prompt — “be accurate, be concise, write for executives.” That’s the license trying to do the inspection’s job. It tends to fail for the same reason self-certification usually does: the producer grades its own work, and the standard lives buried in one prompt where no one else can see, version, or reuse it.
The alternative is to make quality a gate that stands outside the skill. The workflow produces a draft; a separate evaluation layer — with its own rubric, its own pass bar, its own owner — judges it; the draft revises against the critique; only then does anything surface to a human. In practice, the separation shows up right in the component’s manifest:
# skill manifest — note what this file does NOT contain
name: meeting-capture
type: skill
audience: internal
autonomy: # the x-axis
ladder: [suggest, draft, act-with-review, act-and-log] # semantics owned by the framework
current_level: act-with-review # per-user, promoted on evidence
promotion_trigger: 20_clean_approvals
ceiling: none # internal skill; external skills cap at act-with-review
quality: # the y-axis
gates: # evaluators are separate components,
- accuracy-check # owned and versioned independently
- concision-standard
- executive-writing # convened only when audience_tier >= director
surface_to_human: only_above_pass_barRead the two blocks. Nothing in autonomy says anything about how good the work is. Nothing in quality says anything about how independently the skill may act. You can move along either axis without touching the other — which is the whole point, and which is hard to do when both live tangled inside one prompt.
What I’m still working out
The honest caveat: I conflated these axes myself, publicly, for longer than I’d like. Earlier this year I wrote about leading with a 96% adoption number that turned out to be an anesthetic — and the maturity-level version of that mistake was subtler, so I was slower to catch it. “Level four” felt like an achievement in a way “cleared the executive-writing bar” didn’t, and I let the achievement that presented better crowd out the one that mattered more. I also don’t yet know how to calibrate starting autonomy levels well — our day-one assessment sets them by self-reported comfort, and comfort is a noisy proxy for judgment. That part of the design is still a guess with a feedback loop attached.
The whole game on two axes
Pull it back to the drawing. The license ladder and the vehicle inspection coexist because someone decided, structurally, that trust in the operator and fitness of the output were different questions requiring different machinery. Nobody argues about this at the DMV. It’s simply how a system that takes both seriously has to be built.
An AI-native operation is the same system with different nouns. The x-axis needs a ladder, evidence-based promotion, and a held ceiling. The y-axis needs rubrics, pass bars, and gates that stand outside the thing being judged. Build one without the other and you get either expensive supervision of mediocre work or unsupervised mediocrity at scale. Build both, and something changes in what your senior people spend their judgment on: not checking whether the machine’s work is acceptable, but doing the work only they can do.
I’ve started thinking about this as expanding from one number to two — where a workflow’s maturity is a coordinate, not a level, defined by where it sits on both axes at once. The next piece is about the y-axis’s machinery: why the evaluators, not the producing skills, may turn out to be the more valuable library. The one after that is about what a skill has to declare about itself before it’s allowed into the system at all.
For now, one exercise. Pick the most autonomous AI workflow in your organization — the one you’re proudest of, the one on the slide. Ask who last judged its output against a written standard, and when. If the only answer you can give is a level number, you’ve measured the license and skipped the inspection — and the road doesn’t care how confident the driver is.
