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

## Veille

**Boris Cherny** (Creator & Head of Claude Code @Anthropic) pubblica su LinkedIn una tabella-framework, **« Steps of AI Adoption »**, che mappa l'adozione dell'IA agentica da parte di un team di ingegneria lungo **5 stadi (0→4)**, ciascuno caratterizzato da un **ordine di grandezza di agenti guidati** e da una **trasformazione del ruolo dell'ingegnere**: **0 Gated** (0 agenti, accesso bloccato), **1 Assisted** (~1 agente — "tu + un agente", pair programming supervisionato), **2 Parallel** (~10 agenti — **orchestrator**), **3 Supervised autonomy** (~100 agenti — **manager of managers**, un albero organizzativo), **4 AI-native** (~1.000+ agenti — **VP steering by intent**). La tabella incrocia cinque colonne: numero di agenti, *a cosa assomiglia*, *il collo di bottiglia*, *i prodotti che aiutano*, *i guardrail*. **Tesi centrale**: consumare più token non fa salire di livello — avanzare allo stadio successivo richiede **identificare e rompere il prossimo collo di bottiglia** E **costruire il prossimo set di guardrail**. Concretamente: dare a Claude un **loop di auto-verifica** affidabile (test + build + lint + e2e su un ambiente reale), attivare **Auto mode** (evitando prompt di permesso bloccanti), rendere **il code review e il security review predefiniti**, adottare interfacce multi-agente (Agent view CLI, Desktop, app iOS/Android, Tag), poi `/loop`, `/batch`, `/goal`, **dynamic workflows** e **worktree isolation** per i subagenti. Sullo steering: l'utilizzo (dashboard) misura **l'attività, non il ritorno**; la domanda giusta è *"avremmo comunque speso sforzo ingegneristico su questo? se sì, quante ore-ingegnere manuali sarebbero costate?"* — questo è il ROI. Il vero guadagno arriva quando **la correzione e la manutenzione avvengono in background** e i team si concentrano sul *costruire*. Anthropic si colloca allo **stadio 3, diretta verso il 4**; Boris Cherny dichiara di aver raggiunto personalmente il **livello 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, adozione dell'IA, modello di maturità, scala di maturità dell'IA, IA agentica, agenti di coding, agenti guidati, trasformazione del ruolo, pair programming, orchestrator, manager of managers, VP steering by intent, steering by intent, monitoraggio per eccezione, collo di bottiglia, guardrail, guardrail, collo di bottiglia, i token non bastano, loop di auto-verifica, loop di auto-verifica, test build lint e2e, Auto mode, prompt di permesso, code review automatizzato, security review automatizzato, Agent view, Claude Code Review, Claude Security Review, Claude Cowork, Claude Design, Plan mode, worktree isolation, git checkout, Claude Code Mobile, esecuzione cloud, Remote control, Claude Tag, Claude Teams, Claude Enterprise, Compliance API, Analytics API, analytics da dashboard, OpenTelemetry, OTel, SIEM, osservabilità, /loop, /batch, /goal, Routines, dynamic workflows, subagenti, sandboxing degli agenti, CLAUDE.md, Skills, lazy Skills, codifica degli standard, classificatore di Auto mode, uso dei token, selezione del modello, advisor, LSP, Claude Agent SDK, pianificazione degli agenti, migrazione del codice, fuzzing, remediation dei feedback, governance MCP, SSO SCIM, RBAC, tetti di budget, IAM, governance dei dati, ROI dell'IA, attività vs ritorno, ore-ingegnere, PMF interno, stadio 0 Gated, stadio 1 Assisted, stadio 2 Parallel, stadio 3 Supervised autonomy, stadio 4 AI-native, albero di agenti, fiducia nel loop, throughput decisionale, manutenzione in background

## Authors

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

## Ton

