Five Levels, One Ladder

The five primitives tell you what to write when you direct an agent. They do not tell you how much to let go of afterwards. Two engineers can write identical problem statements and constraints, and one of them reviews every line the agent produces while the other reads a summary and ships. Same primitives, wildly different postures — and the difference between those postures is the single best diagnostic I know for where a person, a team or a whole organisation actually stands with agentic development. What the disciplines are to skill, autonomy is to trust, and it turns out trust comes in rungs.

The ladder I use is not mine. Dan Shapiro — the Glowforge CEO — published his Five Levels framework in January 2026, and I have found it the most honest map of the territory, precisely because it is calibrated to where people are rather than where the marketing says they should be. What follows is my paraphrase of his ladder and my own reading of why people get stuck on it; the framework, the coinages at either end and the estimates are his, and his post is worth reading in full.

The ladder, bottom to top

At the very bottom sits what Shapiro memorably calls spicy autocomplete: the human writes the code, and the AI suggests the next line or block for acceptance or rejection. It is assistance in the most literal sense — the human's mental model of the codebase remains the only one that matters, and the tool sharpens keystrokes rather than replacing judgement.

One rung up, the AI graduates to an intern. The human carves off a discrete, bounded task — write this function, add this test — and reviews everything that comes back, line by line. The unit of delegation is small enough that reviewing it costs less than doing it, which is what makes the rung feel safe and also what caps its leverage.

The middle rung is where the tools of the last two years live. The agent can navigate a codebase on its own: find the relevant files, trace the call paths, build a feature that spans modules. The human still reviews the output, but the output is now too large and too interconnected for line-by-line reading to be the real control — you are reviewing shape and complex sections, not every character. This is the rung most contemporary agentic tooling was built for, and Shapiro's estimate of its population is blunt:

“This is where 90% of ‘AI-native’ developers are living right now.”

That is his estimate, not a measurement — but it matches everything I see. The overwhelming majority of people who describe themselves as AI-native are directing capable agents on a rung where the human still owns the implementation in every way that matters.

The rung above is the first genuine inversion: the human stops touching the implementation at all and manages the agent the way a lead manages a team — reading diffs, approving, rejecting, redirecting. The code flows one way; the judgement flows the other. And of this rung Shapiro is equally blunt: "And almost everyone tops out here." His words, and again my experience agrees. Something about surrendering the diff itself — trusting a spec and a test suite instead of your own eyes on the code — is where the industry's collective nerve currently fails.

Above it, the human writes a specification, leaves, and comes back to check whether the acceptance criteria pass. And at the very top sits the rung Shapiro calls the dark factory — borrowed from manufacturing, where a lights-out factory runs with nobody on the floor. Software goes from specification to shipped system with humans evaluating outcomes and approving releases, not reading code.

The ceiling on each rung is a missing discipline

Here is my own contribution to the ladder, and it is the reason this part belongs in this series: at every rung, the ceiling is not the tools — it is whichever discipline from this series you have not built yet. Climbing is not a matter of daring; it is a matter of infrastructure.

The bottom rungs run on prompt craft alone, which is why they feel accessible and why they plateau. The middle rung — the one holding Shapiro's 90% — is where context engineering becomes the binding constraint: an agent can only navigate your codebase as well as the context you have engineered for it, and teams stuck there are almost always typing context in by hand, session after session. The diff-review rung is where harness engineering earns its keep — an agent that starts every session already knowing your conventions is reviewable at diff speed; one that reinvents your architecture every morning is not. And the rungs above that are unreachable without intent and specification engineering, because once you stop reading the code, the spec and the encoded intent are the only controls you have left. The disciplines are cumulative; so is the ladder. That is not a coincidence — it is the same stack viewed from two angles, skill on one axis and trust on the other.

This reframing matters because it converts an intimidating question — how do I learn to let go? — into an engineering one: which discipline is my current ceiling, and what would it take to build it? Letting go is not a character trait. It is what becomes safe once the layer below it exists.

The top rung, as built

The top of the ladder would be a thought experiment if nobody had built it. Someone has. StrongDM's Software Factory is the most documented working example of the top rung I know of — described in their own write-up and examined in Simon Willison's February 2026 analysis. The team is three people — Justin McCarthy, Jay Taylor and Navan Chauhan — formed around July 2025, and two of their design decisions are worth more than the headline.

The first is what they did with evaluation. The factory's behavioural scenarios are used to evaluate the software but not stored where the coding agents can see them. That is the holdout-set concept from machine learning applied to software delivery: if the agent can read the evaluation criteria, it can — and eventually will — game them, optimising for the test rather than the behaviour. Keeping the scenarios outside the codebase makes passing them mean something. If that sounds like primitive five from last week taken to its logical conclusion, it is exactly that: evaluation designed as seriously as the software it judges.

The second is the Digital Twin Universe: behavioural clones of the external services the software touches — Okta, Jira, Slack, Google Docs, Drive and Sheets — so agents develop and are evaluated against simulations rather than production systems. It is harness engineering at a scale most of us never attempt: not a context file describing the environment, but a rebuilt environment the agent can safely inhabit.

And the output is real. One released project from the factory — cxdb, their AI Context Store — comprises 16,000 lines of Rust, 9,500 of Go and 6,700 of TypeScript, shipped to production. A caution I want to place carefully, because the figures get repeated with the scope stripped: those numbers describe that one project, not the factory's total output. They are still, for a three-person team operating at the ladder's top rung, a remarkable proof that the rung holds weight.

A ladder, not a leaderboard

One reading of Shapiro's framework I want to argue against: the ladder is not a virtue scale, and the top rung is not the goal for every piece of work. The right rung is a function of the task — how completely its acceptance criteria can be written, how expensive a wrong outcome is, how much of the surrounding intent has been encoded. I run different work at different rungs in the same week, and so does everyone operating honestly. What the ladder gives you is not a target but a truthful mirror: where you actually are, what specifically is holding you there, and what it would cost to climb. The 90% are not failing. They are one unbuilt discipline away from the next rung, whether or not they want it.

Fourteen parts in, the stack is assembled: five disciplines, five primitives, one ladder. What remains is the part every honest series owes its readers — where all of this is thin, dated or simply unsolved. Next, what the stack does not solve.