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

## Veille

**Boris Cherny** (Creator & Head of Claude Code @Anthropic) veröffentlicht auf LinkedIn eine Framework-Tabelle, **« Steps of AI Adoption »**, die die Einführung agentischer KI durch ein Engineering-Team über **5 Stufen (0→4)** abbildet, jede charakterisiert durch eine **Größenordnung der gesteuerten Agenten** und eine **Transformation der Rolle des Engineers**: **0 Gated** (0 Agenten, abgeschotteter Zugang), **1 Assisted** (~1 Agent — „du + ein Agent“, betreutes Pair Programming), **2 Parallel** (~10 Agenten — **Orchestrator**), **3 Supervised autonomy** (~100 Agenten — **Manager of Managers**, ein Org-Baum), **4 AI-native** (~1.000+ Agenten — **VP Steering by Intent**). Die Tabelle kreuzt fünf Spalten: Anzahl der Agenten, *wie es aussieht*, *der Engpass*, *die hilfreichen Produkte*, *die Guardrails*. **Zentrale These**: mehr Tokens zu verbrauchen bringt keinen Stufenaufstieg — der Aufstieg zur nächsten Stufe erfordert, **den nächsten Engpass zu identifizieren und aufzulösen** UND **den nächsten Satz an Guardrails aufzubauen**. Konkret: Claude eine verlässliche **Self-Verification-Loop** geben (Tests + Build + Lint + E2E in einer echten Umgebung), **Auto mode** aktivieren (um blockierende Berechtigungsabfragen zu vermeiden), **Code-Review und Security-Review zum Standard machen**, Multi-Agenten-Oberflächen einführen (Agent View CLI, Desktop, iOS/Android-Apps, Tag), dann `/loop`, `/batch`, `/goal`, **dynamische Workflows** und **worktree isolation** für Subagenten. Zum Thema Steuerung: Nutzung (Dashboard) misst **Aktivität, nicht Ertrag**; die richtige Frage lautet *„hätten wir hierfür ohnehin Engineering-Aufwand investiert? Wenn ja, wie viele manuelle Engineer-Stunden hätte es gekostet?“* — das ist der ROI. Der eigentliche Gewinn stellt sich ein, wenn **Fixes und Wartung im Hintergrund ablaufen** und Teams sich auf das *Bauen* konzentrieren. Anthropic befindet sich auf **Stufe 3, auf dem Weg zu 4**; Boris Cherny erklärt, persönlich **Stufe 4** erreicht zu haben.

## 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, KI-Einführung, Reifegradmodell, KI-Reifegradskala, agentische KI, Coding-Agenten, gesteuerte Agenten, Rollentransformation, Pair Programming, Orchestrator, Manager of Managers, VP Steering by Intent, Steering by Intent, Überwachung nach Ausnahmeprinzip, Engpass, Guardrails, Guardrails, Engpass, Tokens allein reichen nicht, Self-Verification-Loop, Self-Verification-Loop, Tests Build Lint E2E, Auto mode, Berechtigungsabfragen, automatisiertes Code-Review, automatisiertes Security-Review, Agent view, Claude Code Review, Claude Security Review, Claude Cowork, Claude Design, Plan mode, worktree isolation, Git-Checkout, Claude Code Mobile, Cloud-Ausführung, Remote control, Claude Tag, Claude Teams, Claude Enterprise, Compliance API, Analytics API, Dashboard-Analytics, OpenTelemetry, OTel, SIEM, Observability, /loop, /batch, /goal, Routines, dynamische Workflows, Subagenten, Agent-Sandboxing, CLAUDE.md, Skills, lazy Skills, Kodifizierung von Standards, Auto-mode-Klassifikator, Token-Nutzung, Modellauswahl, Advisors, LSP, Claude Agent SDK, Agenten-Scheduling, Code-Migration, Fuzzing, Feedback-Behebung, MCP-Governance, SSO SCIM, RBAC, Budgetobergrenzen, IAM, Data Governance, KI-ROI, Aktivität vs. Ertrag, Engineer-Stunden, internes PMF, Stufe 0 Gated, Stufe 1 Assisted, Stufe 2 Parallel, Stufe 3 Supervised autonomy, Stufe 4 AI-native, Agentenbaum, Vertrauen in die Loop, Entscheidungsdurchsatz, Wartung im Hintergrund

## Authors

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

## Ton

