# cherny-steps-ai-adoption-2026-07-16

## Veille

**Boris Cherny** (Creator & Head of Claude Code @Anthropic) publishes a framework table on LinkedIn, **« Steps of AI Adoption »**, mapping an engineering team's adoption of agentic AI across **5 stages (0→4)**, each characterized by an **order of magnitude of agents driven** and a **transformation of the engineer's role**: **0 Gated** (0 agents, locked-down access), **1 Assisted** (~1 agent — "you + one agent", supervised pair programming), **2 Parallel** (~10 agents — **orchestrator**), **3 Supervised autonomy** (~100 agents — **manager of managers**, an org tree), **4 AI-native** (~1,000+ agents — **VP steering by intent**). The table crosses five columns: number of agents, *what it looks like*, *the bottleneck*, *the products that help*, *the guardrails*. **Central thesis**: consuming more tokens does not move you up a level — advancing to the next stage requires **identifying and breaking the next bottleneck** AND **building the next set of guardrails**. Concretely: giving Claude a trustworthy **self-verification loop** (tests + build + lint + e2e on a real environment), enabling **Auto mode** (avoiding blocking permission prompts), making **code review and security review the default**, adopting multi-agent interfaces (Agent view CLI, Desktop, iOS/Android apps, Tag), then `/loop`, `/batch`, `/goal`, **dynamic workflows** and **worktree isolation** for subagents. On steering: usage (dashboard) measures **activity, not return**; the right question is *"would we have spent engineering effort on this anyway? if so, how many manual engineer-hours would it have cost?"* — that's the ROI. The real payoff arrives when **fixing and maintaining happens in the background** and teams focus on *building*. Anthropic sits at **stage 3, heading toward 4**; Boris Cherny states he has personally reached **level 4**.

## Titre Article

Steps of AI Adoption (tableau/artifact + post LinkedIn « I talk to engineers at other companies every day… »)

## Date

2026-07-16

## URL

https://www.linkedin.com/posts/bcherny_i-talk-to-engineers-at-other-companies-every-share-7483695057200615424-6hA0/

## Keywords

Boris Cherny, Claude Code, Anthropic, Steps of AI Adoption, AI adoption, maturity model, AI maturity scale, agentic AI, coding agents, agents driven, role transformation, pair programming, orchestrator, manager of managers, VP steering by intent, steering by intent, monitoring by exception, bottleneck, guardrails, guardrails, bottleneck, tokens aren't enough, self-verification loop, self-verification loop, tests build lint e2e, Auto mode, permission prompts, automated code review, automated security review, Agent view, Claude Code Review, Claude Security Review, Claude Cowork, Claude Design, Plan mode, worktree isolation, git checkout, Claude Code Mobile, cloud execution, Remote control, Claude Tag, Claude Teams, Claude Enterprise, Compliance API, Analytics API, dashboard analytics, OpenTelemetry, OTel, SIEM, observability, /loop, /batch, /goal, Routines, dynamic workflows, subagents, agent sandboxing, CLAUDE.md, Skills, lazy Skills, encoding standards, Auto mode classifier, token use, model selection, advisors, LSP, Claude Agent SDK, agent scheduling, code migration, fuzzing, feedback remediation, MCP governance, SSO SCIM, RBAC, budget caps, IAM, data governance, AI ROI, activity vs return, engineer-hours, internal PMF, stage 0 Gated, stage 1 Assisted, stage 2 Parallel, stage 3 Supervised autonomy, stage 4 AI-native, agent tree, trust in the loop, decision throughput, background maintenance

## Authors

Boris Cherny (Creator & Head of Claude Code @Anthropic)

## Ton

