Update — July 19, 2026: @ClaudeDevs extended Claude Code weekly limits 50% higher through August 19 — relevant for Step 2–3 parallel agent adoption where quota is the bottleneck. Not permanent. July 18 retention guide
Update — July 17, 2026: Kr$na's viral final 10% dev cycle chart — 5-minute idea, 2-hour demo, 6-month polish — maps Step 1–2 (fast yellow demos) vs Step 3+ (red-bar verification in the background).
On July 16, 2026, Boris Cherny — creator of Claude Code — published Steps of AI Adoption on Anthropic's site. Lance Martin reposted it July 17; the thread hit 251K+ views in hours. Cherny's thesis: he talks to engineers daily who see one person 10× output while the rest of the org stays gated — and the gap is not "more tokens," it is bottlenecks and guardrails per maturity step.
Cherny mapped five steps (0–4): from legacy approval gates with zero agents to AI-native intent steering with 1,000+ agents where Claude kicks off most loops. Anthropic says it operates at Step 3; Cherny claims he personally hit Step 4.
This post translates Cherny's framework into a builder checklist — with product names, bottlenecks, and links to explainx.ai's loop engineering and Claude Code loops guide corpus.
TL;DR — the five steps at a glance
| Step | Name | Your role | ~Agents | Unlock | Main bottleneck |
|---|---|---|---|---|---|
| 0 | Gated | — | 0 | — | Legacy security, cost-per-token mindset, no approval path |
| 1 | Assisted | You + agent (pair) | ~1 | Afternoon task → between meetings | Your attention; must read every edit |
| 2 | Parallel | Orchestrator | ~10 | Team-week backlog → one afternoon | Reviewing many streams; steering prompts |
| 3 | Supervised autonomy | Manager of managers | ~100 | Background maintenance runs continuously | Trust + decision throughput; token efficiency |
| 4 | AI-native | VP steering by intent | 1,000+ | Quarter migration → kickoff + monitor | Automating work at scale; per-task guardrails |
Cherny on X: "There's no one right path through the steps… at each step, tokens aren't enough… you need to find and break down the next set of bottlenecks, and build up the next set of guardrails."
Step 0 — Gated (zero agents)
What it looks like: Only older or lighter/faster models are approved. Latency stacks through AI gateways and custom auth. No MCP governance. Internal access to AI tools is gated or process-heavy. Claude-generated code or artifacts have no IT path to host — outputs stay local only.
Bottleneck: Legacy security and approval processes; orgs optimize cost-per-token containment instead of outcomes; lack of technical voices in procurement decisions.
Products Cherny lists:
- Claude.ai chat (not full agent stack)
- SSO/SCIM + role-based access
- Org-level budget caps
- Deploy inside existing approvals / IAM
- Data governance package
How to reach Step 1: Executive or buyer alignment, escalating blockers, and frameworks for launching Claude securely — not buying more seats.
For enterprises still here after Fable export controls, Step 0 often means region-locked chat while engineering pilots Claude Code on personal machines. That mismatch is exactly what Cherny describes when one engineer 10×'s and the org chart says "not approved."
Step 1 — Assisted (~1 agent, supervised pair)
What it looks like: One engineer, one agent — a fast pair programmer. You run one session at a time and review almost every change before merge.
Unlock: A change that used to fill an afternoon becomes something you finish between meetings.
Bottleneck: Your attention and low trust. Without a self-verification loop you believe you must read everything — work stays synchronous: you watch Claude work instead of starting the next task.
Products:
- Claude Code (Desktop, CLI, IDE)
- Claude Cowork, Claude Design
- API via Anthropic, Bedrock, Vertex, or Microsoft Foundry
- Claude Code analytics dashboard + Analytics API
- Compliance API (Enterprise)
- Plan mode — review intent before edits
- Per-seat spend caps, centrally managed model/effort settings and policy
- OpenTelemetry export into SIEM/observability
Guardrails: Plan mode, spend caps, centralized policy, OTel into existing stacks.
How to reach Step 2:
- Run more than one agent at a time
- Build a self-verification loop you trust — tests, build, lint, e2e in a real dev environment
- Enable auto mode to avoid blocking permission prompts
- Automate code review
Pair with Claude Code model vs effort — Step 1 teams often burn tokens on max effort while still reviewing every line manually.
Step 2 — Parallel (~10 agents, orchestrator)
What it looks like: One engineer orchestrates 5–10 agents on separate worktrees or git checkouts, jumping between sessions. Claude checks its own work — tests, build, lint, security scan — before you see diffs. Auto mode always on. Automated code review and security review default on. Claude writes most of the code; you review final diffs, not keystrokes. Maintenance backlogs start shrinking.
Unlock: A backlog that used to take the team weeks becomes one engineer's afternoon of orchestration.
Bottleneck: Reviewing output — six streams of diffs instead of one. Prompting and steering as you juggle sessions.
Products:
- Auto mode
- Agent view (CLI + Desktop)
- Claude Code Review
- Claude Security Review
- Claude Code on Mobile, cloud execution in Desktop
- Claude Teams / Enterprise
- Claude Tag (single task)
- Worktree isolation (CLI + Desktop)
- Remote control — monitor agents from phone
- Analytics for team usage
- Automatic lint, tests, typecheck
- Claude-powered e2e verification (Chrome extension, iOS/Android simulator MCP)
Guardrails: Manual merge still required; same quality bar for human and agent code; pre-approve safe bash and MCP commands in settings.json.
How to reach Step 3:
- Give Claude context pull — code, wikis, discussions
- Fix agency + code review speed when agents touch other teams' code
- Break work into loops and routines — see loop engineering guide and official /goal, /loop, /schedule taxonomy
- Let Claude kick off Claude — subagent fan-out
This is where explainx.ai's should developers stop reviewing AI code? debate lands: Step 2 still reviews, but the unit of review shifts from tokens typed to harness output.
Step 3 — Supervised autonomy (~100 agents, org tree)
What it looks like: Claude writes all or nearly all code. "Did you read the code?" becomes "what context was the model missing and how do we fix it next time?" Proactive maintenance runs in the background — cleanup that waited for someone with time now runs continuously.
Unlock: Work you would have kicked off manually now starts proactively.
Bottleneck: Trust in the loop and team decision throughput. The agent tree is too deep to babysit — scaling agent count before the loop earns widespread trust is the trap. Token efficiency at scale requires OTel or Analytics and a culture that experiments then controls cost after PMF.
Cherny's test: "Is this something an engineer would have done?"
Products:
- Subagents + worktree isolation
- Routines,
/loop,/batch,/goal - Dynamic workflows — see dynamic workflows GA
- Claude Tag — monitor a channel or data source, kick off tasks
- Automatic code + security review
- Agent sandboxing
CLAUDE.mdand Skills for standards — skills registry- Tune auto mode classifier from team usage
- Token controls: model selection, advisors, LSPs, lazy Skills vs bloated root
CLAUDE.md
Guardrails: Sandboxing, encoded standards, cost monitoring, proactive routines scoped to well-defined streams (bug triage, dependency upgrades, migrations).
How to reach Step 4: Scaled automation of domain use cases — code migration, fuzzing, feature-building, feedback remediation. Code with Claude Tokyo shipped managed agents, scheduling, and vaults as infrastructure for this step.
For advisor + executor splits (Fable plans, Sonnet executes), see Fable advisor + Sonnet executor — a common Step 3 pattern before full autonomy.
Step 4 — AI-native (1,000+ agents, intent steering)
What it looks like: The loop is fully closed. Most agents are kicked off by Claude, not humans. Hundreds to thousands of agents run; you steer by intent and monitor by exception.
Unlock: A quarter-long migration becomes a workflow you kick off and check on.
Bottleneck: Identifying and automating work at scale while enforcing the right guardrails per work type — not one blanket policy.
Products:
- Claude Agent SDK — programmatic build and schedule agents; see programmatic usage credits
- Claude Tag active in most Slack channels, auto-responding
- Cost controls for automation
- Model selection for automation (cheaper models for bulk, frontier for judgment)
Guardrails: Per-workflow cost caps, exception-based monitoring, separation between automation lanes (migrations, triage) and human-gated lanes (production deploys, security-sensitive refactors).
Cherny wrote Anthropic is pushing toward Step 4; he personally claimed Step 4 on July 17, 2026. Treat that as internal dogfooding signal, not a guarantee your team can copy day one without Step 2–3 harness investment.
What Cherny emphasized on X (July 17)
Beyond the table, Cherny's thread named concrete advance requirements:
| Theme | Cherny's guidance |
|---|---|
| Verification | Give Claude ways to verify its own work end to end |
| Permissions | Auto mode for permissions; pre-approve safe commands |
| Review defaults | Automated code review + security review on by default |
| Multi-agent UI | Agent view in CLI, Desktop, iOS — manage multiple agents |
| Background payoff | Fixing and maintaining in the background; teams focus on building |
| No universal path | Every team different — break bottlenecks, don't just buy tokens |
When the published page had Safari scroll bugs, Cherny pointed to a Google Doc mirror of the same framework — worth bookmarking if the claude.ai page misbehaves.
Mapping Cherny's steps to explainx.ai coverage
Where is your team — honest self-assessment
Cherny's ladder is descriptive, not a certification. Common misreads:
| Misread | Reality |
|---|---|
| "We bought Enterprise so we're Step 3" | Step 0–1 is about behavior, not SKU — one supervised session is still Step 1 |
| "We run 10 Cursor tabs so we're Step 2" | Step 2 requires self-verification, auto mode, and automated review — not just parallel chats |
"We enabled /loop so we're Step 4" | Proactive loops without trust + cost controls is Step 3 at best — often Step 2 with extra tokens |
| "One 10× engineer means the org is advanced" | Cherny's opening observation — individual heroics without guardrails widens internal inequality |
Run Cherny's question at Step 3+: would an engineer have done this task? If yes, automate. If no, keep a human gate.
Summary
Boris Cherny's Steps of AI Adoption (July 16, 2026) names five maturity levels for Claude Code teams: Gated (0) → Assisted (~1) → Parallel (~10) → Supervised autonomy (~100) → AI-native (1,000+). Each step defines your role, the unlock, the bottleneck, Anthropic products, and guardrails to advance. Tokens alone do not move you forward — verification loops, auto mode, automated review, worktree isolation, routines, and cost monitoring do. Anthropic reports Step 3 org-wide; Cherny claims Step 4 personally. Map your team by behavior, not license tier.
Related on explainx.ai
- Claude Code loops official guide — /goal, /loop, /schedule
- Loop engineering for coding agents
- Should developers stop reviewing AI-generated code?
- Claude Code dynamic workflows
- Code with Claude Tokyo — managed agents and scheduling
- Claude Code commands reference + /checkup
- Fable advisor + Sonnet executor setup
- Claude Reflect usage dashboard and AI fluency
- kache — programming as low-intelligence drudgery debate
- Agent skills complete guide
Official sources: Steps of AI Adoption (Boris Cherny, Jul 16, 2026) · @bcherny X thread (Jul 17, 2026) · Claude Code docs
Framework accurate as of July 17, 2026 per Boris Cherny's published adoption ladder and X commentary. Product names and step definitions may change — verify on Anthropic's Claude Code documentation before planning enterprise rollouts.