The 5-Stage AI Adoption Map from Claude Code's Creator: The Bottlenecks That Stall Organizations, and How to Clear Them

On July 16, 2026, Boris Cherny, the creator of Claude Code, posted a single table on X. He titled it "Steps of AI Adoption", a map of how organizations adopt AI.¹ Cherny says he meets engineers at other companies every day and hears the same story. "One person has 10x'd their output with Claude, but the rest of the organization hasn't caught up yet." Watching teams adopt AI, Cherny noticed the same stages repeating every time. He laid those stages out as a five-row map running from 0 to 4. This article works through that table and post and adds Modern Web Labs' diagnostic perspective.

The three axes that separate the stages

Three things shift at every stage of Cherny's map: the number of agents running in parallel (1 → 10 → 100 → 1,000+), the engineer's role (pair programmer → orchestrator → manager of managers → VP who steers by intent), and where the bottleneck sits.

The core claim is this: "you cannot reach the next stage on token budget alone." Raising the usage budget does not move a team up on its own. Give a team that checks every output by eye ten times the tokens and it still works at the pace of a single agent. To move up, you have to find the next bottleneck, remove it, and put the next guardrail in place. In practice that means giving Claude the means to verify its own work end to end, turning auto mode on for permissions, making automated code review and security review the default, and working in an interface built to manage several agents at once. At higher stages, other tools take over that role. /loop, which repeats the same task on a schedule, /batch, which fans one task out across many items, and dynamic workflows that direct dozens or hundreds of subagents from a script all remove the bottleneck of "a human has to kick off every task." Git worktree (worktree) isolation, which hands each parallel agent its own copy of the repository, is the guardrail that keeps all that parallelism from colliding. No single feature does the work. Automation you can trust comes from pairing the right features with the right guardrails.

Stage 0 (Gated): organizations that have not started yet

Only legacy models or light, fast ones are available, and AI gateways and custom authentication add layer upon layer of latency. MCP governance does not exist, and access to internal AI tools is either blocked or buried in heavy process. No IT infrastructure or approval path exists for hosting the code and artifacts Claude produces, so its output never leaves local machines.

The bottleneck at this stage is not technology. It is legacy security and approval processes, a mindset that fixates on holding down cost per token rather than on outcomes, and the absence of genuine technical expertise at the decision-making table.

What helps at this stage

• Claude.ai chat

Guardrails

• SSO/SCIM and role-based access control

• Organization-level budget caps

• Deployment inside existing approval workflows and IAM

• Data governance package

The path from Stage 0 to Stage 1 runs through agreement among executives and procurement decision-makers, an escalation channel that carries bottlenecks up to leadership, and a framework for adopting Claude safely. In other words, the top of the org chart has to solve this one.

Stage 1 (Assisted): the engineer pairs with an agent

One engineer works with one agent, and the AI behaves like a fast pair programmer working under supervision. The engineer runs one session at a time and reviews almost every change by hand before merging.

At this stage you start buying back time. Work that used to eat a full afternoon is finished by the time you get back from a meeting.

The bottleneck is human attention. Trust in the model's output is low and nothing verifies that output automatically, so engineers feel obliged to read every response and every edited line, and they stay glued to the screen. The synchronous rhythm of the work is the other problem. Having handed a task to the AI, the engineer should move on to the next one instead of waiting, but sits and watches Claude work.

What helps at this stage

• Claude Code (desktop, CLI, IDE)

• Claude Cowork, Claude Design

• Working through the Anthropic API, Bedrock, Vertex, or Microsoft Foundry

• The Claude Code analytics dashboard and the Analytics API

• The Compliance API for Claude Enterprise

• Plan mode, which lets you review intent before any edits

Guardrails

• Per-user spending limits (distinct from organization-wide budget caps)

• Centrally managed settings and policy for model choice and reasoning effort

• Integrating OpenTelemetry into your existing SIEM and observability stack