**Profil**: Praktiker-Leader-Framework in Form einer **Reifegrad-Tabelle** (Claude-Artefakt, datiert 16. Juli 2026), begleitet von einem narrativen LinkedIn-Post. Gerichtet an Engineering-Führungskräfte und Entscheider, die beobachten, dass „eine Person mit Claude einen 10-fachen Output-Schub erzielt, der Rest der Organisation aber nicht nachzieht“. Operatives Register, nicht präskriptiv bezüglich des Wegs (« There's no one right path ») aber sehr präzise bei den **Mechanismen** für den Übergang von einer Stufe zur nächsten.

**Stil**: dichte 5-Stufen-×-5-Spalten-Matrix (Anzahl der Agenten, wie es aussieht, Engpass, Produkte, Guardrails), durchsetzt mit **« How to get from step X to Y »**-Zeilen. Jede Stufe trägt ein **Unlock** (den konkreten Gewinn, den sie freischaltet) und benennt explizit den nächsten **Engpass** — die argumentative Struktur lautet „Blocker diagnostizieren → Produkte + Guardrails zu seiner Beseitigung“. Eine vorausgesetzte Autoritätsposition (der Autor *ist* der Head of Claude Code, gestützt auf den Produktkatalog), abgemildert durch ehrliche Maßstäbe: Anthropic selbst steht erst auf Stufe 3, und die vorgeschlagene Erfolgsmetrik (eingesparte Engineer-Stunden) verwirft die Eitelkeit der reinen Nutzung. Roter Faden: Fortschritt ist keine Frage isolierter *Features* oder *Tokens*, sondern von **aufgelösten Engpässen + aufgebauten Guardrails**, die es dem Team erlauben, dem Output zu *vertrauen*.

## Pense-betes

- **Kernidee: Man steigt nicht durch mehr Tokens eine Stufe auf.** Jede Stufe hat ihren eigenen **Engpass**; der Aufstieg zur nächsten erfordert, *ihn aufzulösen* UND *den nächsten Satz an Guardrails aufzubauen*, der den Output vertrauenswürdig macht. « Es geht nicht um ein einzelnes Feature, sondern darum, die richtigen Features mit den richtigen Guardrails einzusetzen. »
- **Das Rückgrat des Modells = die Größenordnung der gesteuerten Agenten und die dadurch auferlegte Rolle.** 0 → ~1 → ~10 → ~100 → ~1.000+ Agenten, also blockierter Engineer → **Pair Programmer** → **Orchestrator** → **Manager of Managers (Org-Baum)** → **VP Steering by Intent**. Das ist die eigentliche „Essenz“ der Tabelle: ein exponentieller Anstieg der Parallelität, der *den Job transformiert*, nicht nur die Geschwindigkeit.
- **Stufe 0 — Gated (0 Agenten).** Nur ältere/leichtgewichtige freigegebene Modelle, sich über Gateways + Custom Auth aufbauende Latenz, keine MCP-Governance, abgeschotteter/prozesslastiger Zugang, **keine Infrastruktur, um von Claude erzeugten Code zu hosten** (Outputs bleiben lokal). *Engpass*: veraltete Sicherheit/Freigaben, eine Fixierung auf **Kosten pro Token** auf Kosten der *Ergebnisse*, keine echten technischen Stimmen in der Entscheidung. *Produkt*: Claude.ai-Chat. *Guardrails*: SSO/SCIM + RBAC, Org-Budgetobergrenzen, Deployment innerhalb bestehender Freigaben/IAM, Data Governance. **0→1**: Abstimmung mit Führungskräften/Einkäufern, Eskalation von Blockern, Frameworks, um Claude sicher einzuführen.
- **Stufe 1 — Assisted / „du + ein Agent“ (~1).** Ein Engineer, ein Agent, fast alles wird beaufsichtigt (schneller Pair Programmer), jeweils eine Session, fast jede Änderung wird vor dem Merge geprüft. *Unlock*: Was früher einen Nachmittag füllte, ist jetzt zwischen zwei Meetings erledigt. *Engpass*: **deine Aufmerksamkeit** — geringes Vertrauen + keine Self-Verification → du liest alles, **synchrone** Arbeit (du beobachtest Claude, statt weiterzumachen). *Produkte*: Claude Code (Desktop/CLI/IDE), Cowork, Design, Nutzung via API/Bedrock/Vertex/Microsoft Foundry, Dashboard + Analytics API, Compliance API, **Plan mode**. *Guardrails*: Ausgabenobergrenzen pro Seat, zentral verwaltetes Modell/Effort und Policy, **OpenTelemetry**-Export ins SIEM.
- **1→2 (Schlüsselübergang):** **mehrere Agenten gleichzeitig** betreiben; eine verlässliche **Self-Verification-Loop** (Tests + Build + Lint + **E2E in einer echten Dev-Umgebung**); **Auto mode**, um nicht mehr durch Berechtigungsabfragen blockiert zu werden; **Code-Review automatisieren**.
- **Stufe 2 — Parallel / Orchestrator (~10).** Ein Engineer orchestriert **5–10 Agenten** parallel, jeder auf seinem eigenen **Worktree/Git-Checkout**. Claude verifiziert seine eigene Arbeit (Tests, Build, Lint, Security-Scan), *bevor* du sie siehst; **Auto mode dauerhaft aktiv**; **Code-Review + Security-Review als Standard**. Du prüfst **finale Diffs, nicht Tastenanschläge**; der Wartungsrückstand schrumpft; Claude schreibt *das Meiste* des Codes. *Unlock*: Ein mehrwöchiger Rückstand wird zum Orchestrierungs-Nachmittag eines Engineers. *Engpass*: **das Reviewen** (sechs parallele Stränge prüfen) + das Jonglieren von Prompting/Steuerung. *Produkte*: Auto mode, Agent View, Claude Code Review, Claude Security Review, Claude Code Mobile + Desktop Cloud Execution, Claude Tag (eine isolierte Aufgabe), worktree isolation CLI/Desktop, **Remote control** (Steuerung vom Handy aus). *Guardrails*: Team-Nutzungs-Analytics, Qualitätsdurchsetzung (Lint/Tests/Typecheck), **Claude-gestützte E2E-Verifikation** (Chrome-Erweiterung oder iOS/Android-Simulator-MCP), **derselbe Qualitätsmaßstab für menschlichen Code und Agenten-Code**, das Vorab-Freigeben von sicherem Bash/MCP in `settings.json`.
- **2→3:** Claude die Mittel geben, **Kontext abzurufen** (Code, Wikis, Diskussionen lesen); **Agency + Geschwindigkeit beim Code-Review** (Agenten dürfen den Code anderer Teams anfassen); Arbeit in **Loops und Routinen** zerlegen; **Claude Claude starten lassen**.
- **Stufe 3 — Supervised autonomy / Manager of Managers (~100).** Claude schreibt **den gesamten oder fast den gesamten** Code; die Frage verschiebt sich von *„hast du den Code gelesen?“* zu *„welcher Kontext fehlte dem Modell, und wie beheben wir das für das nächste Mal?“*. *Unlock*: Claude erledigt **proaktiv**, was früher von Hand gestartet wurde; Wartung/Aufräumarbeiten laufen **kontinuierlich im Hintergrund**. *Engpass*: **Vertrauen in die Loop** und der **Entscheidungsdurchsatz des Teams** — der Agentenbaum ist zu tief, um beaufsichtigt zu werden; die Falle ist, *die Anzahl der Agenten zu skalieren, bevor die Loop sich Vertrauen verdient hat*. Zu überwachende Token-Effizienz (OTel/Analytics), eine Kultur des Experimentierens + Kostenkontrolle, sobald interne Nutzung PMF erreicht. Test: *„ist das etwas, das ein Engineer getan hätte?“*. *Produkte*: Subagenten mit **worktree isolation** (keine Kollisionen), **Routines, /loop, /batch, /goal**, **dynamische Workflows**, Claude Tag (beobachtet einen Kanal/eine Quelle und startet Aufgaben). *Guardrails*: automatisiertes Code-Review + Security-Review, **Agent-Sandboxing**, **CLAUDE.md + Skills** zur Kodifizierung von Standards, **Feintuning des Auto-mode-Klassifikators**, Steuerung des Token-Verbrauchs (Modellauswahl, Advisors, LSP, Aufteilung von CLAUDE.md in **lazy Skills**).
- **3→4:** **Automatisierung im großen Maßstab für domänenspezifische Anwendungsfälle** (Code-Migration, Fuzzing, Feature-Entwicklung, Feedback-Behebung).
- **Stufe 4 — AI-native / VP Steering by Intent (~1.000+).** Eine **vollständig geschlossene** Loop; **die meisten Agenten werden von Claude selbst gestartet**; Hunderte bis Tausende laufender Agenten; Steuerung **nach Intent** und Überwachung **nach dem Ausnahmeprinzip**. *Unlock*: Eine quartalslange Migration wird zu einem **Workflow, den man startet und dann kontrolliert**. *Engpass*: **Arbeit im großen Maßstab identifizieren und automatisieren** + pro *Art* der Arbeit die richtigen Guardrails durchsetzen. *Produkte*: **Claude Agent SDK** (Agenten programmatisch bauen/planen), Claude Tag (in den meisten Slack-Kanälen präsent, antwortet auf Posts). *Guardrails*: Kostenkontrollen für Automatisierung, Modellauswahl für Automatisierung.
- **Anti-Vanity-Metrik (Steuerung).** Nutzung (Dashboard) misst **Aktivität, nicht Ertrag**. Bessere Frage: *hätten wir hierfür ohnehin Engineering-Aufwand investiert, und wenn ja, wie viele **manuelle Engineer-Stunden** hätte es gekostet?* → das ist der **ROI**. Der Jackpot: Wenn Fixes/Wartung in den Hintergrund wandern, tun Teams „Dinge, die vorher nicht einmal im Bereich des Möglichen lagen“.
- **Selbsteinschätzungs-Benchmark.** *Anthropic steht auf Stufe 3 und strebt Richtung 4*; *Boris Cherny erklärt, selbst auf Stufe 4 zu sein*. Nützlich als ehrlicher Maßstab: Nicht einmal der Anbieter ist „ganz oben angekommen“.
- **Verwandt**: Begleitstück zu [[fiches/2026-07/cherny-wu-reflecting-year-claude-code-2026-07-17\|Cherny & Wu — « Reflecting on a year of Claude Code »]] (gleicher Autor, Shipping wird billig → Wert verschiebt sich zum Urteilsvermögen); „Agent-Manager/Orchestrierung“-Korpus (Sankars great flattening, Martignoles Token-Manifest); Guardrails & Verifikation (Compound Engineering, Self-Verification-Loop).

## RésuméDe400mots

Boris Cherny, Creator & Head of Claude Code bei Anthropic, veröffentlicht eine Framework-Tabelle — **« Steps of AI Adoption »** — entstanden aus einer wiederkehrenden Beobachtung: In vielen Unternehmen vervielfacht *eine einzelne* Person ihren Output mit Claude um das Zehnfache, aber der Rest der Organisation zieht nicht nach. Daraus leitet er eine **5-stufige Reifeskala (0→4)** ab, strukturiert um die **Größenordnung der von einem Engineer gesteuerten Agenten** — und die dadurch erzwungene Rollentransformation.

**0 — Gated (0 Agenten)**: abgeschotteter Zugang, ältere Modelle, keine MCP-Governance und keine Infrastruktur, um Claudes Code zu hosten; Engpass = veraltete Sicherheits-/Freigabeprozesse und eine Fixierung auf Kosten pro Token. **1 — Assisted (~1)**: „du + ein Agent“, betreutes Pair Programming, synchrone Arbeit; Engpass = deine Aufmerksamkeit, da du ohne Self-Verification alles selbst prüfst. **2 — Parallel (~10)**: du wirst zum **Orchestrator** von 5–10 Agenten auf getrennten Worktrees; Claude verifiziert sich selbst (Tests/Build/Lint/Security), Auto mode und automatisierte Reviews sind Standard; Engpass = das Prüfen mehrerer paralleler Stränge. **3 — Supervised autonomy (~100)**: **Manager of Managers**, Claude schreibt fast alles, Wartung läuft im Hintergrund; Engpass = Vertrauen in die Loop und der Entscheidungsdurchsatz. **4 — AI-native (~1.000+)**: **VP Steering by Intent**, eine geschlossene Loop, in der Claude die meisten Agenten selbst startet, Überwachung nach dem Ausnahmeprinzip.

**Zentrale These**: Tokens bringen keinen Stufenaufstieg. Jede Stufe hat ihren eigenen Engpass; Fortschritt entsteht durch **dessen Auflösung** und den **Aufbau des nächsten Satzes an Guardrails**, der den Output vertrauenswürdig macht. Die genannten Hebel: Self-Verification-Loop (Tests + Build + Lint + E2E in einer echten Umgebung), **Auto mode** gegen blockierende Abfragen, **Code-Review + Security-Review als Standard**, Multi-Agenten-Oberflächen (Agent View, Desktop, Mobile, Tag), dann `/loop`, `/batch`, `/goal`, **dynamische Workflows**, **worktree isolation**, **CLAUDE.md + Skills** zur Kodifizierung von Standards, und schließlich das **Claude Agent SDK**, um Agentenflotten programmatisch zu bauen und zu steuern.

Zum Thema Steuerung verwirft Cherny die Vanity-Metrik: Nutzung misst **Aktivität, nicht Ertrag**. Die richtige Frage — *hätten wir diesen Aufwand ohnehin investiert, und wie viele **manuelle Engineer-Stunden** hätte es gekostet?* — liefert den wahren ROI. Der entscheidende Gewinn kommt, wenn Fixes/Wartung in den Hintergrund wandern und Teams frei werden, um Dinge zu *bauen*, die zuvor nicht einmal in Reichweite lagen. Ein ehrlicher Maßstab: Anthropic steht auf Stufe 3 und strebt Richtung 4; er selbst habe soeben Stufe 4 erreicht.

## 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/de/fiches/cherny-steps-ai-adoption-2026-07-16/