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

## Veille

**Boris Cherny** (Creator & Head of Claude Code @Anthropic) publie sur LinkedIn un tableau-framework, **« Steps of AI Adoption »**, qui cartographie l'adoption de l'IA agentique par une équipe d'ingénierie en **5 étapes (0→4)**, chacune caractérisée par un **ordre de grandeur d'agents pilotés** et une **transformation du rôle de l'ingénieur** : **0 Gated** (0 agent, accès verrouillé), **1 Assisted** (~1 agent — « vous + un agent », pair programming supervisé), **2 Parallel** (~10 agents — **orchestrateur**), **3 Supervised autonomy** (~100 agents — **manager de managers**, un arbre org), **4 AI-native** (~1 000+ agents — **VP qui pilote par l'intention**). Le tableau croise cinq colonnes : nombre d'agents, *à quoi ça ressemble*, *le goulet d'étranglement*, *les produits qui aident*, *les garde-fous*. **Thèse centrale** : consommer plus de tokens ne fait pas monter d'un cran — pour passer à l'étape suivante il faut **identifier et casser le prochain goulet d'étranglement** ET **bâtir le prochain jeu de garde-fous**. Concrètement : donner à Claude une **boucle d'auto-vérification** de confiance (tests + build + lint + e2e sur un vrai environnement), activer l'**Auto mode** (éviter les prompts de permission bloquants), passer **code review et security review par défaut**, adopter des interfaces multi-agents (Agent view CLI, Desktop, apps iOS/Android, Tag), puis `/loop`, `/batch`, `/goal`, **dynamic workflows** et **worktree isolation** pour subagents. Sur le pilotage : l'usage (dashboard) mesure l'**activité, pas le retour** ; la bonne question est *« aurait-on de toute façon dépensé de l'effort d'ingénierie là-dessus ? si oui, combien d'heures-ingénieur manuelles cela aurait-il coûté ? »* — voilà le ROI. Le vrai gain arrive quand **corriger et maintenir se fait en arrière-plan** et que les équipes se concentrent sur *construire*. Anthropic se situe à l'**étape 3, en route vers 4** ; Boris Cherny déclare avoir personnellement atteint le **niveau 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, adoption de l'IA, modèle de maturité, échelle de maturité IA, IA agentique, agents de codage, nombre d'agents piloté, transformation du rôle, pair programming, orchestrateur, manager de managers, VP steering by intent, pilotage par l'intention, monitoring par exception, goulet d'étranglement, garde-fous, guardrails, bottleneck, tokens ne suffisent pas, boucle d'auto-vérification, self-verification loop, tests build lint e2e, Auto mode, prompts de permission, code review automatique, security review automatique, 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, observabilité, /loop, /batch, /goal, Routines, dynamic workflows, subagents, agent sandboxing, CLAUDE.md, Skills, lazy Skills, encoder les standards, Auto mode classifier, token use, model selection, advisors, LSP, Claude Agent SDK, scheduling d'agents, migration de code, fuzzing, feedback remediation, MCP governance, SSO SCIM, RBAC, budget caps, IAM, data governance, ROI IA, activité vs retour, heures-ingénieur, PMF interne, étape 0 Gated, étape 1 Assisted, étape 2 Parallel, étape 3 Supervised autonomy, étape 4 AI-native, arbre d'agents, confiance dans la boucle, débit décisionnel, maintenance en arrière-plan

## Authors

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

## Ton

**Profil** : framework de praticien-dirigeant sous forme de **tableau de maturité** (artifact Claude, daté du 16 juillet 2026) accompagné d'un post LinkedIn de mise en récit. Adressé aux leaders d'ingénierie et décideurs qui constatent qu'« une personne 10x son output avec Claude mais le reste de l'org n'a pas suivi ». Registre opérationnel, non-prescriptif sur le chemin (« There's no one right path ») mais très précis sur les **mécanismes** de passage d'un palier à l'autre.