**Profile**: practitioner-leader framework in the form of a **maturity table** (Claude artifact, dated July 16, 2026) accompanied by a narrative LinkedIn post. Addressed to engineering leaders and decision-makers who observe that "one person gets a 10x output boost with Claude but the rest of the org hasn't followed". Operational register, non-prescriptive about the path (« There's no one right path ») but very precise about the **mechanisms** for moving from one tier to the next.

**Style**: dense 5-stage × 5-column matrix (number of agents, what it looks like, bottleneck, products, guardrails), interspersed with **« How to get from step X to Y »** lines. Each stage carries an **Unlock** (the concrete gain it unblocks) and explicitly names the next **bottleneck** — the argumentative structure is "diagnose the blocker → products + guardrails to lift it". An assumed position of authority (the author *is* the Head of Claude Code, backed by the product catalogue), tempered by honest benchmarks: Anthropic itself is only at stage 3, and the proposed success metric (engineer-hours saved) rejects the vanity of raw usage. Throughline: progress isn't a matter of isolated *features* or *tokens*, but of **bottlenecks broken + guardrails built** that let the team *trust* the output.

## Pense-betes

- **Core idea: you don't move up a level by spending more tokens.** Each tier has its own **bottleneck**; moving to the next requires *breaking it* AND *building the next set of guardrails* that makes the output trustworthy. « It's not about a single feature, but rather using the right features with the right guardrails. »
- **The model's backbone = the order of magnitude of agents driven, and the role it imposes.** 0 → ~1 → ~10 → ~100 → ~1,000+ agents, i.e. blocked engineer → **pair programmer** → **orchestrator** → **manager of managers (org tree)** → **VP steering by intent**. That's the table's true "essence": an exponential rise in parallelism that *transforms the job*, not just velocity.
- **Stage 0 — Gated (0 agents).** Only older/lightweight approved models, latency piling up through gateways + custom auth, no MCP governance, locked-down/process-heavy access, **no infrastructure to host code produced by Claude** (outputs stay local). *Bottleneck*: legacy security/approvals, an obsession with **cost-per-token** at the expense of *outcomes*, no real technical voices in the decision. *Product*: Claude.ai chat. *Guardrails*: SSO/SCIM + RBAC, org budget caps, deployment within existing approvals/IAM, data governance. **0→1**: executive/buyer alignment, escalating blockers, frameworks to launch Claude safely.
- **Stage 1 — Assisted / "you + one agent" (~1).** One engineer, one agent, almost everything supervised (fast pair programmer), one session at a time, reviewing nearly every change before merge. *Unlock*: what used to fill an afternoon now wraps up between two meetings. *Bottleneck*: **your attention** — low trust + no self-verification → you read everything, **synchronous** work (you watch Claude instead of moving on). *Products*: Claude Code (Desktop/CLI/IDE), Cowork, Design, usage via API/Bedrock/Vertex/Microsoft Foundry, dashboard + Analytics API, Compliance API, **Plan mode**. *Guardrails*: per-seat spend caps, centrally managed model/effort and policy, **OpenTelemetry** export to the SIEM.
- **1→2 (key transition):** running **several agents at once**; a trustworthy **self-verification loop** (tests + build + lint + **e2e on a real dev environment**); **Auto mode** to stop being blocked by permission prompts; **automating code review**.
- **Stage 2 — Parallel / Orchestrator (~10).** An engineer orchestrates **5–10 agents** in parallel, each on its own **worktree/git checkout**. Claude verifies its own work (tests, build, lint, security scan) *before* you see it; **Auto mode always on**; **code review + security review by default**. You review **final diffs, not keystrokes**; the maintenance backlog shrinks; Claude writes *most* of the code. *Unlock*: a multi-week backlog becomes an engineer's afternoon of orchestration. *Bottleneck*: **reviewing** (checking six parallel streams) + juggling prompting/steering. *Products*: Auto mode, Agent view, Claude Code Review, Claude Security Review, Claude Code Mobile + Desktop cloud execution, Claude Tag (an isolated task), worktree isolation CLI/Desktop, **Remote control** (steering from your phone). *Guardrails*: team usage Analytics, quality enforcement (lint/tests/typecheck), **Claude-powered e2e verification** (Chrome extension or iOS/Android simulator MCP), **the same quality bar for human code and agent code**, pre-approving safe bash/MCP in `settings.json`.
- **2→3:** giving Claude the means to **retrieve context** (reading code, wikis, discussions); **agency + code review speed** (agents can touch other teams' code); breaking work down into **loops and routines**; **letting Claude launch Claude**.
- **Stage 3 — Supervised autonomy / Manager of managers (~100).** Claude writes **all or almost all** of the code; the question shifts from *"did you read the code?"* to *"what context was the model missing, and how do we fix that for next time?"*. *Unlock*: Claude **proactively** does what used to be launched by hand; maintenance/cleanup runs **continuously in the background**. *Bottleneck*: **trust in the loop** and the **team's decision throughput** — the agent tree is too deep to be babysat; the trap is *scaling the number of agents before the loop has earned trust*. Token efficiency to monitor (OTel/Analytics), a culture of experimentation + cost control once internal usage hits PMF. Test: *"is this something an engineer would have done?"*. *Products*: subagents with **worktree isolation** (no collisions), **Routines, /loop, /batch, /goal**, **dynamic workflows**, Claude Tag (watches a channel/source and launches tasks). *Guardrails*: automated code review + security review, **agent sandboxing**, **CLAUDE.md + Skills** to encode standards, **tuning the Auto mode classifier**, managing token use (model selection, advisors, LSP, splitting CLAUDE.md into **lazy Skills**).
- **3→4:** **automation at scale for domain-specific use cases** (code migration, fuzzing, feature building, feedback remediation).
- **Stage 4 — AI-native / VP steering by intent (~1,000+).** A **fully closed** loop; **most agents are launched by Claude**; hundreds to thousands of agents running; steering **by intent** and monitoring **by exception**. *Unlock*: a quarter-long migration becomes a **workflow you launch and check on**. *Bottleneck*: **identifying and automating work at scale** + enforcing the right guardrail per *type* of work. *Products*: **Claude Agent SDK** (building/scheduling agents programmatically), Claude Tag (present in most Slack channels, replies to posts). *Guardrails*: cost controls for automation, model selection for automation.
- **Anti-vanity metric (steering).** Usage (dashboard) measures **activity, not return**. Better question: *would we have invested engineering effort on this anyway, and if so, how many **manual engineer-hours** would it have cost?* → that's the **ROI**. The jackpot: when fixing/maintaining moves to the background, teams do "things that weren't even within the realm of possibility before".
- **Self-placement benchmark.** *Anthropic is at stage 3, pushing toward 4*; *Boris Cherny states he's at level 4*. Useful as an honest benchmark: even the vendor isn't "at the very top".
- **Related**: companion piece to [[fiches/2026-07/cherny-wu-reflecting-year-claude-code-2026-07-17\|Cherny & Wu — « Reflecting on a year of Claude Code »]] (same author, shipping becomes cheap → value shifts to judgment); "agent manager / orchestration" corpus (Sankar's great flattening, Martignole's token manifesto); guardrails & verification (compound engineering, self-verification loop).

## RésuméDe400mots

Boris Cherny, Creator & Head of Claude Code at Anthropic, publishes a framework table — **« Steps of AI Adoption »** — born from a recurring observation: in many companies, *one* person multiplies their output tenfold with Claude, but the rest of the organization doesn't follow. From this he derives a **5-stage maturity scale (0→4)**, structured around the **order of magnitude of agents an engineer drives** — and the role transformation this imposes.

**0 — Gated (0 agents)**: locked-down access, older models, no MCP governance nor infrastructure to host Claude's code; bottleneck = legacy security/approvals and an obsession with cost-per-token. **1 — Assisted (~1)**: "you + one agent", supervised pair programming, synchronous work; bottleneck = your attention, since without self-verification you review everything. **2 — Parallel (~10)**: you become the **orchestrator** of 5–10 agents on separate worktrees; Claude self-verifies (tests/build/lint/security), Auto mode and automated reviews by default; bottleneck = reviewing multiple streams. **3 — Supervised autonomy (~100)**: **manager of managers**, Claude writes almost everything, maintenance runs in the background; bottleneck = trust in the loop and decision throughput. **4 — AI-native (~1,000+)**: **VP steering by intent**, a closed loop where Claude launches most agents, monitoring by exception.

**Central thesis**: tokens don't move you up a level. Each tier has its own bottleneck; progress comes from **breaking it** and **building the next set of guardrails** that makes the output trustworthy. The levers named: self-verification loop (tests + build + lint + e2e on a real environment), **Auto mode** against blocking prompts, **code review + security review by default**, multi-agent interfaces (Agent view, Desktop, mobile, Tag), then `/loop`, `/batch`, `/goal`, **dynamic workflows**, **worktree isolation**, **CLAUDE.md + Skills** to encode standards, and finally the **Claude Agent SDK** to program/schedule fleets of agents.

On steering, Cherny dismisses the vanity metric: usage measures **activity, not return**. The right question — *would we have spent this effort anyway, and how many **manual engineer-hours** would it have cost?* — gives the true ROI. The decisive gain comes when fixing/maintaining moves to the background, freeing teams to *build* what wasn't even within reach before. An honest benchmark: Anthropic is at stage 3 and pushing toward 4; he himself has just reached level 4.

## GrapheDeConnaissance

- Boris Cherny —a_créé→ Steps of AI Adoption (METHODOLOGIE, 0.98)
- Boris Cherny —travaille_chez→ Anthropic (ORGANISATION, 0.98)
- Boris Cherny —dirige→ Claude Code (TECHNOLOGIE, 0.95)
- Steps of AI Adoption —s_applique_à→ adoption de l'IA agentique par une équipe d'ingénierie (CONCEPT, 0.95)
- Steps of AI Adoption —affirme_que→ pour passer à l'étape suivante il faut casser le prochain goulet d'étranglement et bâtir de nouveaux garde-fous ; les tokens seuls ne suffisent pas (AFFIRMATION, 0.95)
- Steps of AI Adoption —affirme_que→ l'axe structurant est l'ordre de grandeur d'agents piloté (0, ~1, ~10, ~100, ~1000+), transformant le rôle de pair programmer à VP pilotant par l'intention (AFFIRMATION, 0.9)
- boucle d'auto-vérification (tests + build + lint + e2e) —permet→ le passage de l'étape 1 (Assisted) à l'étape 2 (Parallel) (AFFIRMATION, 0.9)
- Auto mode —réduit→ les interruptions par prompts de permission bloquants (AFFIRMATION, 0.9)
- code review et security review automatiques —améliore→ la confiance dans le code généré par les agents (activées par défaut dès l'étape 2) (AFFIRMATION, 0.88)
- étape 2 Parallel —utilise→ worktree isolation (TECHNOLOGIE, 0.9)
- étape 3 Supervised autonomy —utilise→ /loop, /batch, /goal, Routines et dynamic workflows (TECHNOLOGIE, 0.9)
- étape 3 Supervised autonomy —utilise→ CLAUDE.md et Skills pour encoder les standards (TECHNOLOGIE, 0.85)
- étape 4 AI-native —utilise→ Claude Agent SDK (TECHNOLOGIE, 0.9)
- Anthropic —observé_dans→ étape 3 (Supervised autonomy), en route vers l'étape 4 (AFFIRMATION, 0.9)
- Boris Cherny —affirme_que→ avoir personnellement atteint le niveau 4 (AI-native) (AFFIRMATION, 0.85)
- Boris Cherny —recommande→ mesurer le retour en heures-ingénieur économisées plutôt que l'usage brut (activité ≠ retour) (AFFIRMATION, 0.9)
- Claude Tag —permet→ de surveiller un canal/source et de lancer des tâches proactivement (étapes 3-4) (AFFIRMATION, 0.85)

---
Canonical: https://www.thekb.eu/en/fiches/cherny-steps-ai-adoption-2026-07-16/