**Profilo**: framework practitioner-leader nella forma di una **tabella di maturità** (artefatto Claude, datato 16 luglio 2026) accompagnata da un post narrativo su LinkedIn. Rivolto a leader dell'ingegneria e decisori che osservano che "una persona ottiene un boost di output 10x con Claude ma il resto dell'organizzazione non segue". Registro operativo, non prescrittivo sul percorso (« Non esiste un unico percorso corretto ») ma molto preciso sui **meccanismi** per passare da un livello al successivo.

**Stile**: matrice densa 5 stadi × 5 colonne (numero di agenti, a cosa assomiglia, collo di bottiglia, prodotti, guardrail), intervallata da righe **« Come passare dallo stadio X allo stadio Y »**. Ogni stadio porta uno **Sblocco** (il guadagno concreto che sblocca) e nomina esplicitamente il prossimo **collo di bottiglia** — la struttura argomentativa è "diagnosticare il blocco → prodotti + guardrail per rimuoverlo". Una posizione di autorità assunta (l'autore *è* l'Head of Claude Code, sostenuto dal catalogo prodotti), temperata da benchmark onesti: la stessa Anthropic è solo allo stadio 3, e la metrica di successo proposta (ore-ingegnere risparmiate) rigetta la vanità dell'utilizzo grezzo. Filo conduttore: il progresso non è questione di *feature* o *token* isolati, ma di **colli di bottiglia rotti + guardrail costruiti** che permettono al team di *fidarsi* dell'output.

## Pense-betes