**Style** : matrice dense 5 étapes × 5 colonnes (nb d'agents, à quoi ça ressemble, goulet, produits, garde-fous), entrecoupée de lignes **« How to get from step X to Y »**. Chaque étape porte un **Unlock** (le gain concret débloqué) et nomme explicitement le **goulet d'étranglement** suivant — la structure argumentative est « diagnostic du blocage → produits + garde-fous pour le lever ». Position d'autorité assumée (l'auteur *est* le Head of Claude Code, catalogue produit à l'appui), mais tempérée par des repères honnêtes : Anthropic elle-même n'est qu'à l'étape 3, et la métrique de succès proposée (heures-ingénieur économisées) refuse la vanité de l'usage brut. Fil rouge : la progression n'est pas une question de *features* isolées ni de *tokens*, mais de **bottlenecks cassés + garde-fous bâtis** permettant à l'équipe de *faire confiance* à l'output.

## Pense-betes

- **Idée-force : on ne monte pas d'un cran en dépensant plus de tokens.** Chaque palier a un **goulet d'étranglement** propre ; pour passer au suivant il faut *le casser* ET *bâtir le prochain jeu de garde-fous* qui rend l'output digne de confiance. « It's not about a single feature, but rather using the right features with the right guardrails. »
- **La colonne vertébrale du modèle = l'ordre de grandeur d'agents pilotés, et le rôle qu'il impose.** 0 → ~1 → ~10 → ~100 → ~1 000+ agents, soit ingénieur bloqué → **pair programmer** → **orchestrateur** → **manager de managers (arbre org)** → **VP qui pilote par l'intention**. C'est la vraie « essence » du tableau : une montée exponentielle du parallélisme qui *transforme le métier*, pas juste la vélocité.
- **Étape 0 — Gated (0 agent).** Seuls des modèles anciens/légers approuvés, latence qui s'accumule via gateways + auth custom, pas de gouvernance MCP, accès verrouillé/process-heavy, **aucune infra pour héberger le code produit par Claude** (les sorties restent locales). *Goulet* : sécurité/approbations legacy, obsession du **cost-per-token** au détriment des *outcomes*, absence de vraies voix techniques dans la décision. *Produit* : Claude.ai chat. *Garde-fous* : SSO/SCIM + RBAC, budget caps org, déploiement dans les approbations/IAM existants, data governance. **0→1** : alignement exécutif/acheteur, escalade des bloqueurs, cadres pour lancer Claude en sécurité.
- **Étape 1 — Assisted / « vous + un agent » (~1).** Un ingénieur, un agent, quasi tout supervisé (fast pair programmer), une session à la fois, relecture de presque chaque changement avant merge. *Unlock* : ce qui remplissait un après-midi se boucle entre deux réunions. *Goulet* : **votre attention** — faible confiance + pas d'auto-vérification → vous lisez tout, travail **synchrone** (vous regardez Claude au lieu d'enchaîner). *Produits* : Claude Code (Desktop/CLI/IDE), Cowork, Design, usage via API/Bedrock/Vertex/Microsoft Foundry, dashboard + Analytics API, Compliance API, **Plan mode**. *Garde-fous* : spend caps par siège, model/effort et policy gérés centralement, export **OpenTelemetry** vers le SIEM.
- **1→2 (transition clé) :** faire tourner **plusieurs agents à la fois** ; une **boucle d'auto-vérification de confiance** (tests + build + lint + **e2e sur un vrai environnement de dev**) ; **Auto mode** pour ne plus être bloqué par les prompts de permission ; **automatiser la code review**.
- **Étape 2 — Parallel / Orchestrateur (~10).** Un ingénieur orchestre **5–10 agents** en parallèle, chacun sur son **worktree/git checkout**. Claude vérifie son propre travail (tests, build, lint, security scan) *avant* que vous le voyiez ; **Auto mode toujours actif** ; **code review + security review par défaut**. On relit des **diffs finaux, pas des frappes** ; le backlog de maintenance rétrécit ; Claude écrit *la plupart* du code. *Unlock* : un backlog de plusieurs semaines devient l'après-midi d'orchestration d'un ingénieur. *Goulet* : **la relecture** (vérifier six flux en parallèle) + le prompting/steering en jonglant. *Produits* : Auto mode, Agent view, Claude Code Review, Claude Security Review, Claude Code Mobile + exécution cloud Desktop, Claude Tag (une tâche isolée), worktree isolation CLI/Desktop, **Remote control** (piloter depuis son téléphone). *Garde-fous* : Analytics d'usage équipe, enforcement qualité (lint/tests/typecheck), **vérification e2e propulsée par Claude** (extension Chrome ou MCP simulateur iOS/Android), **même barre de qualité pour code humain et code d'agent**, pré-approuver les bash/MCP sûrs dans `settings.json`.
- **2→3 :** donner à Claude de quoi **récupérer le contexte** (lire code, wikis, discussions) ; **agentivité + vitesse de code review** (les agents peuvent toucher du code d'autres équipes) ; découper le travail en **loops et routines** ; **laisser Claude lancer Claude**.
- **Étape 3 — Supervised autonomy / Manager de managers (~100).** Claude écrit **tout ou presque** le code ; la question passe de *« as-tu lu le code ? »* à *« quel contexte manquait au modèle et comment le régler pour la prochaine fois ? »*. *Unlock* : Claude fait **proactivement** ce qu'on lançait à la main ; la maintenance/cleanup tourne **en continu en arrière-plan**. *Goulet* : **la confiance dans la boucle** et le **débit décisionnel de l'équipe** — l'arbre d'agents est trop profond pour être materné ; le piège est de *scaler le nombre d'agents avant que la boucle ait gagné la confiance*. Efficacité des tokens à surveiller (OTel/Analytics), culture d'expérimentation + contrôle des coûts une fois les usages internes en PMF. Test : *« est-ce quelque chose qu'un ingénieur aurait fait ? »*. *Produits* : subagents avec **worktree isolation** (pas de collision), **Routines, /loop, /batch, /goal**, **dynamic workflows**, Claude Tag (surveille un canal/source et lance des tâches). *Garde-fous* : code review + security review automatiques, **agent sandboxing**, **CLAUDE.md + Skills** pour encoder les standards, **tune du classifier Auto mode**, gestion du token use (model selection, advisors, LSP, découper CLAUDE.md en **lazy Skills**).
- **3→4 :** **automatisation à l'échelle de cas d'usage spécifiques au domaine** (migration de code, fuzzing, construction de features, remédiation de feedback).
- **Étape 4 — AI-native / VP qui pilote par l'intention (~1 000+).** Boucle **entièrement fermée** ; **la plupart des agents sont lancés par Claude** ; centaines à milliers d'agents tournent ; on **pilote par l'intention** et **surveille par exception**. *Unlock* : la migration d'un trimestre devient un **workflow qu'on lance et qu'on va checker**. *Goulet* : **identifier et automatiser le travail à l'échelle** + imposer le bon garde-fou par *type* de travail. *Produits* : **Claude Agent SDK** (construire/planifier des agents par programmation), Claude Tag (présent dans la plupart des canaux Slack, répond aux posts). *Garde-fous* : contrôles de coûts pour l'automatisation, model selection pour l'automatisation.
- **Métrique anti-vanité (pilotage).** L'usage (dashboard) mesure **l'activité, pas le retour**. Meilleure question : *aurait-on de toute façon investi de l'effort d'ingénierie là-dessus ? si oui, combien d'**heures-ingénieur manuelles** cela aurait coûté ?* → c'est le **ROI**. Le gros lot : quand corriger/maintenir passe en arrière-plan, on fait « des choses qui n'étaient même pas dans le champ des possibles avant ».
- **Repère d'auto-situation.** *Anthropic est à l'étape 3, poussant vers 4* ; *Boris Cherny se déclare au niveau 4*. Utile comme benchmark honnête : même l'éditeur n'est pas « tout en haut ».
- **À relier** : diptyque avec [[fiches/2026-07/cherny-wu-reflecting-year-claude-code-2026-07-17\|Cherny & Wu — « Reflecting on a year of Claude Code »]] (même auteur, livrer devient bon marché → valeur vers le jugement) ; corpus « manager d'agents / orchestration » (great flattening de Sankar, token manifesto de Martignole) ; garde-fous & vérification (compound engineering, self-verification loop).

## RésuméDe400mots

Boris Cherny, Creator & Head of Claude Code chez Anthropic, publie un tableau-framework — **« Steps of AI Adoption »** — né d'un constat répété : dans beaucoup d'entreprises, *une* personne décuple son output avec Claude, mais le reste de l'organisation ne suit pas. Il en tire une **échelle de maturité en 5 étapes (0→4)**, dont l'axe structurant est l'**ordre de grandeur d'agents qu'un ingénieur pilote** — et la transformation de rôle que cela impose.

**0 — Gated (0 agent)** : accès verrouillé, modèles anciens, pas de gouvernance MCP ni d'infra pour héberger le code de Claude ; goulet = sécurité/approbations legacy et obsession du cost-per-token. **1 — Assisted (~1)** : « vous + un agent », pair programming supervisé, travail synchrone ; goulet = votre attention, car sans auto-vérification vous relisez tout. **2 — Parallel (~10)** : vous devenez **orchestrateur** de 5–10 agents sur worktrees séparés ; Claude s'auto-vérifie (tests/build/lint/security), Auto mode et revues automatiques par défaut ; goulet = la relecture de flux multiples. **3 — Supervised autonomy (~100)** : **manager de managers**, Claude écrit presque tout, la maintenance tourne en fond ; goulet = la confiance dans la boucle et le débit décisionnel. **4 — AI-native (~1 000+)** : **VP qui pilote par l'intention**, boucle fermée où Claude lance la plupart des agents, supervision par exception.

**Thèse centrale** : les tokens ne font pas monter d'un cran. Chaque palier a un goulet propre ; on progresse en **le cassant** et en **bâtissant le prochain jeu de garde-fous** qui rend l'output digne de confiance. Les leviers nommés : boucle d'auto-vérification (tests + build + lint + e2e sur un vrai environnement), **Auto mode** contre les prompts bloquants, **code review + security review par défaut**, interfaces multi-agents (Agent view, Desktop, mobile, Tag), puis `/loop`, `/batch`, `/goal`, **dynamic workflows**, **worktree isolation**, **CLAUDE.md + Skills** pour encoder les standards, et enfin le **Claude Agent SDK** pour programmer/planifier des flottes d'agents.

Sur le pilotage, Cherny écarte la métrique de vanité : l'usage mesure l'**activité, pas le retour**. La bonne question — *aurait-on dépensé cet effort de toute façon, et combien d'heures-ingénieur manuelles ?* — donne le vrai ROI. Le gain décisif survient quand corriger et maintenir passent en arrière-plan, libérant les équipes pour *construire* ce qui n'était pas atteignable avant. Repère honnête : Anthropic est à l'étape 3 et pousse vers 4 ; lui-même vient d'atteindre le niveau 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/fr/fiches/cherny-steps-ai-adoption-2026-07-16/