Moving from Stage 1 to Stage 2 requires four things: running more than one agent at a time, building a self-verification loop you can trust (tests, builds, lint, and end-to-end tests against a real development environment), turning auto mode on so permission prompts stop blocking progress, and automating code review.

Stage 2 (Parallel): becoming an orchestrator

A single engineer runs 5 to 10 agents at once. Each agent has its own worktree or a separately cloned copy of the repository, and the engineer moves between them. Claude checks its own work with tests, builds, lint, and security scans before a human sees any of it. Auto mode stays on, and automated code review and security review are the defaults. Engineer output multiplies, review shifts from keystrokes to final diffs, and the maintenance backlog starts to shrink. Claude writes most of the code.

What this stage unlocks is scale. A backlog that would have taken a team weeks clears in half an afternoon under one engineer's orchestration.

The bottleneck shifts to reviewing output. Engineers write less code themselves and spend more time inspecting streams of code arriving from every direction. Prompting and steering the model across many sessions becomes work in itself.

What helps at this stage

• Auto mode, Agent view

• Claude Code Review, Claude Security Review

• Mobile Claude Code and cloud execution on the desktop (sessions run in the cloud instead of the local machine, so work continues even when the laptop is closed)

• Using Claude Teams and Claude Enterprise

• Claude Tag (single-task delegation)

• Worktree isolation in the CLI and desktop

• Remote control to monitor agents from a phone

Guardrails

• Analytics for monitoring team usage

• Automated code quality enforcement (lint, automated tests, type checks)

• Claude-driven end-to-end verification (using the Claude Chrome extension or iOS and Android simulator MCPs)

• Manual code review, merge, and security review. Apply the same quality bar to human-written and agent-written code

• Pre-approve safe bash and MCP commands in settings.json

Moving from Stage 2 to Stage 3 means giving Claude access to code, wiki pages, and internal discussion so it can pull its own context. Maintenance that runs in the background will inevitably touch code other teams own, so agents need the discretion to act beyond team boundaries, and cross-team code review has to keep pace with agent output. You also have to break work into loops and routines, and go as far as letting Claude run Claude.

Stage 3 (Supervised autonomy): becoming a manager of managers

Claude writes all or nearly all of the code. The engineer's question shifts from "Did you read the code?" to "What context did the model lack, and how do we fix that next time?" This is the point where the unit of quality control moves from code review to the system that supplies context.

At this stage Claude moves first. Work that once needed an engineer to kick it off now starts on Claude's own initiative. Maintenance and cleanup that only got done when someone found the time now runs continuously in the background.

The bottlenecks are trust in the loops and the team's decision throughput. By Stage 3, the agent tree is too deep for an engineer to look after every agent individually. The trap here is scaling up the number of agents before the loops have earned enough trust. As usage grows, you also have to watch whether the tokens are going to good use. Monitor with OpenTelemetry or Analytics. While a use case is still experimental, accept some token waste and encourage exploration, but once a piece of internal automation has proved itself and the whole team depends on it (internal product-market fit, PMF), the culture has to shift toward optimizing that use case for cost. To decide whether an agent's work is worth the tokens, Cherny suggests one question: "Would a human engineer have spent time on this anyway?" If the answer is yes, tokens are replacing engineering time. If not, you are spending tokens on busywork the agent invented.

What helps at this stage

• Subagents with worktree isolation (so parallel agents do not collide)

• Routines and /loop, /batch, /goal to reduce repetitive work

• Dynamic workflows

• Claude Tag (monitors channels and data sources, and Claude starts work on its own)

Guardrails

• Automated code review, automated security review

• Agent sandboxing

• Document team standards with CLAUDE.md and Skills

• Tune the auto mode classifier to match team usage patterns

• Model selection, advisor tool, and LSP usage

  • Advisor tool: a smaller model runs the work and asks a larger model only for the hard judgment calls

  • LSP: code intelligence over the Language Server Protocol that pinpoints definitions and references, sparing the tokens spent reading whole files