- **Idea centrale: non si sale di livello spendendo più token.** Ogni livello ha il proprio **collo di bottiglia**; passare al successivo richiede *romperlo* E *costruire il prossimo set di guardrail* che renda l'output affidabile. « Non si tratta di una singola funzionalità, ma piuttosto di usare le funzionalità giuste con i guardrail giusti. »
- **La spina dorsale del modello = l'ordine di grandezza di agenti guidati, e il ruolo che impone.** 0 → ~1 → ~10 → ~100 → ~1.000+ agenti, ossia ingegnere bloccato → **pair programmer** → **orchestrator** → **manager of managers (albero organizzativo)** → **VP steering by intent**. È questa la vera "essenza" della tabella: una crescita esponenziale del parallelismo che *trasforma il mestiere*, non solo la velocità.
- **Stadio 0 — Gated (0 agenti).** Solo modelli approvati più vecchi/leggeri, latenza che si accumula attraverso gateway + autenticazione custom, nessuna governance MCP, accesso bloccato/gravato da processi, **nessuna infrastruttura per ospitare codice prodotto da Claude** (gli output restano locali). *Collo di bottiglia*: sicurezza/approvazioni legacy, un'ossessione per il **costo per token** a scapito dei *risultati*, nessuna voce tecnica reale nella decisione. *Prodotto*: chat Claude.ai. *Guardrail*: SSO/SCIM + RBAC, tetti di budget organizzativi, deployment entro le approvazioni/IAM esistenti, data governance. **0→1**: allineamento dirigenza/buyer, escalation dei blocchi, framework per lanciare Claude in sicurezza.
- **Stadio 1 — Assisted / "tu + un agente" (~1).** Un ingegnere, un agente, quasi tutto supervisionato (pair programmer veloce), una sessione alla volta, revisione di quasi ogni modifica prima del merge. *Sblocco*: ciò che prima riempiva un pomeriggio ora si conclude tra due riunioni. *Collo di bottiglia*: **la tua attenzione** — bassa fiducia + assenza di auto-verifica → leggi tutto, lavoro **sincrono** (osservi Claude invece di andare avanti). *Prodotti*: Claude Code (Desktop/CLI/IDE), Cowork, Design, utilizzo via API/Bedrock/Vertex/Microsoft Foundry, dashboard + Analytics API, Compliance API, **Plan mode**. *Guardrail*: tetti di spesa per postazione, modello/effort e policy gestiti centralmente, esportazione **OpenTelemetry** verso il SIEM.
- **1→2 (transizione chiave):** far girare **più agenti contemporaneamente**; un **loop di auto-verifica** affidabile (test + build + lint + **e2e su un ambiente di sviluppo reale**); **Auto mode** per smettere di essere bloccati dai prompt di permesso; **automatizzare il code review**.
- **Stadio 2 — Parallel / Orchestrator (~10).** Un ingegnere orchestra **5-10 agenti** in parallelo, ciascuno sul proprio **worktree/git checkout**. Claude verifica il proprio lavoro (test, build, lint, scansione di sicurezza) *prima* che tu lo veda; **Auto mode sempre attivo**; **code review + security review predefiniti**. Rivedi **diff finali, non battute di tastiera**; il backlog di manutenzione si riduce; Claude scrive la *maggior parte* del codice. *Sblocco*: un backlog di più settimane diventa un pomeriggio di orchestrazione per un ingegnere. *Collo di bottiglia*: **la revisione** (controllare sei flussi paralleli) + destreggiarsi tra prompting/steering. *Prodotti*: Auto mode, Agent view, Claude Code Review, Claude Security Review, Claude Code Mobile + esecuzione cloud Desktop, Claude Tag (un task isolato), worktree isolation CLI/Desktop, **Remote control** (steering dal telefono). *Guardrail*: Analytics sull'utilizzo del team, applicazione della qualità (lint/test/typecheck), **verifica e2e potenziata da Claude** (estensione Chrome o MCP simulatore iOS/Android), **lo stesso standard di qualità per codice umano e codice agente**, pre-approvazione di bash/MCP sicuri in `settings.json`.
- **2→3:** dare a Claude i mezzi per **recuperare contesto** (lettura di codice, wiki, discussioni); **agency + velocità di code review** (gli agenti possono toccare il codice di altri team); scomporre il lavoro in **loop e routine**; **lasciare che Claude lanci Claude**.
- **Stadio 3 — Supervised autonomy / Manager of managers (~100).** Claude scrive **tutto o quasi tutto** il codice; la domanda passa da *"hai letto il codice?"* a *"quale contesto mancava al modello, e come lo correggiamo per la prossima volta?"*. *Sblocco*: Claude fa **proattivamente** ciò che prima veniva lanciato a mano; la manutenzione/pulizia gira **continuamente in background**. *Collo di bottiglia*: **la fiducia nel loop** e il **throughput decisionale del team** — l'albero di agenti è troppo profondo per essere sorvegliato passo passo; la trappola è *scalare il numero di agenti prima che il loop abbia guadagnato fiducia*. Efficienza dei token da monitorare (OTel/Analytics), una cultura di sperimentazione + controllo dei costi una volta che l'utilizzo interno raggiunge il PMF. Test: *"è qualcosa che un ingegnere avrebbe fatto?"*. *Prodotti*: subagenti con **worktree isolation** (nessuna collisione), **Routines, /loop, /batch, /goal**, **dynamic workflows**, Claude Tag (osserva un canale/fonte e lancia task). *Guardrail*: code review + security review automatizzati, **agent sandboxing**, **CLAUDE.md + Skills** per codificare gli standard, **calibrazione del classificatore di Auto mode**, gestione dell'uso dei token (selezione del modello, advisor, LSP, suddivisione di CLAUDE.md in **lazy Skills**).
- **3→4:** **automazione su larga scala per casi d'uso specifici del dominio** (migrazione del codice, fuzzing, costruzione di feature, remediation dei feedback).
- **Stadio 4 — AI-native / VP steering by intent (~1.000+).** Un loop **completamente chiuso**; **la maggior parte degli agenti è lanciata da Claude**; da centinaia a migliaia di agenti in esecuzione; steering **per intento** e monitoraggio **per eccezione**. *Sblocco*: una migrazione di un trimestre diventa un **workflow che lanci e controlli**. *Collo di bottiglia*: **identificare e automatizzare il lavoro su larga scala** + applicare il guardrail giusto per ogni *tipo* di lavoro. *Prodotti*: **Claude Agent SDK** (costruire/pianificare agenti programmaticamente), Claude Tag (presente nella maggior parte dei canali Slack, risponde ai post). *Guardrail*: controlli dei costi per l'automazione, selezione del modello per l'automazione.
- **Metrica anti-vanità (steering).** L'utilizzo (dashboard) misura **l'attività, non il ritorno**. Domanda migliore: *avremmo comunque investito sforzo ingegneristico su questo, e se sì, quante **ore-ingegnere manuali** sarebbero costate?* → questo è il **ROI**. Il jackpot: quando la correzione/manutenzione passa in background, i team fanno "cose che prima non rientravano nemmeno nel regno del possibile".
- **Benchmark di autoposizionamento.** *Anthropic è allo stadio 3, in spinta verso il 4*; *Boris Cherny dichiara di essere al livello 4*. Utile come benchmark onesto: nemmeno il fornitore è "al vertice assoluto".
- **Correlato**: pezzo di accompagnamento a [[fiches/2026-07/cherny-wu-reflecting-year-claude-code-2026-07-17\|Cherny & Wu — « Reflecting on a year of Claude Code »]] (stesso autore, la spedizione diventa economica → il valore si sposta sul giudizio); corpus "agent manager / orchestration" (il grande appiattimento di Sankar, il manifesto dei token di Martignole); guardrail e verifica (compound engineering, loop di auto-verifica).

