4 Steps of AI Adoption

Boris Cherny’s map of how teams go from “one person 10× with Claude” to org-wide AI-native work — bottlenecks, guardrails, and real ROI

← Boris Cherny hub · AI Agents · AI · Loops, Not Prompts

Source & Credit

Framework from Boris Cherny (@bcherny), creator of Claude Code at Anthropic — July 2026.

Original thread: x.com/i/status/2077929379661844559 (“Steps of AI Adoption”).

He talks to engineers daily and keeps hearing the same thing: one person is 10×’ing with Claude, but the rest of the org hasn’t caught up. Watching teams adopt AI, he keeps seeing the same steps. Anthropic as an org sits around step 3 and is pushing toward 4; he says he personally hit level 4.

The Core Thesis

There’s no one right path through the steps. Every team and company is different. But at each step, tokens aren’t enough to move you forward: you need to find and break down the next set of bottlenecks, and build up the next set of guardrails.

More seats and more spend do not automatically create step 2 or 3 behavior. Moving up means verification, permissions, review defaults, multi-agent interfaces, and later loops/batch/workflows your team can trust.

At a Glance (Steps 0–4)

Boris calls them “4 steps”; the map usually includes a baseline Step 0 — Gated (no real agent access). Five maturity levels total.

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	Steer by intent	1,000+	Quarter migration → kickoff + monitor	Automating work at scale; per-task guardrails

Step 0 — Gated

Only older/lighter models approved, heavy gateways and process, little MCP governance, generated code has no safe path to host — outputs stay local. Orgs optimize cost-per-token containment instead of outcomes.

How to leave Step 0: executive alignment, escalate blockers, secure launch frameworks — not “buy more seats.”

Step 1 — Assisted (~1 agent)

One engineer, one agent — pair programmer. You review almost every change. Unlock: afternoon work finishes between meetings.

Bottleneck: your attention and low trust. Without self-verification, work stays synchronous — you watch Claude instead of starting the next task.

Tools / practices: Claude Code (CLI, Desktop, IDE), Plan mode, spend caps, centralized policy, analytics.

To reach Step 2: more than one agent; self-verification loop (tests, build, lint, e2e); auto mode for permissions; automate code review.

Step 2 — Parallel (~10 agents)

You orchestrate multiple agents (often worktrees/checkouts). Claude checks its own work (tests, build, lint, security) before you see diffs. Auto mode on. Automated code + security review default on. You review final diffs, not keystrokes.

Unlock: a team-week backlog becomes one engineer’s afternoon of orchestration.

Bottleneck: reviewing many streams; prompting and steering while juggling sessions.

In practice (from Boris’s thread): give Claude end-to-end verification; enable auto mode; default automated review; use interfaces that manage multiple agents (Agent view in CLI, Desktop, iOS/Android, Tag).

To reach Step 3: better context pull; faster agency + review when agents touch other teams’ code; break work into loops/routines; let Claude kick off Claude (subagent fan-out).

See Stop Babysitting Your Agents and agentic setup checklist.

Step 3 — Supervised Autonomy (~100 agents)

Claude writes most or all of the code. “Did you read every line?” becomes “what context was missing and how do we fix the loop next time?” Proactive maintenance runs in the background.

Unlock: work that used to wait for someone with spare time now starts continuously.

Bottleneck: trust in the loop and decision throughput. Scaling agent count before the loop earns trust is the trap. Token efficiency needs observability and a culture that experiments, then controls cost.

Higher-level features: /loop, /batch, dynamic workflows, worktree isolation for subagents, routines, CLAUDE.md + skills for standards — not one magic feature, but the right features with guardrails.

See Loops, Not Prompts, Building AI Agent Loops, CLAUDE.md, skills.

Step 4 — AI-Native (1,000+ agents)

The loop is largely closed. Most agents are kicked off by Claude, not humans. You steer by intent and monitor by exception.

Unlock: a quarter-long migration becomes kickoff + monitor.

Bottleneck: identifying and automating work at scale with the right guardrails per work type — not one blanket policy.

The bigger payoff (Boris): fixing and maintaining happens in the background; teams focus on building. You start doing things that weren’t even in range before.

How to Measure (Not Just Usage)

Usage dashboards measure activity, not return. Better questions:

Would you have spent engineering effort on this anyway?
If yes — how much, and what would it have cost in manual eng-hours?
That’s your return.

Cherny’s Step 3+ test: “Is this something an engineer would have done?” If yes, automate. If no, keep a human gate.

Honest Self-Check

Misread	Reality
“We bought Enterprise → Step 3”	Step is about behavior, not SKU. One supervised session is still Step 1.
“We run 10 tabs → Step 2”	Step 2 needs self-verification, auto mode, automated review — not just parallel chats.
“We enabled /loop → Step 4”	Proactive loops without trust + cost controls is Step 3 at best.
“One 10× engineer → org is advanced”	That’s Boris’s opening problem: heroics without shared guardrails widen the gap.