• Split CLAUDE.md into Skills to manage token usage

  • See the instruction budget guide

The condition for moving from Stage 3 to Stage 4 is large-scale automation of domain-specific use cases. Beyond the general-purpose pattern of a human defining each task as it comes up, you have to pick the work that recurs in your organization, such as code migrations, fuzzing (testing with random inputs to find defects), feature development, and feedback processing, and turn each one into a dedicated pipeline with validation and guardrails built in.

Stage 4 (AI-native): becoming a VP who steers by intent

The loop is fully closed, and most agents run through Claude. Hundreds to thousands of agents run at once, and people no longer dispatch tasks one by one. They set goals and direction (steer by intent), let work that is progressing normally run untouched, and hear back only about the exceptions that fall outside the criteria (monitor by exception).

What this stage unlocks is a shift in time scale. A migration that used to consume an entire quarter becomes a "kick it off and check in on it" workflow.

The bottleneck is identifying what to automate at scale, and enforcing guardrails suited to each kind of work. Helpful tools include the Claude Agent SDK, which lets you create and schedule agents programmatically, and Claude Tag, which answers Slack posts on its own. Automation spend and model selection become the guardrails.

The five stages at a glance

How to measure the impact of adoption

Once a team starts moving up the stages, how do you track the impact? Cherny grants that usage dashboards are worth watching, but usage measures activity, not return. A better question is this: "Would engineering resources have been spent on this anyway? If so, how many hours would it have taken by hand, and what would it have cost?" That difference is the return on AI adoption.

The bigger reward comes next. Once fixes and maintenance run in the background and the team can focus on building, it starts attempting work no one could have imagined before. According to Cherny, Anthropic as an organization sits at Stage 3 and is moving toward Stage 4; he himself has just reached Stage 4.¹

Modern Web Labs' view: this map is most valuable as a diagnostic tool

Some of the organizations Modern Web Labs works with sit between Stage 0 and Stage 2. That is because much of our work is with heavily regulated domains such as semiconductors, automotive, defense, and finance, where we also train the decision-makers. In these industries, Stage 0 is not where an organization lingers out of laziness. It is a structurally enforced starting point, where regulation and industry-wide technical constraints block approval of the latest models and stretch out security reviews.

Even in those cases, Modern Web Labs designs a path that can start inside the constraints. The tools laid out in the Stage 0 row are the starting point: deployment inside existing approval processes and IAM, data governance readiness, and organization-level budget caps. Some organizations do practice parts of Stages 2, 3, and 4 at the team level, running several agents in parallel or making automated code review the default.

That said, set against the whole map, those organizations are only ahead on a few elements. It is hard to say they have settled into that stage as an organization. If the bottleneck described at Stage 0 sounds familiar, the first move is not tool training but executive alignment and a cleanup of the approval framework. For a team already settled at Stage 1, the next investment is not better prompts but self-verification loops (test, build, lint, e2e) and automated code review. Only once a verification system you can trust is in place does the pressure of "I have to read everything" lift and parallelization begin.

Modern Web Labs also runs training that walks teams settled at Stage 1 through this transition hands-on. We work directly on the skills that move a team up to Stages 2 and 3: test-driven development to build self-verification loops, delegating to agent teams, and standardizing Skills and CLAUDE.md across the team. For a team that has reached Stage 2, the remaining bottleneck is not tooling but trust. The shortcut to Stage 3 is to hold the agent count steady until the loop has earned that trust.

The virtue of this map is that it names the next problem to solve at every stage. Start by diagnosing which stage your team is at and whether the bottleneck to the next one is process, trust, or tooling. If you are curious about the tools for Stage 3, Modern Web Labs' loop engineering guide and dynamic workflows write-up are a good place to start. For the Stage 3 guardrail of managing token cost, the caching design from the engineer who built Claude Code can help your organization find its own answer.

1. Boris Cherny (@bcherny), I talk to engineers at other companies every day…, X, 2026-07-16. The original table is Steps of AI Adoption.

   ↩