## RésuméDe400mots

Boris Cherny, Creator & Head of Claude Code presso Anthropic, pubblica una tabella-framework — **« Steps of AI Adoption »** — nata da un'osservazione ricorrente: in molte aziende, *una sola* persona moltiplica per dieci il proprio output con Claude, ma il resto dell'organizzazione non segue. Da qui deriva una **scala di maturità a 5 stadi (0→4)**, strutturata attorno all'**ordine di grandezza di agenti guidati da un ingegnere** — e alla trasformazione di ruolo che questo impone.

**0 — Gated (0 agenti)**: accesso bloccato, modelli più vecchi, nessuna governance MCP né infrastruttura per ospitare il codice di Claude; collo di bottiglia = sicurezza/approvazioni legacy e un'ossessione per il costo per token. **1 — Assisted (~1)**: "tu + un agente", pair programming supervisionato, lavoro sincrono; collo di bottiglia = la tua attenzione, poiché senza auto-verifica rivedi tutto. **2 — Parallel (~10)**: diventi l'**orchestrator** di 5-10 agenti su worktree separati; Claude si auto-verifica (test/build/lint/sicurezza), Auto mode e review automatizzate per default; collo di bottiglia = rivedere più flussi. **3 — Supervised autonomy (~100)**: **manager of managers**, Claude scrive quasi tutto, la manutenzione gira in background; collo di bottiglia = fiducia nel loop e throughput decisionale. **4 — AI-native (~1.000+)**: **VP steering by intent**, un loop chiuso in cui Claude lancia la maggior parte degli agenti, monitoraggio per eccezione.

**Tesi centrale**: i token non fanno salire di livello. Ogni livello ha il proprio collo di bottiglia; il progresso viene dal **romperlo** e dal **costruire il prossimo set di guardrail** che rende l'output affidabile. Le leve nominate: loop di auto-verifica (test + build + lint + e2e su un ambiente reale), **Auto mode** contro i prompt bloccanti, **code review + security review per default**, interfacce multi-agente (Agent view, Desktop, mobile, Tag), poi `/loop`, `/batch`, `/goal`, **dynamic workflows**, **worktree isolation**, **CLAUDE.md + Skills** per codificare gli standard, e infine il **Claude Agent SDK** per programmare/pianificare flotte di agenti.

Sullo steering, Cherny respinge la metrica di vanità: l'utilizzo misura **l'attività, non il ritorno**. La domanda giusta — *avremmo comunque speso questo sforzo, e quante **ore-ingegnere manuali** sarebbero costate?* — dà il vero ROI. Il guadagno decisivo arriva quando la correzione/manutenzione passa in background, liberando i team per *costruire* ciò che prima non era nemmeno alla portata. Un benchmark onesto: Anthropic è allo stadio 3 e spinge verso il 4; lui stesso ha appena raggiunto il livello 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/it/fiches/cherny-steps-ai-adoption-2026-07-16/