This week Boris Cherny, the creator of Claude Code, published a five-step ladder for enterprise AI adoption: Gated, Assisted, Parallel, Supervised autonomy, AI-native. Zero agents at the bottom, a thousand-plus at the top. It’s the clearest public attempt yet at turning “how mature are we with AI coding” into something measurable, and most of the underlying observations hold up. Tokens alone don’t move a team forward. Trust and verification loops do.
But the ladder was written from inside Anthropic, where the harness already exists. CLAUDE.md conventions, skills, sandboxing, hardening, review automation: all of it is ambient there, built by the people who built the product. Climb the same ladder from inside an enterprise that starts with none of that, and the first three rungs stop describing what actually happens.
The ladder assumes somebody already built the harness
Cherny’s own step three lists CLAUDE.md and Skills as something a team picks up on the way to a hundred agents. That’s true if you’re already running Claude Code inside the company that ships Claude Code. It’s not true anywhere else.
In most enterprises, nobody has written the rules, the skills, the hardening swarm, or the discovery agents that make an orchestrator’s job possible in the first place. Somebody has to build that, alone, before a single colleague “adopts” anything. That’s not step one on Cherny’s ladder. It’s step zero, and it doesn’t appear on it at all.
Agent count is measuring the wrong thing
This is the part worth arguing loudest. Cherny’s ladder uses roughly how many agents you’re running as the headline signal of maturity: ~1, ~10, ~100, 1,000+. To his credit, he warns against the obvious misread, turning on a loop doesn’t make you AI-native. But there’s a subtler version of the same problem his own model doesn’t catch.
A properly built factory spawns agents on its own. A hardening swarm fans out to close a build. A discovery pass fans out to map a codebase before anyone writes a line. Neither requires a human to orchestrate anything. It happens because the harness was built to do it.
So two teams can both show ten agents running and sit at opposite ends of the maturity scale. One is a person genuinely juggling ten worktrees. The other is a single, fairly junior adopter who kicked off a build while the factory did the multiplying for them. Same number. Opposite reality. Count agents and you can’t tell them apart.
Where the real rungs are
Enterprise adoption doesn’t run in a straight line from one agent to a thousand. It runs in four stages, and flattening them is the actual risk.
| Level | Name | Who’s doing the work | What maturity actually means | The trap if you skip it |
|---|---|---|---|---|
| 1 | Foundation | One builder | CLAUDE.md, skills, rules, hardening swarm and discovery agents get built before anyone else touches the tool | Calling a tool with no standards behind it “a factory” |
| 2 | Adoption | The team | Learning to work inside the harness: managing context, knowing when to reach for a plugin, reading what the rules and skills are actually doing | Mistaking a high agent count for orchestration skill, when the swarm did the multiplying |
| 3 | Platform governance | The builder, plus one | A named function with the authority to change the factory, whose job is spotting what’s broken in it and shipping the fix | Assuming “someone noticed a problem” is the same as “someone owns fixing it” |
| 4 | Operating model | The factory team | Evals, tokenomics (not just token awareness), agentic safety, and autonomy-versus-human-in-loop become continuous practice | Treating cost and safety as a launch checklist instead of ongoing governance |
Levels two and three get flattened into one step in most public frameworks, Cherny’s Parallel and Supervised autonomy pair included. They’re not the same skill. Learning to use a factory competently is a training problem. Having the authority to change it is an org design problem, and in practice it starts as two people, not a department.
Two ladders, not one
None of this makes Cherny wrong about what he’s describing. His ladder is a genuinely useful measure of practitioner autonomy once the harness exists, and that’s the world he’s writing from. Anthropic dogfoods its own tooling harder than almost anyone will.
What it doesn’t cover is the lifecycle that produces the harness in the first place: build it, get a team to adopt it, hand governance to a small function, mature that function into an operating model. That lifecycle is the part every enterprise without Anthropic’s head start actually has to run, and it’s the part that determines whether the top of either ladder is reachable at all.
I’ve built one of these factories inside a live enterprise, not a demo, not a sandbox. The order was never “run more agents.” It was build, adopt, govern, mature, in that sequence, with the governance rung staffed by two people for far longer than anyone expected. If you’re benchmarking your team against a public ladder and the number of agents you’re running is the headline metric, you’re measuring the wrong rung.
This is the same discipline behind how the Code Factory works: the harness gets built and hardened before a single production line ships. If you’re trying to work out which rung you’re actually on, let’s compare notes.