# Mike Bild
> Software-Architekt & Engineer in Berlin. Über 30 Jahre Software, seit gut 15 Jahren mit Schwerpunkt auf verteilten Systemen, APIs und digitalen Produkten. Heute auch Agentic Engineering.
## Navigation
- [Profil](https://www.mikebild.dev/de/profil/)
- [Blog](https://www.mikebild.dev/de/blog/)
- [Projekte](https://www.mikebild.dev/de/projects/)
- [Kontakt](https://www.mikebild.dev/de/contact/): mike.bild@gmail.com
- [GitHub](https://github.com/MikeBild)
- [LinkedIn](https://www.linkedin.com/in/mikebild)
- [Mike Bild · Blog](https://www.mikebild.dev/de/feed.xml)
- [Mike Bild · Blogcast](https://www.mikebild.dev/de/blogcast.xml): Ausgewählte Blog-Beiträge von Mike Bild als Hörfassung – Softwarearchitektur, Engineering und Methodik.
- [MCP-Wissensserver](https://worker.mikebild.dev/workshop-online-api/knowledge/mcp): Artikel, Folien und Workshop-Katalog für KI-Assistenten, nur lesend, ohne Anmeldung. Anleitung: https://www.mikebild.dev/de/mcp/
- [English](https://www.mikebild.dev/en/llms-full.txt)
## Aktuelle Projekte
- [SubKit](https://subkit.mikebild.dev/de/): Einmal mit der KI gebaut, per Freigabe fürs Team: Workflows mit Rechten und Verlauf. (Beta auf Einladung)
- [Harmoniqs](https://harmoniqs.mikebild.dev/de/): Songideen mit Akkorden, Looper und BRAIN entwickeln. (Beta)
- TackTics: Ein Segeltrainer, der Daten von Bord auswerten soll. (In Arbeit)
## Training
- [JavaScript & TypeScript: Von Werten zu Verträgen](https://slides.mikebild.dev/introduction-javascript-typescript.html): Von Werten und Funktionen über ESM und Async bis zu Generics, Runtime Validation und Library Design. – Repository: https://github.com/MikeBild/introduction-javascript – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-javascript-typescript/introduction-javascript-typescript.pdf?v=c6f94b1ce22b – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-javascript-typescript/introduction-javascript-typescript.mp4?v=c6f94b1ce22b – English: https://slides.mikebild.dev/introduction-javascript-typescript.en.html
- [Python für Entwickler mit uv, pytest und Flask](https://slides.mikebild.dev/introduction-python.html): Daten einlesen und analysieren, Web-APIs mit Flask und ihre Tests, funktionale Muster und fortgeschrittenes Python. – Repository: https://github.com/MikeBild/introduction-python – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-python/introduction-python.pdf?v=187505d0ac21 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-python/introduction-python.mp4?v=187505d0ac21 – English: https://slides.mikebild.dev/introduction-python.en.html
- [Moderne Web-Plattform ohne Framework](https://slides.mikebild.dev/introduction-web-plattform.html): Semantisches HTML, Accessibility, modernes CSS, Formulare, ES Modules ohne Build, fetch, Web Components, View Transitions und Offline. – Repository: https://github.com/MikeBild/introduction-web-plattform – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-web-plattform/introduction-web-plattform.pdf?v=a232e20fe8ed – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-web-plattform/introduction-web-plattform.mp4?v=a232e20fe8ed – English: https://slides.mikebild.dev/introduction-web-plattform.en.html
- [Node.js: Eine moderne Einführung](https://slides.mikebild.dev/introduction-nodejs.html): Runtime und Event Loop, asynchrone Muster, Webentwicklung mit Express, Testing und Skalierung mit Node.js 26. – Repository: https://github.com/MikeBild/introduction-nodejs – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-nodejs/introduction-nodejs.pdf?v=53ea4f3ddcf2 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-nodejs/introduction-nodejs.mp4?v=53ea4f3ddcf2 – English: https://slides.mikebild.dev/introduction-nodejs.en.html
- [React: Von der Komponente zur Architektur](https://slides.mikebild.dev/introduction-react.html): Von JSX über Zustand, Daten und Routing bis zur Komponentenarchitektur mit React 19. – Repository: https://github.com/MikeBild/introduction-react – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-react/introduction-react.pdf?v=a9fa9b32eb2d – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-react/introduction-react.mp4?v=a9fa9b32eb2d – English: https://slides.mikebild.dev/introduction-react.en.html
- [Svelte 5 und SvelteKit mit TypeScript](https://slides.mikebild.dev/introduction-svelte.html): Der Compiler statt Virtual DOM, Runes, Snippets, geteilter Zustand und Context, Motion und Transitions bis zur App mit SvelteKit. – Repository: https://github.com/MikeBild/introduction-svelte – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-svelte/introduction-svelte.pdf?v=b2e7a5fb6237 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-svelte/introduction-svelte.mp4?v=b2e7a5fb6237 – English: https://slides.mikebild.dev/introduction-svelte.en.html
- [KnockoutJS modernisieren und schrittweise migrieren](https://slides.mikebild.dev/introduction-knockoutjs.html): MVVM und Observables mit Knockout 3.5, modern betrieben mit TypeScript, Vite und Vitest. Dazu schrittweise Migration über Web Components und Sicherheit. – Repository: https://github.com/MikeBild/introduction-knockoutjs – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-knockoutjs/introduction-knockoutjs.pdf?v=65e98e30ed2f – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-knockoutjs/introduction-knockoutjs.mp4?v=65e98e30ed2f – English: https://slides.mikebild.dev/introduction-knockoutjs.en.html
- [GraphQL: Vom Type System zum Produktionsbetrieb](https://slides.mikebild.dev/introduction-graphql.html): Schema, Abfragen und Resolver, Echtzeit, Caching und Sicherheit bis zur föderierten API. – Repository: https://github.com/MikeBild/introduction-graphql – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-graphql/introduction-graphql.pdf?v=a904d4f12af2 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-graphql/introduction-graphql.mp4?v=a904d4f12af2 – English: https://slides.mikebild.dev/introduction-graphql.en.html
- [Reactive Programming mit RxJS](https://slides.mikebild.dev/introduction-reactive-programming.html): Streams für Suche, Live-Status und Benutzereingaben, mit Operatoren, Error Handling und Tests auf virtueller Zeit. – Repository: https://github.com/MikeBild/Reactive-Programming – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-reactive-programming/introduction-reactive-programming.pdf?v=d0df6308a9e1 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-reactive-programming/introduction-reactive-programming.mp4?v=d0df6308a9e1 – English: https://slides.mikebild.dev/introduction-reactive-programming.en.html
- [Docker & Kubernetes](https://slides.mikebild.dev/introduction-docker-kubernetes.html): Die Werkstatt-Shop-API in Containern und im Cluster: von Image und Compose bis Rollout, Gateway API und Härtung, lokal mit kind. – Repository: https://github.com/MikeBild/introduction-docker – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-docker-kubernetes/introduction-docker-kubernetes.pdf?v=ada5b80ab5b4 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-docker-kubernetes/introduction-docker-kubernetes.mp4?v=ada5b80ab5b4 – English: https://slides.mikebild.dev/introduction-docker-kubernetes.en.html
- [AWS Serverless mit Lambda, CDK und DynamoDB](https://slides.mikebild.dev/introduction-aws-serverless.html): Lambda, DynamoDB, AppSync, Cognito, Step Functions und SES: serverlose Dienste auf AWS, vom Datenmodell bis zum Workflow. – Repository: https://github.com/MikeBild/introduction-aws – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-aws-serverless/introduction-aws-serverless.pdf?v=3c288d19e4b3 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-aws-serverless/introduction-aws-serverless.mp4?v=3c288d19e4b3 – English: https://slides.mikebild.dev/introduction-aws-serverless.en.html
- [Microservices mit Node.js, Express 5 und Docker Compose](https://slides.mikebild.dev/introduction-microservices.html): Vom Modulith zu Services mit Express 5: Verträge, Docker Compose, Events mit Outbox, Sagas, Resilienz und Contract Tests. – Repository: https://github.com/MikeBild/introduction-microservices – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-microservices/introduction-microservices.pdf?v=77faddde1953 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-microservices/introduction-microservices.mp4?v=77faddde1953 – English: https://slides.mikebild.dev/introduction-microservices.en.html
- [Design Patterns als Funktionen](https://slides.mikebild.dev/introduction-design-patterns.html): Adapter, Chain of Responsibility, Strategy, Provider und Observer als Funktionen in TypeScript, wiedererkannt in Express, React und Apollo. – Repository: https://github.com/MikeBild/introduction-design-patterns – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-design-patterns/introduction-design-patterns.pdf?v=346286ff1417 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-design-patterns/introduction-design-patterns.mp4?v=346286ff1417 – English: https://slides.mikebild.dev/introduction-design-patterns.en.html
- [Architektur: DDD, CQRS und Event Sourcing](https://slides.mikebild.dev/introduction-cqrs-event-sourcing.html): Commands, Events und Queries trennen, das Aggregat als Konsistenzgrenze, Read Models als Projections und ein Event-Store auf AWS. – Repository: https://github.com/MikeBild/introduction-nodejs/tree/master/EXAMPLES/ARCHITECTURE – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-cqrs-event-sourcing/introduction-cqrs-event-sourcing.pdf?v=52932c059f5f – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-cqrs-event-sourcing/introduction-cqrs-event-sourcing.mp4?v=52932c059f5f – English: https://slides.mikebild.dev/introduction-cqrs-event-sourcing.en.html
## Blog
- [Zwischenfazit und Systemblick: eine Bilanz der Serie](https://www.mikebild.dev/de/blog/von-der-session-zum-system-zwischenfazit/): Monate nach dem Gespräch, mit dem alles begann, ist es Zeit für eine ehrliche Bilanz: welche Erwartungen des Auftakts eingetreten sind, welche nicht, was offen bleibt – und warum die spannendste Frage nicht mehr lautet, was die Modelle können, sondern was Organisationen daraus machen.
- [MCP, HTTP, Webhooks und A2A einfach erklärt](https://www.mikebild.dev/de/blog/mcp-http-webhooks-a2a-einfach-erklaert/): MCP, HTTP mit OpenAPI, Webhooks und A2A verbinden Systeme auf unterschiedlichen Ebenen. Entscheidend ist, welche Verantwortung an der jeweiligen Grenze liegt.
- [A2A: Wenn Agenten zusammenarbeiten](https://www.mikebild.dev/de/blog/a2a-agenten-zusammenarbeit/): Agent Card, Message, Task und Artifact verständlich erklärt: wie A2A 1.0 eigenständige Agentensysteme verbindet, was das Protokoll von MCP unterscheidet und wann sich die Delegation an ein eigenständiges System lohnt.
- [Stündlich ist nicht Echtzeit](https://www.mikebild.dev/de/blog/stuendlich-ist-nicht-echtzeit/): Ein abgeschlossener Stundenreport beantwortet andere Fragen als laufende Betriebsbeobachtung – und wird einfacher, sobald Zeitfenster, Verspätung und Messlücken ausdrücklich modelliert sind.
- [Claims: klein, belegt, prüfbar](https://www.mikebild.dev/de/blog/claims-klein-belegt-pruefbar/): Claims zerlegen Wiki-Seiten in einzelne Aussagen mit Subjekt, Prädikat, Objekt, Confidence, Status und wörtlichem Beleg. Dadurch werden Zustimmung und Widerspruch präzise.
- [Produkte berichten über ihre API](https://www.mikebild.dev/de/blog/produkte-berichten-ueber-ihre-api/): Produktstatistiken bleiben verständlich, wenn jedes System seine Daten selbst verdichtet und über einen kleinen, zeitlich einheitlichen HTTP-Vertrag anbietet.
- [Vom Organigramm zur Produktverantwortung](https://www.mikebild.dev/de/blog/vom-organigramm-zum-arbeitsfluss/): KI macht den Weg vom Kundenproblem bis zur Wirkung durchgängiger.
- [llms.txt: Doku für Maschinen](https://www.mikebild.dev/de/blog/llms-txt-und-llms-full-txt/): Kontext für Modelle, nicht fürs Ranking: warum llms.txt und llms-full.txt Coding-Agenten helfen – und was ein MCP-Server daraus macht.
- [Hilfsmittel, die tragen: Konzepte, Methoden, Prozesse](https://www.mikebild.dev/de/blog/hilfsmittel-konzepte-methoden-prozesse/): Einen Agenten für die eigene Fachdomäne kann man nicht installieren – den Weg dorthin aber sehr wohl lernen. Welche Konzepte tragen, welche Methoden den Anfang klein halten und welche Prozesse verhindern, dass Regeln veralten.
- [KI-Agenten pro Fachdomäne: Regeln, Freigaben und Nachweise](https://www.mikebild.dev/de/blog/eigener-agent-pro-fachdomaene/): Wie ein KI-Agent fachliche Regeln über mehrere Tool-Aufrufe hinweg durchsetzt: mit Vorgangszustand, geprüften Plänen, Freigaben und nachvollziehbarer Ausführung.
- [MCP-Sicherheit: Tools, Rechte und Freigaben für KI-Agenten](https://www.mikebild.dev/de/blog/mcp-softwarefaehigkeiten-agenten/): Wie du MCP-Tools sicher in Anwendungen einbindest: serverseitige Rechteprüfung, menschliche Freigaben, Schutz vor Prompt Injection und nachvollziehbare Aufrufe.
- [Agent, Modell, Fachdomäne](https://www.mikebild.dev/de/blog/agent-modell-fachdomaene/): Das Modell ist gemietet, der Agent kann unter eigener Kontrolle stehen – entscheidend ist, ob die Fachdomäne als Prosa im Prompt liegt oder als geprüfte Schnittstelle im Agenten.
- [Wissen, das die Session überlebt](https://www.mikebild.dev/de/blog/wissen-das-die-session-ueberlebt/): Session-Wissen verdampft, wenn niemand es kuratiert – warum Teams ihr KI-Arbeitswissen wie Code behandeln sollten und dabei nicht das Modell schlauer wird, sondern die Organisation lernt.
- [Sauberes Grounding II: Antworten erden](https://www.mikebild.dev/de/blog/sauberes-grounding-antworten-erden/): Mein Arbeitsmodell für Grounding unterscheidet Konventionen, Dokumente und API-Beschreibungen. Was im knappen Kontext bleibt, priorisiere ich nach Aufgabe und Wiederbeschaffungskosten.
- [KI im Enterprise-Umfeld: Schnellere Entwicklung braucht andere Prozesse](https://www.mikebild.dev/de/blog/ki-im-konzern-schnellere-entwicklung-andere-prozesse/): KI verkürzt Recherche, Entwurf und Implementierung. Bleiben Übergaben, Ticket-Hierarchien und Freigaben unverändert, verlagert sich der Engpass – Großunternehmen müssen deshalb Arbeitsfluss und Governance gemeinsam neu ordnen.
- [Sauberes Grounding I: Warum die KI so überzeugend rät](https://www.mikebild.dev/de/blog/sauberes-grounding-warum-ki-raet/): Warum Sprachmodelle plausible Dinge erfinden, weshalb mehr Training das Problem nicht zuverlässig beseitigt und was Grounding damit zu tun hat.
- [Mein Erfolg lässt sich nicht kopieren](https://www.mikebild.dev/de/blog/mein-erfolg-laesst-sich-nicht-kopieren/): Ein Kollege übernimmt mein KI-Setup und bekommt andere Ergebnisse. Werkzeuge, Tests und Konventionen sind übertragbar; Aufgabenzuschnitt, Prüfblick und der einzelne Sessionverlauf sind es nur begrenzt.
- [Was ich kritisch sehe](https://www.mikebild.dev/de/blog/was-ich-kritisch-sehe/): Vier Beobachtungen und eine offene Hypothese nach intensiven Monaten mit KI – vom möglichen Kompetenzverlust bis zur Sorge vor gleichförmigeren Lösungen und meinen praktischen Gegenmaßnahmen.
- [Gut genug: das Modell ist selten der Engpass](https://www.mikebild.dev/de/blog/gut-genug-modelle/): Bei den Alltagsaufgaben, die ich selbst mit KI bearbeite, ist die Modellwahl selten der erste Engpass. Aufgabenzuschnitt, Kontext und Prüfung wirken meist stärker.
- [Vom Werkzeug zur Arbeitsweise](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/): Wie ein Gespräch in Berlin mich nach über dreißig Jahren Softwarehandwerk zum täglichen Arbeiten mit Claude, ChatGPT und Claude Code gebracht hat – und warum ich meiner Begeisterung trotzdem erst einmal misstraue.
- [React-Überblick: Von JSX zur Komponentenarchitektur](https://www.mikebild.dev/de/blog/react-ueberblick-von-jsx-zur-architektur/): Ein kompletter Durchgang durch React, wie ich es heute unterrichte – vom deklarativen Rendern über die Frage, wem ein State gehört, bis zur Architektur einer wachsenden Anwendung. Die Details zu einzelnen Stationen kommen später als eigene Beiträge.
- [Formulare in React 19: Actions, useActionState und useOptimistic](https://www.mikebild.dev/de/blog/formulare-in-react-19-mit-actions/): React 19 macht das Formular zur eigentlichen Schnittstelle: eine Funktion als form action, dazu drei Hooks für Ergebnis, Pending State und sofortiges UI-Feedback. Dieser Beitrag zeigt das Zusammenspiel – und wo optimistisches Rendern ohne sauberen Fehlerpfad kippt.
- [React Server Components und Server Actions: Die neue Grenze](https://www.mikebild.dev/de/blog/react-server-components-und-server-actions/): Server Components laufen außerhalb des Client-Bundles und liefern ihr Ergebnis statt ihres Codes an den Browser. Server Functions holen Schreibvorgänge auf den Server – umgesetzt wird beides durch ein passendes Framework oder einen Bundler.
- [React Router Data Router: Die URL als State-Ort](https://www.mikebild.dev/de/blog/react-router-data-router/): Der Data Router von React Router macht die URL zum Koordinationspunkt – eine Route lädt ihre Daten per loader vor dem Rendern und schreibt über action, sodass Ladelogik aus dem Komponenten-Body verschwindet.
- [React Transitions: nicht dringende Updates mit useTransition](https://www.mikebild.dev/de/blog/react-transitions-mit-usetransition/): useTransition markiert Updates als nicht dringend und hält React während teurer oder suspendierender Renderings responsiv. Dazu useDeferredValue als Werkzeug für nachgelagerte Renderings.
- [React Testing ohne Theater](https://www.mikebild.dev/de/blog/react-testing-ohne-theater/): Tests auf sichtbares Nutzerverhalten koppeln weniger an DOM-Struktur, Komponentengrenzen und internen State. Dadurch überstehen sie bestimmte Refactorings ohne Anpassung.
- [Suspense und der use-Hook: rendern, als wären die Daten schon da](https://www.mikebild.dev/de/blog/react-suspense-und-use/): Statt in jeder Komponente einen Ladezustand zu verwalten, beschreibt man mit Suspense an einer einzigen Stelle im Baum, was während des Wartens erscheint – und der use-Hook lässt die Komponente darunter rendern, als wären die Daten längst da.
- [Client State vs. Server-Cache: die folgenreichste Grenze im Frontend](https://www.mikebild.dev/de/blog/client-zustand-und-server-cache/): Serverdaten sind State, aber nicht client-eigener State. Warum diese Unterscheidung wichtig ist, wann useEffect zum schlechten Cache wird und was eine Server-State-Bibliothek übernimmt.
- [Scheduler und virtuelle Zeit testen](https://www.mikebild.dev/de/blog/scheduler-und-virtuelle-zeit-testen/): Injizierbare Zeit macht zeitabhängige Regeln schnell und deterministisch testbar. Daten, Isolation und externe Systeme bleiben davon unberührt.
- [GraphQL-Überblick: Vom Schema zur föderierten API](https://www.mikebild.dev/de/blog/graphql-ueberblick-vom-schema-zur-foederierten-api/): Ein Durchgang durch GraphQL – vom typisierten Schema über Queries und Resolver bis zu Echtzeit, Betrieb und föderierter Architektur, eingeordnet am Stand von Oktober 2024.
- [HTTP/2 und Server-Sent Events in Node.js](https://www.mikebild.dev/de/blog/nodejs-http2-und-server-sent-events/): Wie HTTP/2 viele Streams über eine Verbindung multiplext und warum Server-Sent Events oft die einfachere Antwort auf Live-Daten sind als WebSocket – mit einem lauffähigen SSE-Endpoint in Node und den üblichen Fallstricken.
- [Markdown Reports statt Dashboard-Zwang](https://www.mikebild.dev/de/blog/markdown-reports-statt-dashboard/): Warum ein diffbarer Markdown Report für Nachvollziehbarkeit, Review und Betrieb oft mehr leistet als ein Dashboard – und wie ich das architektonisch aufziehe.
- [GraphQL Federation: ein Schema aus vielen Subgraphs](https://www.mikebild.dev/de/blog/graphql-federation-und-subgraphs/): Wenn ein Team ein Monolith-Schema nicht mehr allein tragen kann, teilt Federation den Graphen in Subgraphs auf, die ein Router zu einem Supergraph komponiert. Dieser Artikel zeigt an einem User- und Orders-Beispiel, wie @key und __resolveReference Entities über Subgraph-Grenzen hinweg zusammenhalten.
- [Fuzzy Matching mit expliziten Grenzen](https://www.mikebild.dev/de/blog/fuzzy-matching-mit-grenzen/): Ein Fuzzy-Match ist eine Behauptung mit Konfidenz, kein Fakt – nützlich wird er erst durch versionierte Schwellwerte, drei Entscheidungszonen und einen diffbaren Report der Grauzone.
- [Event Sourcing auf AWS: DynamoDB Streams und Lambda](https://www.mikebild.dev/de/blog/event-sourcing-auf-aws-dynamodb-streams/): Event Sourcing serverless umgesetzt: DynamoDB als append-only Event-Store, DynamoDB Streams als Change-Feed und Lambda als idempotenter Projector in CQRS-Read-Models.
- [RxJS testen mit Marble-Diagrammen](https://www.mikebild.dev/de/blog/rxjs-testen-mit-marble-diagrammen/): Marble-Diagramme machen den zeitlichen Ablauf asynchroner Streams sichtbar. Mit TestScheduler.run und virtueller Zeit testest du RxJS-Operatoren deterministisch: kein echtes Warten, keine Flakiness.
- [Rechnungsdaten als Domäne](https://www.mikebild.dev/de/blog/rechnungsdaten-als-domaene/): Warum ein Rechnungsimport kein CSV-Job ist, sondern eine Fachdomäne mit eigenen Begriffen, Invarianten und Zeitregeln – und wie explizite Typen und ein Ablehnungs-Report aus stillen Datenfehlern erklärbare Daten machen.
- [Node.js testen: die Testpyramide mit Mocha](https://www.mikebild.dev/de/blog/nodejs-testing-mit-mocha/): Wie sich eine Node.js-Testsuite sinnvoll auf verschiedene Testebenen verteilt und wie Mocha, node:assert, sinon und supertest dabei zusammenspielen.
- [Deterministische CLIs](https://www.mikebild.dev/de/blog/deterministische-clis/): Determinismus ist eine Architekturentscheidung: gleiche Eingaben, gleicher Report, reviewbar per Diff. Er lohnt sich dort, wo ein Artefakt wiederholt geprüft wird.
- [Observability mit OpenTelemetry: Logs, Traces und Metrics](https://www.mikebild.dev/de/blog/observability-mit-opentelemetry/): Logs, Traces und Metrics mit OpenTelemetry einheitlich instrumentieren, über Trace-IDs verbinden und per OTLP an geeignete Backends ausgeben.
- [Der GraphQL-Client: Apollo Link und Fragments](https://www.mikebild.dev/de/blog/graphql-client-apollo-link-und-fragments/): Apollo Link lässt jede GraphQL-Operation durch eine Kette von Middleware laufen: authLink setzt Header, errorLink behandelt Fehler zentral, split routet Subscriptions. Dazu Fragments als wiederverwendbare Feldmengen und warum Interfaces possibleTypes brauchen.
- [OCR mit Cache und Misstrauen](https://www.mikebild.dev/de/blog/ocr-mit-cache-und-misstrauen/): Warum sich eine OCR-Pipeline für Belegdaten erst dann zuverlässig anfühlt, wenn man jeden erkannten Wert mit Hash-Cache, Confidence-Gate und Plausibilitätsregeln absichert statt ihm zu glauben.
- [Die vier Subject-Typen in RxJS](https://www.mikebild.dev/de/blog/rxjs-die-vier-subject-typen/): Subject, BehaviorSubject, ReplaySubject und AsyncSubject unterscheiden sich darin, was späte Subscriber sehen und wie Abschluss oder Fehler ihr gespeichertes Verhalten beenden.
- [Apollo Client: der normalisierte Cache und optimistische Updates](https://www.mikebild.dev/de/blog/graphql-client-caching-mit-apollo/): HTTP-Caching ist auch mit GraphQL möglich, aber für Client-Zustand oft weniger direkt. Apollo normalisiert deshalb Objekte und unterstützt optimistische Updates in der UI.
- [GraphQL absichern: Query-Tiefe, Komplexität und Rate-Limiting](https://www.mikebild.dev/de/blog/graphql-absichern-depth-complexity-rate-limiting/): Ein einziger GraphQL-Endpoint nimmt beliebig verschachtelte Queries an – das ist bequem und zugleich ein Missbrauchsrisiko. Ich zeige, wie ich mit Depth-Limit, Complexity-Budget, Pagination-Caps und Rate-Limiting eine mehrschichtige Verteidigung gegen teure Queries baue.
- [TypeScript in Node.js: Setup, Typen und Tests](https://www.mikebild.dev/de/blog/typescript-in-node/): TypeScript in einem Node-Projekt aufsetzen: tsconfig-Essentials verstehen, async und Handler typisieren und die Tests laufen lassen, Schritt für Schritt aus der Projektpraxis.
- [TypeScript in React: Props, Hooks und Events typisieren](https://www.mikebild.dev/de/blog/typescript-in-react/): Wie aus Props und State überprüfbare Verträge werden – und der Editor Fehler meldet, bevor der Nutzer sie sieht. Von interface/type über useState-Generics und Event-Typen bis zu useRef und Utility-Types.
- [Resilience-Pattern: Timeout, Retry, Circuit Breaker, Idempotenz](https://www.mikebild.dev/de/blog/resilience-muster-timeout-retry-circuit-breaker/): Warum Resilienz kein Zufall ist: Timeout, Retry mit Backoff und Jitter, Circuit Breaker und Idempotenz als bewusst entworfene Muster gegen die Ausfallmodi verteilter Systeme.
- [GraphQL-Subscriptions über SSE: Echtzeit ohne WebSocket-Zwang](https://www.mikebild.dev/de/blog/graphql-subscriptions-ueber-sse/): Subscriptions brauchen keinen WebSocket. Server-Sent Events genügen für den einseitigen Server-zu-Client-Kanal, während Query und Mutation normales HTTP bleiben, und das Schema entscheidet, was überhaupt ein Domänen-Event ist.
- [Contract Testing statt E2E-Marathon](https://www.mikebild.dev/de/blog/contract-testing-statt-e2e-marathon/): Consumer-Driven Contracts prüfen Schnittstellen an der Grenze zwischen Services statt in einer teuren, flaky End-to-End-Suite. Das Ergebnis: ein schnelleres, deterministisches Deploy-Gate und Teams, die unabhängig releasen.
- [Fehler als Architektur in Node.js: Netze gegen den Absturz](https://www.mikebild.dev/de/blog/nodejs-fehler-als-architektur/): Error Handling in Node.js ist keine try/catch-Kosmetik, sondern eine Entscheidung über Ebenen, Eskalation und geordnetes Beenden. Wer die vier Fehler-Ebenen kennt und Graceful Shutdown ernst nimmt, baut Dienste, die kontrolliert sterben statt korrupt weiterzulaufen.
- [DORA-Metrics: was Entwicklungszyklen wirklich verkürzt](https://www.mikebild.dev/de/blog/dora-metriken-was-zyklen-verkuerzt/): Lead Time, Deploy-Frequenz, Change-Fail-Rate und Recovery-Zeit sind Diagnosewerte statt Vanity-Velocity. Sie zeigen, wo der Zyklus klemmt – und warum Tempo und Stabilität kein Gegensatz sein müssen.
- [child_process in Node.js: Skalierung ohne Illusionen](https://www.mikebild.dev/de/blog/nodejs-child-process-und-skalierung/): Node.js läuft auf einem einzigen Event Loop – CPU-Arbeit blockiert alles. Dieser Beitrag zeigt, wann fork, cluster und worker_threads wirklich helfen und wann sie nur Overhead sind.
- [Lambda-Performance und Cold Starts verstehen](https://www.mikebild.dev/de/blog/lambda-performance-und-cold-starts/): Was ein Cold Start bei AWS Lambda wirklich ist, welche Hebel du steuern kannst – von Bundle-Size über Init-Code und Memory bis Provisioned Concurrency – und wie du das Ganze sauber misst.
- [RxJS in Node.js: Event Streams reaktiv verarbeiten](https://www.mikebild.dev/de/blog/rxjs-in-node-ereignisstroeme/): RxJS in Node.js: Wie fromEvent einen EventEmitter in ein Observable verwandelt, Operatoren serverseitige Ströme deklarativ transformieren und warum RxJS keine echte Backpressure hat.
- [Evolutionary Architecture: Systeme, die sich ändern dürfen](https://www.mikebild.dev/de/blog/evolutionary-architecture-wandel-einplanen/): Architektur ist kein Endzustand, den man einmal festzurrt. Kleine Änderungen und passende Fitness Functions machen ausgewählte Risiken früher sichtbar, garantieren aber weder Tempo noch Qualität.
- [Von HOCs und Render Props zu Custom Hooks](https://www.mikebild.dev/de/blog/von-hocs-und-render-props-zu-custom-hooks/): Wie teile ich Logik zwischen Komponenten ohne Copy-Paste? Custom Hooks vermeiden dafür meist verschachtelte Wrapper; HOCs und Render Props behalten einzelne Kompositionsaufgaben.
- [Async-Kontext in Node.js: AsyncLocalStorage, async_hooks und diagnostics_channel](https://www.mikebild.dev/de/blog/nodejs-async-context-mit-asynclocalstorage/): Wie man request-bezogenen Kontext wie Request-ID, User und Trace durch tiefe asynchrone Aufrufketten trägt, ohne ihn durch jede Funktionssignatur zu fädeln – mit AsyncLocalStorage, dem darunterliegenden async_hooks und diagnostics_channel für entkoppeltes Tracing.
- [GraphQL-Auth: Identität im Context, Autorisierung in der Fachlogik](https://www.mikebild.dev/de/blog/graphql-auth-im-context/): Der GraphQL-Context transportiert die Identität eines Requests. Ob diese Identität eine Operation ausführen darf, entscheidet eine zentrale Policy in der Fachlogik.
- [Node.js lokal debuggen und profilieren](https://www.mikebild.dev/de/blog/nodejs-debuggen-und-beobachten/): Vom console.log-Reflex zum eingebauten Inspector: node --inspect, das debug-Modul, nodemon sowie erste CPU- und Speicherprofile für die lokale Diagnose.
- [Developer Productivity: verkürzte Zyklen bei hoher Qualität](https://www.mikebild.dev/de/blog/developer-productivity-verkuerzte-zyklen/): Kurze Feedbackschleifen bei verlässlicher Qualität sind mein Denkmodell für Developer Productivity. Wo tatsächlich gewartet wird, muss die eigene Durchlaufzeit zeigen.
- [Slots, Context und Web Components in Svelte](https://www.mikebild.dev/de/blog/svelte-slots-context-und-web-components/): Drei Kompositions-Werkzeuge in Svelte 3: Slots reichen Inhalt von außen hinein, die Context-API vermeidet Prop-Drilling, und Custom Elements machen eine Komponente framework-neutral wiederverwendbar.
- [Build vs. Runtime in Webprojekten](https://www.mikebild.dev/de/blog/build-vs-runtime-webprojekte/): Der Rendering-Zeitpunkt wird pro Route entschieden. Statische, dynamische und inkrementelle Modelle lassen sich nach Datenfrist, Kosten und Fehlerverhalten kombinieren.
- [Streams im Objektmodus: Datenpipelines jenseits von Bytes](https://www.mikebild.dev/de/blog/nodejs-streams-im-objektmodus/): Node.js-Streams transportieren nicht nur Bytes: Mit objectMode:true werden sie zu komponierbaren Datenpipelines aus parsen, filtern und aggregieren – inklusive der Brücke zu Async-Iteratoren.
- [Reproduzierbare Testpipelines: kein Flaky, kein Zufall](https://www.mikebild.dev/de/blog/reproduzierbare-testpipelines-kein-flaky/): Flakiness weist auf unkontrollierte Eingaben oder Abhängigkeiten hin. Wer Zeit, Daten und Isolation sichtbar macht, kann die Ursache eingrenzen und das Merge-Gate wieder belastbar machen.
- [Adapter-Design: wo Frameworks enden](https://www.mikebild.dev/de/blog/adapter-design-framework-grenzen/): Was ein Framework-Adapter wirklich leistet: der Vertrag über den Build-Output, die Übersetzung von Request und Response und die stillen Umgebungsannahmen an der Grenze zwischen SvelteKit und AWS.
- [RxJS in React: Observables im Datenfluss der Oberfläche](https://www.mikebild.dev/de/blog/rxjs-in-react-datenfluss/): RxJS glänzt in React nicht überall, sondern genau dort, wo asynchrone Events koordiniert werden müssen – entprellte Eingaben, abgebrochene Autocomplete-Requests, kontinuierliche Ströme. Der Beitrag zeigt die wenigen Stellen, an denen sich Observables wirklich lohnen, und wo useState völlig genügt.
- [Motion, Transitions und Animationen in Svelte](https://www.mikebild.dev/de/blog/svelte-motion-transitions-animationen/): Wie Svelte Bewegung deklarativ und ohne Extra-Bibliothek mitbringt: transition-Direktiven fürs Ein- und Ausblenden, svelte/motion für sanft interpolierte Werte und animate:flip fürs Umsortieren von Listen.
- [Buffers in Node.js: mit Binärdaten arbeiten](https://www.mikebild.dev/de/blog/nodejs-buffers-und-binaerdaten/): Warum JS-Strings für rohe Bytes nicht taugen und Buffer Nodes Werkzeug dafür ist: alloc gegen allocUnsafe, Encodings sauber lesen und schreiben, und die Speicherfalle hinter slice und subarray.
- [Svelte Stores: State außerhalb der Komponente](https://www.mikebild.dev/de/blog/svelte-stores-zustand-ausserhalb-der-komponente/): Svelte Stores sind ein minimales Modell für State, der nicht in eine einzelne Komponente passt: writable, readable, derived – plus die $-Kurzschreibweise, die abonniert und beim Unmount aufräumt.
- [Node.js-Streams: Backpressure verstehen und nutzen](https://www.mikebild.dev/de/blog/nodejs-streams-und-backpressure/): Warum ein schneller Producer einen langsamen Consumer nicht überrennen darf – und wie pipe, pipeline, der Rückgabewert von write() und das drain-Event die Flusskontrolle in Node.js regeln.
- [Fitness Functions: ausgewählte Architektureigenschaften prüfen](https://www.mikebild.dev/de/blog/fitness-functions-messbare-architektur/): Fitness Functions machen ausgewählte Eigenschaften wie Kopplung, Abhängigkeiten und Latenz kontinuierlich prüfbar. Fachliche Qualität und Architekturabwägungen ersetzen sie nicht.
- [Svelte-Reaktivität: der Compiler statt Virtual DOM](https://www.mikebild.dev/de/blog/svelte-reaktivitaet-compiler-ohne-virtual-dom/): Svelte kompiliert Komponenten zur Build-Zeit in gezielten DOM-Code, statt zur Laufzeit einen Virtual DOM zu diffen. Ich zeige das mentale Modell, die reaktive Zuweisung mit $: und die klassische push-Falle, die mir in Projekten immer wieder begegnet.
- [EventEmitter: das Event-Modell im Kern von Node.js](https://www.mikebild.dev/de/blog/nodejs-eventemitter-und-ereignismodell/): EventEmitter ist der gemeinsame Nenner unter Streams, HTTP-Server und Prozessen: Ich zeige on/once/off/emit, das Sonderverhalten von 'error' und wie man Listener-Lecks vermeidet.
- [GraphQL-Paginierung: Cursor, Connections und das Relay-Pattern](https://www.mikebild.dev/de/blog/graphql-paginierung-und-connections/): Warum offset/limit bei bewegten Listen Duplikate und Lücken produziert und wie cursor-basierte Paginierung mit dem Connections-Pattern stabil bleibt – inklusive Schema, Resolver-Skizze und den Fallstricken aus der Projektpraxis.
- [SvelteKit Adapter AWS: Framework trifft Cloud](https://www.mikebild.dev/de/blog/sveltekit-adapter-aws/): Warum ich einen eigenen SvelteKit-Adapter für AWS gebaut habe und was die Übersetzung zwischen Framework-Build und Lambda, S3 und CloudFront über beide Seiten verrät.
- [Preview-Umgebungen pro Pull Request](https://www.mikebild.dev/de/blog/preview-umgebungen-pro-pull-request/): Ephemere Umgebungen pro Pull Request verkürzen das Feedback und machen Reviews konkret: Man klickt die Änderung, statt sie sich aus dem Diff vorzustellen.
- [Jamstack als Architekturstil für Webanwendungen](https://www.mikebild.dev/de/blog/jamstack-architektur/): Jamstack beschreibt einen Architekturstil mit vorgerendertem Frontend und entkoppelten Diensten. Der Beitrag ordnet die ursprünglichen Bausteine JavaScript, APIs und Markup im Stand von 2021 ein.
- [Transaktionale E-Mails serverless: SES und Lambda](https://www.mikebild.dev/de/blog/ses-email-hook-serverless/): Wie SES zum ereignisgetriebenen E-Mail-Baustein wird: ausgehende Bestätigungsmails aus einer Lambda-Function und eingehende Receipt Rules, die aus einer Mail einen Handler auslösen.
- [State-Management in React: Redux Toolkit, leichte Stores, MobX](https://www.mikebild.dev/de/blog/state-management-vergleich/): Wenn ein State wirklich app-weit ist, stellt sich die Werkzeugfrage – Redux Toolkit, ein leichter Store wie Zustand oder Jotai, oder das reaktive Modell von MobX. Warum diese Wahl aber erst nach der Gegenprobe kommt und meistens kleiner ausfällt als gedacht.
- [DynamoDB-Datenmodellierung: Single-Table-Design](https://www.mikebild.dev/de/blog/dynamodb-datenmodellierung-single-table/): DynamoDB belohnt ein anderes Denken als eine relationale Datenbank: nicht vom Datenmodell her, sondern von den Access Patterns. Single-Table-Design fasst mehrere Entity Types über zusammengesetzte Keys in einer Tabelle zusammen.
- [CDN Construct: eine kleine Infrastruktur-API](https://www.mikebild.dev/de/blog/cdn-construct-infrastruktur-api/): Warum ein eigenes CDK-Construct für statische Websites mehr ist als gesparte Zeilen: eine Schnittstelle mit Meinung über S3, CloudFront, Zertifikate und DNS.
- [Outcome vor Output: warum Velocity die falsche Zahl ist](https://www.mikebild.dev/de/blog/outcome-vor-output/): Erledigte Tickets sind Output, aber noch kein Beleg für Wirkung. Warum Velocity im Management-Reporting in die Irre führt und wie man Teams stattdessen an Outcomes ausrichtet.
- [Datenanalyse mit NumPy, Pandas und Matplotlib](https://www.mikebild.dev/de/blog/datenanalyse-mit-pandas/): Von Rohdaten zur Erkenntnis: Wie NumPy, pandas und Matplotlib zusammenspielen – vektorisiertes Rechnen, groupby-Aggregation und ein schneller Plot in einer kleinen Pipeline.
- [Wann CQRS und Event Sourcing zu viel sind](https://www.mikebild.dev/de/blog/wann-cqrs-und-event-sourcing-zu-viel-ist/): Für die meisten Systeme reicht CRUD. CQRS und Event Sourcing lohnen sich nur unter klaren Bedingungen – dieser Beitrag liefert einen ehrlichen Entscheidungsleitfaden statt Muster als Selbstzweck.
- [GraphQL-Konzepte: Schema, Resolver, Ausführung](https://www.mikebild.dev/de/blog/graphql-konzepte-schema-resolver-ausfuehrung/): Die Ideen hinter GraphQL, die bleiben, egal welcher Server gerade modern ist – das Schema als typisierter Vertrag, die Query als Form, das Resolver-Modell und die Reihenfolge der Ausführung. Eine konzeptuelle Vertiefung mit Diagrammen.
- [GraphQL-APIs mit AppSync und DynamoDB](https://www.mikebild.dev/de/blog/appsync-dynamodb-graphql-api/): AWS AppSync verschiebt den GraphQL-Server aus der eigenen Betriebsverantwortung in einen managed Dienst. Ich zeige am DynamoDB-Backend, wann diese Build-vs-Buy-Entscheidung trägt und wann managed zur Sackgasse wird, inklusive der VTL-Mapping-Templates, die 2021 der Preis dafür sind.
- [Context richtig einsetzen: Verteilweg statt heimlicher globaler State](https://www.mikebild.dev/de/blog/context-richtig-einsetzen/): Context löst das Verteilen von Daten durch den Baum – aber nicht die Frage, wem der State gehört. Wer beides verwechselt, baut einen globalen Store durch die Hintertür ein und erzeugt bei unbedacht wechselnden Provider-Werten unnötige Renderläufe.
- [Daten einlesen in Python: CSV, JSON, Excel und Datenbank](https://www.mikebild.dev/de/blog/python-daten-einlesen/): Ein Werkzeugkasten für jede Datenquelle: Wann die Standardbibliothek reicht, wann pandas lohnt, und wie man Encoding, Speicher und SQL-Injection nicht zum Verhängnis werden lässt.
- [Architecture Decision Records: Entscheidungen, die man in zwei Jahren noch versteht](https://www.mikebild.dev/de/blog/adr-entscheidungen-die-man-versteht/): Warum wir uns damals für PostgreSQL und gegen den Message-Bus entschieden haben? ADRs machen das Warum als versioniertes Markdown-Artefakt haltbar – statt es im Flurfunk versickern zu lassen.
- [GraphQL-Schema, das mitwächst: Evolution ohne Bruch](https://www.mikebild.dev/de/blog/graphql-schema-das-mitwaechst/): Wie man ein GraphQL-Schema additiv weiterentwickelt, statt es zu versionieren – sichere Änderungen, echte Breaking Changes, @deprecated als Werkzeug und eine Feld-Migration Schritt für Schritt.
- [Serverless-Workflows mit AWS Step Functions](https://www.mikebild.dev/de/blog/step-functions-serverless-workflows/): Step Functions machen aus verschachtelten Lambda-Handlern eine deklarative State Machine: sichtbarer Ablauf, explizite Retry- und Catch-Pfade, Standard oder Express.
- [Event Sourcing: der Event-Store als Logbuch](https://www.mikebild.dev/de/blog/event-sourcing-der-event-store-als-logbuch/): Event Sourcing speichert nicht den aktuellen Zustand, sondern die Folge der Events als Wahrheitsquelle: der Event-Store als Logbuch, der Zustand als Faltungsergebnis. Nutzen, ehrliche Kosten und die Abgrenzung zu CQRS.
- [Flask-Apps testen: der Test-Client und zuverlässige Endpoints](https://www.mikebild.dev/de/blog/flask-apps-testen/): Wie ich Flask-Endpoints teste: mit app.test_client() ohne laufenden Server, pytest-Fixtures und geprüften JSON-Antworten.
- [State erhalten und zurücksetzen: React und die Position im Baum](https://www.mikebild.dev/de/blog/react-zustand-erhalten-und-zuruecksetzen/): React speichert State nicht in der Komponente, sondern an ihrer Position im Render-Baum – wer das versteht, steuert Erhalt und Reset absichtlich statt zufällig.
- [Serverless-Auth mit Cognito User Pools](https://www.mikebild.dev/de/blog/cognito-userpool-auth-serverless/): Cognito User Pools als managed Identity-Backend: Sign-up, Confirm und Sign-in ohne eigenen Auth-Server, die drei Tokens richtig verstanden und ein API-Gateway-Endpoint, den ein Cognito-Authorizer absichert.
- [Trunk-Based Development statt Branch-Friedhof](https://www.mikebild.dev/de/blog/trunk-based-development-und-feature-flags/): Kurze Integrationszyklen mit Feature Flags schlagen langlebige Branches: tägliche Integration ohne Merge-Hölle und ein Release, das zur Entscheidung wird statt zum Deploy-Event.
- [Wie React den Baum rendert und aktualisiert](https://www.mikebild.dev/de/blog/wie-react-den-baum-rendert-und-aktualisiert/): Vom JSX-Element zum sichtbaren Pixel – was zwischen einer State-Änderung und dem neu gezeichneten Bildschirm genau passiert. Render und Commit als getrennte Phasen, der Abgleich zweier Bäume und warum React fast immer nur einen winzigen Teil des DOM anfasst.
- [Team-Automatisierung mit GitHub Actions](https://www.mikebild.dev/de/blog/team-automatisierung-github-actions/): Warum ich ausgewählte, wiederkehrende Prüfungen als Workflows ausführe – und woran sich zeigt, ob die Automatisierung das Team tatsächlich entlastet.
- [Web-APIs mit Flask: von der App zur JSON-API](https://www.mikebild.dev/de/blog/web-apis-mit-flask/): Von Hello World zur JSON-API: wie Routing, Request-Verarbeitung und jsonify in Flask 1.1 zusammenspielen – und warum SSR und API dieselbe Mechanik sind.
- [Read Models aus Events: Projections statt zufälliger Caches](https://www.mikebild.dev/de/blog/read-models-sind-projektionen/): Ein aus Events aufgebautes Read Model ist eine bewusst gepflegte Projection für konkrete Queries. Herkunft und Rebuild unterscheiden es von einem zufällig gewachsenen Cache, auch wenn die technische Sicht cacheähnlich wirken kann.
- [Cloud Guardrails statt Cloud Gatekeeping](https://www.mikebild.dev/de/blog/cloud-guardrails/): Warum zentrale Freigabeprozesse in der Cloud Schatten-Infrastruktur züchten und wie technisch durchgesetzte Leitplanken – SCPs, Permission Boundaries, Config Rules, Budgets – Teams Bewegungsfreiheit zurückgeben.
- [CDK Constructs: Abstraktion mit Haftung](https://www.mikebild.dev/de/blog/cdk-constructs-abstraktion-mit-haftung/): Wer ein CDK Construct veröffentlicht, verschickt keine Hilfsfunktion, sondern Betriebsentscheidungen – über Defaults, Upgrade-Pfade und das, was beim Konsumenten im CloudFormation-Template landet.
- [Bounded Contexts vor dem Serviceschnitt](https://www.mikebild.dev/de/blog/bounded-contexts-grenze-vor-microservice/): Bevor ich Services schneide, kläre ich fachliche Grenzen. Ein Bounded Context ist eine Sprachgrenze und ein möglicher, aber nicht zwingender Serviceschnitt.
- [Funktionale Muster in Python: Comprehensions, itertools und functools](https://www.mikebild.dev/de/blog/funktionale-muster-in-python/): Comprehensions, functools und itertools im Zusammenspiel: Wie ich in Projekten zeige, wann eine Comprehension die bessere Wahl ist als map/filter, wo lru_cache und groupby glänzen und welche Fallstricke lauern.
- [JSX genau: Die Regeln hinter dem Markup](https://www.mikebild.dev/de/blog/jsx-genau-die-regeln-hinter-dem-markup/): Ein präziser Blick auf JSX – was der Compiler daraus macht, warum in geschweiften Klammern Ausdrücke statt Anweisungen stehen, wie Attribute, Kinder, Bedingungen und Listen funktionieren und an welchen Stellen Anfänger stolpern.
- [AWS Deployment Pipelines sind Architektur](https://www.mikebild.dev/de/blog/aws-deployment-pipelines-architektur/): Deployment Pipelines sind Architektur, weil sie bestimmen, wie häufig, sicher und reversibel ein System verändert wird.
- [Fortgeschrittenes Python: Decorators, Magic Methods und Generatoren](https://www.mikebild.dev/de/blog/python-advanced-decorators-generatoren/): Drei Bausteine, die pythonischen Code ausmachen: Decorators umschließen Funktionen, Magic Methods binden eigene Objekte an Pythons Protokolle, Generatoren erzeugen lazy Sequenzen.
- [Policy as Code für CDK](https://www.mikebild.dev/de/blog/policy-as-code-fuer-cdk/): Policy as Code macht einen prüfbaren Teil der Architekturregeln ausführbar und versionierbar.
- [Das Aggregat als Konsistenzgrenze](https://www.mikebild.dev/de/blog/aggregat-als-konsistenzgrenze/): Ein Aggregat ist keine ORM-Entity und keine Tabelle, sondern eine Konsistenz- und Transaktionsgrenze: ein Verbund von Objekten, den eine Aggregate Root als Einheit schützt. Warum eine Transaktion genau ein Aggregat ändert und andere Aggregate nur per ID referenziert werden.
- [`ssmenv-cli`: kleine CLIs für große Ordnung](https://www.mikebild.dev/de/blog/ssmenv-cli-kleine-clis/): Eine kleine CLI über AWS SSM zeigt, wie Konfiguration aus einer benannten, zugriffskontrollierten Quelle in lokale Prozesse und CI gelangt – einschließlich Versions- und Ausfallfragen.
- [GitHub Actions mit AWS CDK](https://www.mikebild.dev/de/blog/github-actions-mit-aws-cdk/): GitHub Actions und AWS CDK verbinden Codeänderung, Infrastruktur und Deployment zu einer reviewbaren Pipeline – und machen die Architekturentscheidung im Pull Request sichtbar.
- [PouchDB und Offline-First](https://www.mikebild.dev/de/blog/pouchdb-offline-first/): Wer offline Schreibzugriffe erlaubt, wechselt von Request/Response zur Replikation – und der Revisionsbaum von PouchDB und CouchDB macht Konflikte zur Aufgabe des Fachmodells.
- [Commands, Events und Queries sauber trennen](https://www.mikebild.dev/de/blog/commands-events-queries-trennen/): Command, Event und Query sind drei Nachrichtenarten mit klarer Semantik: ein Wunsch, der abgelehnt werden kann, eine geschehene Tatsache und eine seiteneffektfreie Query. Wer sie sauber benennt und trennt, gewinnt Klarheit im Modell – ganz ohne großes CQRS-Setup.
- [Infrastructure as Code braucht Code-Reviews](https://www.mikebild.dev/de/blog/infrastructure-as-code-code-reviews/): Sobald Infrastruktur Code ist, entscheidet ein kleiner Diff über Sicherheit, Kosten und Ausfallrisiko – deshalb gehört sie in denselben Review-Prozess wie Anwendungscode.
- [Secrets im Build sind Produktentscheidungen](https://www.mikebild.dev/de/blog/secrets-im-build/): Secrets im Build sind ein Vertrauensproblem: Wer darf was wann sehen, speichern und deployen?
- [Product Discovery vor der ersten Zeile Code](https://www.mikebild.dev/de/blog/product-discovery-vor-der-ersten-zeile/): Discovery senkt das Risiko, effizient das Falsche zu bauen. Ich zeige eine kontinuierliche Spur, die Annahmen prüft, bevor sie teure Delivery bindet – nicht eine Phase vor der Entwicklung.
- [CQRS ist eine fachliche Grenze, kein Framework](https://www.mikebild.dev/de/blog/cqrs-fachliche-grenze-kein-framework/): CQRS trennt das Modell zum Schreiben vom Modell zum Lesen – eine fachliche Entscheidung, kein installierbares Framework. Wann sich die Grenze lohnt, wie man klein anfängt und welche Verwechslungen teuer werden.
- [Node.js-Training: Vom Event Loop zur Architekturentscheidung](https://www.mikebild.dev/de/blog/nodejs-training-event-loop-architektur/): Node.js lässt sich nicht am Framework erklären, sondern am Event Loop, an Streams und an der Frage, welche Architekturentscheidung ein Team morgen noch versteht – genau das übe ich mit Teilnehmenden im Repo introduction-nodejs.
- [CDK-Anfänge: Infrastruktur mit einer Programmiersprache](https://www.mikebild.dev/de/blog/cdk-infrastruktur-als-programmiersprache/): Mit dem CDK rückt Infrastruktur in dieselbe Werkzeugkette wie Anwendungscode, wodurch Tests, Reviews und logische Identitäten plötzlich über den Bestand von Produktionsdaten entscheiden.
- [AWS Parameter Store im Build](https://www.mikebild.dev/de/blog/aws-parameter-store-im-build/): Parameter Store im Build macht Konfiguration explizit, wirft aber harte Fragen zu Secrets und Reproduzierbarkeit auf.
- [Eine eigene Docker Registry betreiben](https://www.mikebild.dev/de/blog/docker-eigene-registry/): Wie ich in Projekten eine private Docker Registry mit registry:2 aufsetze: Images taggen, pushen und pullen, und danach mit htpasswd und TLS absichern.
- [Kubernetes-Grundlagen durch Deployment-Druck](https://www.mikebild.dev/de/blog/kubernetes-grundlagen-deployment-druck/): Unter dem Druck eines echten Deployments sortieren sich die Kubernetes-Konzepte von selbst nach Wichtigkeit – vom Pod über Deployment und Service bis zum Ingress.
- [Zentrales Logging mit dem ELK-Stack in Docker](https://www.mikebild.dev/de/blog/docker-logging-mit-elk/): Container-Logs verstreuen sich über viele Container und sind flüchtig. Dieser Artikel zeigt, wie ein ELK-Stack aus Elasticsearch, Logstash und Kibana im Compose-Setup Logs zentralisiert, indiziert und durchsuchbar macht.
- [Micro-Frontends: Teamschnitt im Browser](https://www.mikebild.dev/de/blog/micro-frontends-teamschnitt-browser/): Warum die eigentliche Arbeit bei Micro-Frontends nicht in der Integrationstechnik steckt, sondern im Teamschnitt – gezeigt an einer lauffähigen Beispiel-Landschaft aus Gateway, vier Anwendungen und einer Komponenten-Bibliothek.
- [Frontend-Schnittstellen sind APIs](https://www.mikebild.dev/de/blog/frontend-schnittstellen-sind-apis/): Warum Props, URLs, Events, CSS-Klassen und localStorage dieselbe Versionierungs-Disziplin verdienen wie ein REST-Endpoint – spätestens, wenn mehrere Teams im selben Browser arbeiten.
- [Node.js und Redis mit Docker Compose](https://www.mikebild.dev/de/blog/docker-compose-nodejs-redis/): Wie ich in Projekten eine Zwei-Container-App aus Node.js und Redis mit Docker Compose beschreibe: eine YAML für den ganzen Stack, Service Discovery über den Servicenamen, Persistenz per Volume – und warum depends_on nicht auf Betriebsbereitschaft wartet.
- [Containerisierung und die falsche Sicherheit](https://www.mikebild.dev/de/blog/containerisierung-falsche-sicherheit/): Warum „läuft im Container“ weder Isolation noch Reproduzierbarkeit noch geregelten Betrieb bedeutet – und welche Handgriffe die drei Lücken tatsächlich schließen.
- [Meine Arbeitsdefinition für ein MVP: lernen statt halb fertig liefern](https://www.mikebild.dev/de/blog/mvp-kleinstes-lernendes-produkt/): Ich benutze MVP für ein Experiment, das eine riskante Annahme ehrlich testet. Diese Arbeitsdefinition verhindert, dass ein bloß reduziertes Feature-Set schon als Lernen gilt.
- [GraphQL-Schema in der Fachsprache](https://www.mikebild.dev/de/blog/graphql-schema-in-der-fachsprache/): Ein GraphQL-Schema ist der beste Ort, den es je für die ubiquitäre Fachsprache gab – und wenn die Domäne deutsch ist, darf sie dort auch deutsch bleiben.
- [Angular, React und der Wert von Übergängen](https://www.mikebild.dev/de/blog/angular-react-uebergaenge/): Ob ein Framework-Wechsel zum Umzug oder zum Neubau wird, entscheidet sich daran, wie billig zwei Welten monatelang nebeneinander laufen können.
- [Prototypen: das Objektmodell hinter JavaScript-Klassen](https://www.mikebild.dev/de/blog/javascript-prototypen-modell-hinter-class/): class in ES2015 ist im Kern Syntax-Zucker über Prototypen: Wer die [[Prototype]]-Kette, Object.create und den new-Ablauf versteht, debuggt this-Fehler und geteilte Methoden souveräner.
- [Redux als Protokoll für UI-Änderungen](https://www.mikebild.dev/de/blog/redux-als-protokoll/): Der Store ist der langweiligste Teil von Redux – wertvoll ist das Nachrichtenprotokoll aus benannten, serialisierbaren Actions, das UI-Änderungen nachvollziehbar, testbar und diskutierbar macht.
- [JavaScript-Patterns, die geblieben sind: Module, Higher-Order Functions, Currying](https://www.mikebild.dev/de/blog/javascript-patterns-module-hof-currying/): Drei JavaScript-Pattern haben jeden Framework-Wechsel überlebt: das Module-Pattern für saubere Kapselung, Higher-Order Functions für Funktionen als Werte und Currying für spezialisierte Varianten. Warum sie das Fundament moderner Utility-Libraries bilden.
- [WebSockets sind nicht immer die Antwort](https://www.mikebild.dev/de/blog/websockets-nicht-immer-antwort/): Warum Server-Sent Events für die meisten Echtzeit-Anforderungen die einfachere Wahl sind und wann sich der Preis einer echten WebSocket-Verbindung tatsächlich lohnt.
- [KnockoutJS: fein-granulare Reaktivität mit Observables und Computed](https://www.mikebild.dev/de/blog/knockoutjs-observables-computed-vor-signals/): Wie KnockoutJS Reaktivität löst: Observables als get/set-Funktionen, Computed mit automatischem Dependency-Tracking und gezielte DOM-Updates statt globalem Baum-Vergleich.
- [PWA Weather: offline ist ein Feature](https://www.mikebild.dev/de/blog/pwa-weather-offline-feature/): Eine kleine Wetter-App als Progressive Web App zeigt, warum Offline-Verhalten eine Produktentscheidung ist und wie ehrlich eine Oberfläche mit veralteten Daten umgehen sollte.
- [Tic-Tac-Toe mit Minimax in React](https://www.mikebild.dev/de/blog/tic-tac-toe-minimax-react/): Ein unschlagbarer Tic-Tac-Toe-Gegner in React zeigt, warum Spiellogik als Pure Function nichts vom Rendering wissen darf – und warum immutable Züge zu Reacts Modell passen.
- [Einfacher Entwurf kann Prozess sparen](https://www.mikebild.dev/de/blog/einfach-schlagen-elegant-statt-prozess/): In vielen Projekten kompensiert Prozess-Overhead einen zu großen oder spekulativen Entwurf. Kleiner zu schneiden kann Koordination sparen; externe Vorgaben und echte Abhängigkeiten bleiben.
- [HTML5, CSS3 und ECMAScript als Baseline](https://www.mikebild.dev/de/blog/html5-css3-ecmascript-baseline/): Im Frühjahr 2017 tragen CSS Grid, Flexbox, fetch und natives ES2015 so weit, dass die erste Architekturfrage im Frontend neu gestellt gehört: Wie weit komme ich ohne Framework?
- [RxJS: Push und Pull endlich auseinanderhalten](https://www.mikebild.dev/de/blog/rxjs-push-und-pull/): Wer Producer und Consumer benennt, erkennt sofort, ob Daten gezogen oder geschoben werden, und wählt zwischen Funktion, Iterator, Promise und Observable ohne Raten.
- [Node.js: Async I/O erklärt Architektur](https://www.mikebild.dev/de/blog/nodejs-async-io-architektur/): Die Rechnung „ein Thread mal 200 Verbindungen“ zeigt, welche Systeme zu Node.js passen und welche Arbeit besser in eigene Prozesse gehört.
- [Babel Node Express: moderne Syntax, altes HTTP](https://www.mikebild.dev/de/blog/babel-node-express-http/): Babel übersetzt Syntax, kein Ausführungsmodell – wer das trennt, weiß, warum babel-node in die Entwicklungsschleife gehört und nicht in den Betrieb.
- [API-Denken vor Framework-Denken](https://www.mikebild.dev/de/blog/api-denken-vor-framework-denken/): Wer Operationen, Daten und Fehlerfälle vor der Framework-Wahl festlegt, kann das Frontend später fast beliebig tauschen – umgekehrt bekommt man eine API, die ein Framework nachbildet.
- [Tyrian Rx React: UI als Datenfluss](https://www.mikebild.dev/de/blog/tyrian-rx-react-ui-datenfluss/): Ein Nachbau der Elm-Architektur mit RxJS und React – Actions als Strom, scan() faltet das Model, Side Effects bleiben am Rand – und was dieser Proof of Concept über gut alternde UI-Architektur verrät.
- [GraphQL-Pouch: lokale Daten mit Schema](https://www.mikebild.dev/de/blog/graphql-pouch-lokale-daten/): Ein Open-Source-Experiment aus dem Sommer 2016: eine GraphQL-Runtime, die aus einer Schema-Kurznotation eine komplette CRUD-API über PouchDB erzeugt – inklusive Synchronisation über das CouchDB-Replikationsprotokoll.
- [Definition of Done als Qualitäts-Gate, nicht als Bürokratie](https://www.mikebild.dev/de/blog/definition-of-done-als-qualitaets-gate/): Der automatisierbare Kern einer Definition of Done gehört in ein grünes Gate aus Lint, Build und Test. Fachliche Abnahme und andere Urteile bleiben gemeinsame Qualitätsarbeit.
- [React: Komponenten als Schnittstellen](https://www.mikebild.dev/de/blog/react-komponenten-als-schnittstellen/): Warum Props der öffentliche Vertrag einer React-Komponente sind – und was sich ändert, wenn man sie wie eine API entwirft statt wie eine Parameterliste.
- [GraphQL als Frage an das System](https://www.mikebild.dev/de/blog/graphql-als-frage-an-das-system/): Ein halbes Jahr nach der Spezifikation sortiert dieser Beitrag, was an GraphQL wirklich neu ist – und welche Fragen Anfang 2016 noch niemand beantwortet hat.
- [Build-Skripte als Produktcode](https://www.mikebild.dev/de/blog/build-skripte-als-produktcode/): Build-Skripte verdienen die Sorgfalt von Produktcode, weil sie bestimmen, wie reproduzierbar ein System tatsächlich ist.
- [ES6 Memory: UI-State begreifen](https://www.mikebild.dev/de/blog/es6-memory-ui-state/): Ein Memory-Spiel in frischem ES2015, ohne Framework gebaut, macht sichtbar, welche States eine UI wirklich hat, wo sie liegen sollten und wer sie ändern darf.
- [Web Messaging mit RxJS](https://www.mikebild.dev/de/blog/web-messaging-mit-rxjs/): Wer eingehende Messages hinter einem Observable versteckt, macht den Transport zwischen Browser und Server austauschbar – und merkt dabei, wie weit gewöhnliches HTTP trägt.
- [Funktionale Stile im Alltag](https://www.mikebild.dev/de/blog/funktionale-stile-im-alltag/): Warum funktionaler Stil im Team-Alltag 2015 nicht Haskell bedeutet, sondern die Disziplin, Pure Functions von I/O zu trennen – und wie ES2015 das endlich bequem macht.
- [Container sind keine Architektur](https://www.mikebild.dev/de/blog/container-sind-keine-architektur/): Docker macht Systemgrenzen sichtbar und transportabel – gezogen werden müssen sie weiterhin von Hand, und ein Monolith bleibt auch im Container ein Monolith.
- [Programming Styles als Architekturvergleich](https://www.mikebild.dev/de/blog/programming-styles-architekturvergleich/): Dieselbe kleine Aufgabe in Dutzenden Programmierstilen gelöst ist der kompakteste Architekturvergleich, den ich kenne – weil jeder Stil eine bewusst gewählte Constraint-Menge ist.
- [Docker für .NET, bevor es normal war](https://www.mikebild.dev/de/blog/docker-fuer-dotnet/): Eine kleine Nancy-API unter Mono in einen Docker-Container zu packen war im Frühjahr 2015 ein Umweg über Linux – und hat mir mehr über .NET-Deployment beigebracht als jedes IIS-Handbuch.
- [Tests, bevor es ein Produkt gibt](https://www.mikebild.dev/de/blog/tests-bevor-produkt/): Frühe Tests helfen, ein Problem zu begreifen, auch wenn der Code später komplett ersetzt wird.
- [Flood-It: ein Spiel als Architektur-Lupe](https://www.mikebild.dev/de/blog/flood-it-architektur-lupe/): Ein Brett aus Zahlen, ein Zug als Pure Function und ein Greedy-Löser zeigen im Kleinen, was in großen Systemen verschwimmt: die Trennung von Kernlogik, Strategie und Darstellung.
- [MathParser: Parser als Denkwerkzeug](https://www.mikebild.dev/de/blog/mathparser-parser-als-denkwerkzeug/): Ein Rückblick auf ein eigenes Parser-Demo von 2010 zeigt, warum ein handgeschriebener Ausdrucks-Parser auf wenigen Zeilen mehr über Schichten, Struktur und die Grenze zwischen Syntax und Semantik lehrt als manches große Projekt.
- [State Mutation auf Streams](https://www.mikebild.dev/de/blog/state-mutation-auf-streams/): Wer State als Faltung über einen Strom von Events berechnet statt ihn direkt zu ändern, bekommt Undo, Replay und Nachvollziehbarkeit fast geschenkt.
- [HTTP-APIs: klein, stabil, lesbar](https://www.mikebild.dev/de/blog/http-apis-klein-stabil-lesbar/): Was der Heroku HTTP API Design Guide taugt, wenn man ihn an eigenen APIs spiegelt – und warum wenige Ressourcen, ein Versionsversprechen und selbsterklärende Fehler mehr bewirken als jedes Framework.
- [Was ich an Elixir gesucht habe](https://www.mikebild.dev/de/blog/was-ich-an-elixir-gesucht-habe/): Nicht die Syntax hat mich zu Elixir gebracht, sondern das Ausführungsmodell der Erlang-VM – Prozesse, Messages und Supervisors, betrachtet mit JavaScript- und C#-Augen.
- [Control Flow vor `async/await`](https://www.mikebild.dev/de/blog/control-flow-vor-async-await/): Ein Blick auf die winzige Bibliothek cflow zeigt, wie Node-Entwickler asynchrone Schritte von Hand zu einer Kette verdrahteten und warum der fehlende Fehlerkanal die eigentliche Lektion ist.
- [Warum Katas mehr sind als Fingerübungen](https://www.mikebild.dev/de/blog/warum-katas-mehr-sind/): Eine Kata ist ein Architektur-Labor im Kleinen – weil die Aufgabe konstant bleibt, wird sichtbar, was sonst nur der Entwurf weiß.
---
# Zwischenfazit und Systemblick: eine Bilanz der Serie
URL: https://www.mikebild.dev/de/blog/von-der-session-zum-system-zwischenfazit/
Datum: 2026-08-17
Das Gespräch, mit dem [diese Serie begann](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/), liegt im Oktober des vergangenen Jahres; dieser Text zieht mit Stand August 2026 Bilanz. Der Auftakt endete mit einem Vorsatz: der eigenen Begeisterung erst einmal misstrauen, genau hinschauen und jedes Ergebnis an über dreißig Jahren Handwerk messen. Die [letzte Folge](https://www.mikebild.dev/de/blog/hilfsmittel-konzepte-methoden-prozesse/) hat angekündigt, diesen Vorsatz beim Wort zu nehmen. Also: Was von den Erwartungen ist eingetreten, was nicht, was bleibt offen – und welcher Systemblick ist aus den einzelnen Sitzungen des Anfangs inzwischen geworden?
*Teil 13 der Serie „Von der Session zum System“ – hier geht es [zum Auftakt](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/).*
## Die Begeisterung hat die Prüfung überstanden – knapp
Das Wichtigste zuerst, weil alles andere darauf aufbaut: Aus den paar Tagen Probe im Oktober ist Alltag geworden, und zwar der unspektakulärste Beleg, den ich anbieten kann. Ich denke über diese Werkzeuge nicht mehr nach, so wenig wie über den Editor oder die Versionsverwaltung. Sie sind Infrastruktur. Ein Strohfeuer sieht anders aus – Strohfeuer erkennt man daran, dass man nach drei Monaten wieder davon erzählt statt damit zu arbeiten.
Trotzdem wäre es zu billig, die eigene Wahrnehmung einfach zur Bilanz zu erklären. Im Juli 2025 hat das amerikanische Forschungsinstitut METR – eine gemeinnützige Organisation, die die Fähigkeiten von KI-Systemen mit kontrollierten Experimenten vermisst – eine Studie veröffentlicht, die mich mehr beschäftigt hat als jede Benchmark: Erfahrene Open-Source-Entwickler waren mit KI-Unterstützung in randomisierten Aufgaben messbar langsamer – um rund ein Fünftel – und schätzten hinterher trotzdem, deutlich schneller gewesen zu sein. Genau die Wahrnehmung, auf die ich mich seit dem Auftakt verlassen habe, kann also systematisch täuschen. Das nehme ich ernst, denn es ist dieselbe Warnung, die ich mir im Auftakt selbst gegeben habe: Frische Begeisterung ist ein schlechter Zeuge.
Deshalb prüfe ich an Dingen, die sich nicht schönreden lassen. Was ist abends tatsächlich fertig? Welche der liegen gebliebenen Vorhaben sind heute in Betrieb? Wie oft habe ich in Reviews Fehler gefunden, die ohne die Verschiebung zum Prüfen durchgerutscht wären? Nach diesem Maßstab fällt die Bilanz positiv aus – als Beobachtung, nicht als Messung; belastbare Zahlen dazu fehlen mir. Genau deshalb bleibt die Studie für meine Bewertung wichtig: Solange ich nicht mit vergleichbarer Strenge messe, muss ich einrechnen, dass auch meine Wahrnehmung täuscht. Sie misst allerdings Aufgaben, die den Entwicklern vertraut waren, in Code, den sie gut kannten. Mein größter Gewinn liegt woanders – bei den Vorhaben, die ohne diese Werkzeuge gar nicht erst angefangen worden wären. Das ist keine Widerlegung der Studie, es ist eine andere Rechnung. Beide können gleichzeitig stimmen.
## Was eingetreten ist
Der Auftakt hielt drei Beobachtungen fest. Alle drei haben die Monate seit dem Auftakt überlebt, aber keine ist geblieben, wie sie war.
Die erste – Erzeugen wird billig, Prüfen wird der Engpass – hat sich als die tragende Beobachtung der ganzen Serie erwiesen. Rückblickend ist fast jede Folge eine Antwort auf diese eine Verschiebung: der Harness organisiert das Prüfen um das Modell herum, die [Hausregeln](https://www.mikebild.dev/de/blog/was-ich-kritisch-sehe/) verteidigen es gegen die eigene Bequemlichkeit, [Grounding](https://www.mikebild.dev/de/blog/sauberes-grounding-antworten-erden/) verankert es in echten Quellen, und [Regeln im Pfad](https://www.mikebild.dev/de/blog/eigener-agent-pro-fachdomaene/) machen es unabhängig von der Tagesform des Prüfenden. Was ich im November noch nicht sah: Der Engpass wandert weiter. Erst war das Prüfen knapp, dann das saubere Aufschreiben dessen, was gelten soll – inzwischen ist es das Entscheiden, was überhaupt gebaut wird.
Die zweite Beobachtung – die Schubladen gehen wieder auf – ist eingetreten, mit einer Einschränkung, die ich damals nicht kommen sah. Einiges von dem, was jahrelang liegen geblieben war, ist heute in Betrieb: kleiner als die ursprüngliche Idee, und das ist keine Niederlage, sondern ein Befund. Denn was die Werkzeuge nicht liefern, ist ein Urteil darüber, welche der alten Ideen es wert waren. Zwei Vorhaben habe ich nach wenigen Wochen wieder eingestellt – schneller gescheitert, als es früher möglich gewesen wäre, und genau das ist der unterschätzte Gewinn: Billige Umsetzung macht auch das Verwerfen billig.
Die dritte Beobachtung – der Ton stimmt immer, auch wenn der Inhalt nicht stimmt – war im November ein Bauchgefühl. Daraus ist [eine strukturelle Erklärung](https://www.mikebild.dev/de/blog/sauberes-grounding-warum-ki-raet/) geworden und dann ein Verfahren. Das Misstrauen ist geblieben, aber es ist umgezogen: von meiner privaten Wachsamkeit in Prüfschritte, die nicht davon abhängen, ob ich einen guten Tag habe. Das ist vielleicht die kompakteste Zusammenfassung dessen, was diese Monate mit meiner Arbeitsweise gemacht haben – Sorgfalt wurde von einer Tugend zu einer Eigenschaft des Aufbaus.
## Was ich falsch erwartet hatte
Eine Bilanz, die nur Treffer aufzählt, ist Werbung. Zwei Erwartungen haben sich nicht gehalten.
Die teuerste Fehleinschätzung: dass Aufschreiben reicht. Monatelang steckte ich Arbeit in immer bessere Instruktionsdateien, ehe ich die Chronik dieser Versuche ehrlich gezogen habe – aufgeschriebene Regeln bleiben Empfehlungen, egal wie gut sie formuliert sind. Aus dieser Ernüchterung ist die wichtigste Erkenntnis der Serie geworden: Regeln, die gelten sollen, brauchen einen Pfad, der sie durchsetzt – Prüfung vor Wirkung, Freigaben, Nachweise. Wenn ich einen einzigen Satz aus diesen Monaten mitnehmen dürfte, wäre es dieser.
Die zweite Fehleinschätzung ist angenehmer: Erwartet hatte ich, dass die Modellwahl mit der Zeit wichtiger wird – dass sich irgendwann ein Modell absetzt und die Frage „welches?“ doch noch zur Strategiefrage wird. Das Gegenteil ist passiert. Bei meinen Aufgaben wirkten mehrere Modellwechsel seit dem Auftakt wie Qualitätsverbesserungen, und mit jedem Sprung wurde die Wahl [unwichtiger, nicht wichtiger](https://www.mikebild.dev/de/blog/gut-genug-modelle/). Die Arbeitsweise hat die Wechsel kaum bemerkt. Was sich dagegen jedes Mal bemerkbar macht: eine schlecht geschnittene Aufgabe, ein fehlendes Stück Kontext, eine Regel, die nur in Prosa existiert. Der eigene Anteil dominiert das Ergebnis – das war als These früh da, und inzwischen entscheidet sich daran konkret, ob ein Lauf trägt: am Schnitt der Aufgabe, am mitgegebenen Kontext und an den Regeln, die im Pfad durchgesetzt werden.
## Was offen bleibt
Drei Fragen bleiben in diesem Zwischenfazit unbeantwortet.
Die Junior-Frage. Im Auftakt stand ein Verdacht: Der Hebel wirkt, weil drei Jahrzehnte Urteilsfähigkeit dahinterstehen – und ob er für jemanden ohne dieses Fundament genauso wirkt, wisse ich nicht. Auch heute weiß ich es nicht, und die [kritische Folge](https://www.mikebild.dev/de/blog/was-ich-kritisch-sehe/) hat den Verdacht eher geschärft als entkräftet: Wer funktionierenden Code bekommt, bevor der Schmerz einsetzt, aus dem Verständnis entsteht, baut womöglich nie die Substanz auf, von der das Prüfen zehrt. Verdacht ist weiterhin kein Wissen. Aber er ist die Frage, die ich für wichtiger halte als jede Modellfrage.
Die Homogenisierung. Dass Teams, die dasselbe Modell fragen, ähnlichere Lösungen bauen, habe ich seit der einen Beobachtung vom Februar mehrfach wiedererkannt, aber nie gemessen. Es bleibt eine Sorge ohne Beleg, und ich lasse sie bewusst so stehen, statt sie zur These aufzublasen.
Das Verlernen des eigenen Handwerks. Die Hausregeln aus dem Februar halten ungefähr so gut wie Neujahrsvorsätze: besser als nichts, schlechter als behauptet. Der bewusste Lauf ohne KI findet statt, aber seltener, als ich ihn eingeplant hatte. Der Sog der bequemen Variante ist real, jeden Tag. Genau diese Erfahrung hat mich für die zweite Serienhälfte skeptisch gegenüber allem gemacht, was auf Disziplin baut – und empfänglich für alles, was Sorgfalt in den Aufbau verlegt.
## Der Bogen, im Rückblick
Der Dreiklang Ich, Wir, System stand als Absicht schon im Auftakt. Was ich nicht geplant hatte, ist die Mechanik, die sich beim Schreiben zeigte: Jede Ebene erbt das ungelöste Problem der vorherigen. Die Disziplin des Einzelnen [skaliert nicht aufs Team](https://www.mikebild.dev/de/blog/mein-erfolg-laesst-sich-nicht-kopieren/), also schreibt das Team seine Regeln auf; aufgeschriebene Regeln binden niemanden, also braucht es Wissen mit Besitzern und [einen Ort, der die Session überlebt](https://www.mikebild.dev/de/blog/wissen-das-die-session-ueberlebt/); kuratiertes Wissen beantwortet noch keine Verbindlichkeitsfrage, also wandern die harten Regeln [in den Pfad eines eigenen Agenten](https://www.mikebild.dev/de/blog/eigener-agent-pro-fachdomaene/); und damit das kein Reißbrett-Entwurf bleibt, braucht es [Konzepte, Methoden und Prozesse](https://www.mikebild.dev/de/blog/hilfsmittel-konzepte-methoden-prozesse/), die den Anfang klein halten.
```mermaid
flowchart LR
subgraph AKT1["Akt 1 · Ich"]
S["Session Erzeugen wird billig"] --> P["Arbeitsweise Prüfen wird der Engpass"]
end
subgraph AKT2["Akt 2 · Wir"]
P --> V["Team-Varianz Disziplin skaliert nicht"] --> D["Instruktionsdateien Empfehlung statt Regel"]
end
subgraph AKT3["Akt 3 · System"]
D --> W["Kuratiertes Wissen mit Besitzern"] --> R["Regeln im Pfad Agent pro Fachdomäne"] --> B["Systemarchitektur Oberfläche, Verträge, Freigaben"]
end
```
Der Satz, der diesen Bogen zusammenhält, fiel in der Folge über kuratiertes Wissen: Nicht das Modell wird schlauer – die Organisation kuratiert ihr Wissen.
## Der heutige Systemblick
Im Mittelpunkt steht die Eigenschaft, um die es dieser Serie von Anfang an ging: die Trennung von Vorschlag und Wirkung, gebaut als eigene Freigabegrenze, nicht als pauschaler Schalter. Eine Workflow-Engine kann externe Writes bis zur Bestätigung zurückhalten. Ein Publishing-System kann die Promotion einer Vorschau an einen Menschen binden. Ein Wissenssystem kann Änderungen bis zur menschlichen Entscheidung als Vorschlag stehen lassen. Eine Auftragssteuerung kann Ausführung an freigegebene Aufträge binden. Dasselbe Prinzip, jeweils anders geschnitten – weil die Frage, was „wirken“ bedeutet, in jeder Fachdomäne anders beantwortet werden muss. Ein veröffentlichter Inhalt wirkt anders als eine freigegebene Wissensrevision, und beide anders als ein Workflow, der in ein Fremdsystem schreibt.
Damit hat sich auch die Frage verschoben, die der Auftakt stellte. Sie lautete: Was können die Modelle? Sie lautet jetzt: Was macht eine Organisation daraus? Der Zugang zu einer externen Modell-API ist nicht der Teil dieser Architektur, den die Organisation dauerhaft selbst kontrolliert. Eine Oberfläche, hinter der eine sauber geschnittene Fachdomäne steht, maschinelle Verträge, auf die sich andere Systeme verlassen können, und Freigabepfade, die verhindern, dass ein Vorschlag ohne die vorgesehene menschliche Entscheidung wirkt: Das muss eine Organisation selbst aufbauen, und genau darin liegt der Anteil, der ihr unabhängig vom einzelnen Modell bleibt.
## Position statt Prognose
Über Modellfähigkeiten in einem Jahr, über Produktivitätskurven ganzer Branchen oder über Arbeitsmärkte habe ich keine Urteilsgrundlage, und diese Monate haben mir vor allem beigebracht, wie schnell solche Aussagen altern. Ich formuliere deshalb keine Vision und markiere ausdrücklich, was dieses Zwischenfazit ist: mein begrenzter Erfahrungsstand, keine Prognose über unvermeidliche Markt- oder Organisationsentwicklungen.
Was ich vertreten kann, weil es sich in diesen Monaten wiederholt bestätigt hat: Der dauerhafte Wert liegt weniger im einzelnen Modell als in eigenem Wissen, durchsetzbaren Regeln, klaren Fachdomänen und überprüfbaren Abläufen. Das ist keine Zukunftsaussage, sondern eine Beschreibung dessen, was nach jedem Modellwechsel übrig blieb – und dessen, was jedes Mal fehlte, wenn ein Ergebnis nicht trug.
Und für meinen eigenen Tisch bleibt eine Erwartung, an der man mich messen kann: der erste Fachdomänen-Agent, der lange genug im Betrieb ist, dass seine Ablehnungen Geschichten erzählen – richtige Neins, zu enge Neins, Sonderfälle, die ein eigenes Verb verdienen. Erst dann zeigt sich, ob der Kreislauf aus der letzten Folge trägt oder nur gut klingt.
## Zwischenfazit, kein Schlusswort
Diese Serie pausiert hier, und zwar aus einem einfachen Grund: Der Vorrat an Beobachtungen ist aufgebraucht. Was jetzt käme, wäre Extrapolation, und davon gibt es genug. Was diesem Zwischenfazit fehlt, ist Betriebszeit. Wenn wieder genug Neues beisammen ist, wenn die Neins des ersten Fachdomänen-Agenten etwas erzählen, schreibe ich weiter. Bis dahin gilt der Vorsatz vom Auftakt unverändert: der eigenen Begeisterung misstrauen, an echten Aufgaben messen, jedes Ergebnis am eigenen Handwerk prüfen. Das Hinschauen lohnt sich, und es hört nicht auf.
## Weiterführende Quellen
- [Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity (METR, Juli 2025)](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/) – die Studie, die gemessene Verlangsamung und gefühlte Beschleunigung nebeneinanderlegt
- [The Anthropic Economic Index](https://www.anthropic.com/economic-index) – laufende Datenerhebung dazu, wofür KI in der Wirtschaft tatsächlich eingesetzt wird
- [Things we learned about LLMs in 2024 (Simon Willison)](https://simonwillison.net/2024/Dec/31/llms-in-2024/) – nüchterner Jahresrückblick als Gegenmittel zu Prognosen-Prosa
---
# MCP, HTTP, Webhooks und A2A einfach erklärt
URL: https://www.mikebild.dev/de/blog/mcp-http-webhooks-a2a-einfach-erklaert/
Datum: 2026-08-17
Vier Verbindungen können technisch über HTTP laufen und trotzdem vier grundverschiedene Aufgaben erfüllen. Eine Agentenanwendung entdeckt ein Werkzeug. Ein festes Programm ruft einen dokumentierten Endpoint auf. Ein Dienst meldet ein bereits eingetretenes Event. Ein eigenständiger Agent übernimmt einen Auftrag mit eigener Laufzeit.
MCP, HTTP mit OpenAPI, Webhooks und A2A beschreiben diese Grenzen. Keines der Verfahren ersetzt die fachliche Entscheidung darüber, wer lesen, schreiben, freigeben oder veröffentlichen darf. Ein Produkt kann mehrere dieser Maschinenoberflächen anbieten und zusätzlich eine eigene Weboberfläche für Menschen besitzen. Es bleibt trotzdem eine Fachdomäne mit einem maßgeblichen Produktzustand und denselben fachlichen Regeln.
## Vier Fragen statt einer Rangliste
Eine Schnittstelle ist eine vereinbarte Grenze zwischen Systemen. Sie legt Eingaben, Ergebnisse und Fehler fest. Der Übertragungsweg beantwortet jedoch noch nicht, welche Verantwortung an dieser Grenze übergeben wird.
| Technik | Leitfrage | Typische Aufgabe |
| --- | --- | --- |
| MCP | Welche Fähigkeiten kann eine Agentenanwendung entdecken und verwenden? | Werkzeuge und Kontext für eine offene Aufgabe bereitstellen |
| HTTP mit OpenAPI | Welchen bekannten Maschinenbefehl kann ein Client ausführen? | Einen stabilen Dienstvertrag aufrufen und prüfen |
| Webhook | Welches eingetretene Event soll ein anderes System erfahren? | Einen nachgelagerten Ablauf zeitnah anstoßen |
| A2A | Welchen begrenzten Auftrag kann ein eigenständiger Agent übernehmen? | Zustandsbehaftete Arbeit an ein anderes Agentensystem delegieren |
Die vier Optionen stehen nicht in einer Rangfolge und liegen nicht auf derselben technischen Schicht. HTTP ist ein Übertragungsprotokoll, OpenAPI beschreibt eine Schnittstelle, Webhooks verwenden HTTP für Ereigniszustellungen, und MCP sowie A2A bringen eigene Interaktionsverträge mit. Ein A2A-Agent kann intern MCP-Werkzeuge und normale HTTP-APIs aufrufen.
## MCP stellt Fähigkeiten für Agentenanwendungen bereit
MCP steht für Model Context Protocol. Eine Agentenanwendung kann damit etwa die Suche eines Wissensdienstes als Werkzeug entdecken; die Sichtbarkeit dieses Werkzeugs ist noch keine fachliche Berechtigung und kein Ersatz für einen festen Workflow.
Ein Server kann lokal als Prozess oder entfernt als Webdienst laufen. Das Wort „Server“ beschreibt seine Rolle im Protokoll, nicht seinen Standort.
```json
{
"mcpServers": {
"knowledge": {
"type": "http",
"url": "https://knowledge.example.com/mcp"
}
}
}
```
Nach dem Verbinden kann die Agentenanwendung das Eingabeschema prüfen und das Werkzeug aufrufen. Das Modell erhält dadurch keine pauschale Berechtigung. Der Host steuert, welche Fähigkeiten sichtbar sind und welche Aufrufe eine Zustimmung verlangen. Der Server authentifiziert und autorisiert den Aufruf. Der zuständige Dienst setzt zusätzlich seine fachlichen Regeln für die Operation durch.
MCP passt zu offenen Aufgaben. Eine Agentenanwendung kann in einem Wissensdienst nach freigegebenem Wissen suchen, Quellen lesen und abhängig vom Ergebnis entscheiden, welcher nächste Schritt sinnvoll ist. Für wiederholte Veröffentlichungen mit identischer Schrittfolge ist diese Freiheit unnötig. Ein gespeicherter, freigegebener Workflow ist dort leichter zu prüfen und zu wiederholen.
## HTTP und OpenAPI bilden einen ausdrücklichen Maschinenvertrag
HTTP regelt Anfrage und Antwort. OpenAPI beschreibt darauf aufbauende APIs maschinenlesbar: Pfade, Methoden, Eingaben, Antworten und Sicherheitsverfahren. Menschen können die Beschreibung lesen, Programme daraus Clients erzeugen und Prüfungen die Implementierung mit dem Vertrag vergleichen.
Der folgende Aufruf ist ein schematisches Beispiel:
```http
POST /v1/sites/demo/previews HTTP/1.1
Host: content.example.com
Authorization: Bearer
Content-Type: application/json
{
"revisionIds": ["rev-123", "rev-456"]
}
```
Der Aufruf fordert eine Vorschau an. Er sagt nichts darüber aus, wer den Inhalt fachlich geprüft hat oder ob diese Vorschau veröffentlicht werden darf. OpenAPI kann den technischen Vertrag präzisieren. Die Freigaberegel gehört in die Fachdomäne und in den kontrollierten Ablauf.
In einem Publishing-System kann die HTTP- und OpenAPI-Oberfläche feste Integrationen bedienen, ein Remote-MCP-Endpoint ausgewählte Fähigkeiten an Agentenanwendungen richten und eine Weboberfläche die menschliche Arbeit in derselben Publishing-Domäne tragen. Alle drei Zugänge arbeiten dann mit denselben Revisionen, Vorschauen, Releases und Berechtigungsgrenzen; keiner führt einen zweiten Persistenzpfad ein.
## Ein Webhook meldet ein Event
Bei einem normalen API-Aufruf fragt der Client aktiv nach. Bei einem Webhook sendet die Event Source eine HTTP-Anfrage an eine vorher registrierte Adresse. Der Empfänger muss dadurch nicht fortlaufend prüfen, ob sich etwas geändert hat.
```http
POST /webhooks/knowledge HTTP/1.1
Host: orchestration.example.com
webhook-id: evt-789
webhook-timestamp: 1785585600
webhook-signature: v1,
Content-Type: application/json
{
"type": "proposal.approved",
"data": {
"space": "product-docs",
"concepts": ["integration-options"]
}
}
```
Der Event-Typ im Beispiel ist absichtlich generisch. In diesem Ablauf transportiert der Webhook nur das Event und die Referenz auf den maßgeblichen Stand. Der Empfänger prüft Signatur und Alter, erkennt Mehrfachzustellungen über die Event-ID und liest den Stand anschließend mit eigener Berechtigung aus dem verantwortlichen System.
Mehrfache Zustellung gehört zum normalen Fehlerbild. Der Empfänger muss idempotent arbeiten: Dieselbe Event-ID darf fachlich nur einmal wirken. Er antwortet schnell und verschiebt längere Arbeit in einen gespeicherten Ablauf. Ein Wissensdienst kann dafür signierte Standard Webhooks liefern. Eine Workflow-Engine kann einen solchen Eingang signaturgeprüft und gegen Wiederholungen geschützt an genau einen versionierten Workflow binden, ohne die Wissens- oder Publishing-Regeln der beteiligten Systeme zu übernehmen.
## A2A delegiert an ein eigenständiges Agentensystem
A2A steht für Agent2Agent. Das Protokoll verbindet einen aufrufenden Agenten mit einem eigenständigen entfernten Agentensystem. Der Client kennt dessen veröffentlichte Fähigkeiten, aber nicht dessen internen Plan, Speicher oder Werkzeuge. Der entfernte Agent bleibt dafür verantwortlich, wie er den Auftrag innerhalb seiner Grenzen bearbeitet.
Eine Agent Card beschreibt Identität, Endpoint, Fähigkeiten und Anforderungen an die Anmeldung. Eine Message überträgt einen Gesprächsschritt aus Text, Dateien oder strukturierten Daten. Länger laufende Arbeit erhält einen Task mit eigener ID und einem Lifecycle. Ergebnisse werden als Artifacts zurückgegeben. Rückfragen und andere notwendige Entscheidungen erscheinen als Zustandsübergänge des Tasks.
Das unterscheidet Delegation von einem Werkzeugaufruf. Bei MCP ruft eine Agentenanwendung eine beschriebene Fähigkeit auf. Bei A2A übergibt ein Agent ein Ziel an ein anderes System, das selbst planen, Werkzeuge verwenden und mehrere Schritte ausführen kann.
## Weboberflächen und Maschinenoberflächen erfüllen verschiedene Aufgaben
Eine Weboberfläche für Menschen ist keine fünfte Integrationsart. MCP, HTTP mit OpenAPI, Webhooks und A2A verbinden Maschinen. Weboberfläche und Maschinenoberflächen arbeiten mit dem Zustand derselben Fachdomäne und führen keinen zweiten Persistenzpfad ein.
Jede Weboberfläche verwendet dafür die Begriffe und Entscheidungen ihrer eigenen Domäne. In einem Wissensdienst ist eine ausstehende Wissensänderung ein Änderungsvorschlag, in einer Workflow-Engine gehört eine Ausführung zu einer bestimmten Workflow-Version.
Aus dieser Trennung folgen zwei Grenzen:
- Eine Weboberfläche wird nicht zum zweiten fachlichen System mit abweichenden Regeln.
- Ein Maschinenprotokoll wird nicht zur unbeabsichtigten Umgehung der menschlichen Entscheidung.
## Kein Protokoll erteilt von selbst Berechtigungen
Authentifizierung beantwortet: Wer stellt die Anfrage? Autorisierung beantwortet: Was darf diese Identität tun? Ein gültiger Schlüssel sollte Lesen, Schreiben und Veröffentlichen nicht pauschal zusammenfassen.
Ein Agent, der Wissen sucht, braucht nur Leserechte. Ein Schritt, der eine Vorschau baut, braucht die dafür erforderlichen Schreibrechte. Eine Veröffentlichung darf eine eigene Berechtigung und eine sichtbar gebundene menschliche Freigabe verlangen. Wenn eine Operation über mehrere Oberflächen angeboten wird, müssen für sie dieselben fachlichen Freigabegrenzen gelten.
Zuverlässigkeit entsteht ebenfalls nicht durch den Namen des Protokolls. Ein HTTP-Aufruf kann nach erfolgreicher Verarbeitung abbrechen, bevor die Antwort beim Client ankommt. Ein Webhook kann mehrfach eintreffen. Ein A2A-Task kann lange auf eine Entscheidung warten. Jeder schreibende Schritt braucht deshalb eine stabile Kennung, eine klare Wiederholungsregel und einen gespeicherten Zustand.
Für schreibende oder freigabepflichtige Integrationen müssen drei Verträge zusammenpassen:
- Der technische Vertrag beschreibt Eingaben, Ergebnisse und Fehler.
- Der fachliche Vertrag legt fest, welches System Wissen, Freigabe und Veröffentlichung besitzt.
- Der betriebliche Vertrag regelt Zeitlimits, Wiederholungen, Logging und den Umgang mit Ausfällen.
## Ein Ablauf mit allen vier Grenzen
```mermaid
flowchart LR
U["Mensch formuliert ein Ziel"] --> A["Agentenanwendung bearbeitet offene Aufgabe"]
A -->|"MCP suchen und lesen"| K["Wissensdienst geprüftes Wissen"]
A -->|"MCP oder HTTP / OpenAPI Revision und Vorschau"| C["Publishing-System Publishing-Domäne"]
K -->|"signierter Webhook Freigabeereignis"| S["Workflow-Engine versionierter Workflow"]
S -->|"HTTP / OpenAPI festgelegte Schritte"| C
A -.->|"A2A begrenzten Auftrag delegieren"| R["Agentensystem eigenständiger Task"]
H["Mensch in der jeweiligen Weboberfläche"] -.-> K
H -.-> S
H -.-> C
H -.-> R
```
Der erste Durchlauf kann begleitet sein. Eine Agentenanwendung liest im Wissensdienst, erzeugt Markdown und baut im Publishing-System eine Vorschau. Ein Mensch sieht die Ergebnisse und kann die Reihenfolge noch verändern.
Sobald sich die Folge stabil wiederholt, gehört sie als versionierter Workflow in eine Workflow-Engine. Der Workflow liest eine konkrete freigegebene Wissensrevision, erzeugt eine Content-Revision und baut eine Vorschau. Er veröffentlicht nicht deshalb automatisch, weil ein Webhook ihn gestartet hat. Das Publishing-System behält die Freigabe- und Release-Grenze.
A2A kommt hinzu, wenn tatsächlich ein eigenständiges Agentensystem einen begrenzten Auftrag mit eigener Laufzeit übernimmt. Ein einfacher API-Aufruf wird durch die Bezeichnung „Agent“ nicht zu einer Delegation.
## Die Entscheidung liegt vor dem Protokoll
Die Tabelle hilft erst, wenn drei Fragen beantwortet sind: Welches System besitzt den Zustand? Welche Identität darf ihn verändern? Welche Wirkung benötigt eine menschliche Entscheidung? Daraus folgen die Regeln für Wiederholungen und die Ansicht, in der ein Mensch den aktuellen Stand prüfen kann.
Zuerst werden der Besitzer von Zustand und Freigabe festgelegt. Danach folgt das Protokoll.
## Weiterführende Quellen
- [Model Context Protocol: Architektur](https://modelcontextprotocol.io/docs/learn/architecture)
- [Model Context Protocol: Einführung](https://modelcontextprotocol.io/docs/getting-started/intro)
- [OpenAPI Specification](https://spec.openapis.org/oas/)
- [Standard Webhooks](https://www.standardwebhooks.com/)
- [A2A: zentrale Konzepte](https://a2a-protocol.org/latest/topics/key-concepts/)
- [A2A und MCP im Vergleich](https://a2a-protocol.org/latest/topics/a2a-and-mcp/)
---
# A2A: Wenn Agenten zusammenarbeiten
URL: https://www.mikebild.dev/de/blog/a2a-agenten-zusammenarbeit/
Datum: 2026-07-22
Ein Agentensystem braucht eine begrenzte Codeänderung in einem fremden Repository. Es könnte selbst Werkzeuge laden, den Code lesen und die Änderung entwerfen. Es kann den Auftrag aber auch an ein eigenständiges System übergeben, das in einer anderen Umgebung läuft, eigene Berechtigungen besitzt und später ein prüfbares Ergebnis zurückmeldet.
A2A 1.0 – die Abkürzung steht für Agent2Agent – beschreibt für diesen zweiten Fall die Übergabe und Verfolgung eines Auftrags zwischen eigenständigen Systemen. Die veröffentlichte Spezifikation des offenen Protokolls behandelt, wie ein Auftraggeber einen entfernten Agenten findet, ihm Messages übermittelt, länger laufende Aufgaben verfolgt und Ergebnisse entgegennimmt. Welches Sprachmodell, welche Programmiersprache oder welches Framework intern arbeitet, schreibt sie nicht vor.
## Eigenständig ist das entscheidende Wort
Nicht jede benannte Rolle ist ein eigener Agent. Wenn eine Anwendung nacheinander drei Prompts ausführt und alle Werkzeuge, Zugangsdaten und Zustände zentral verwaltet, sind das aus Sicht der Architektur drei Arbeitsschritte in einem Agentensystem. A2A bringt dort wenig.
Ein entfernter A2A-Agent ist dagegen ein eigenständiger Dienst. Er entscheidet innerhalb seines Auftrags selbst, wie er arbeitet. Der aufrufende Agent sieht die angebotenen Fähigkeiten und die ausgetauschten Daten, aber nicht automatisch den internen Speicher, die Überlegungen oder die Werkzeuge des anderen Systems. Diese Kapselung trennt die Berechtigungs- und Task-Grenzen beider Systeme: Der entfernte Agent arbeitet mit eigenen Zugriffsrechten, und ausgetauscht werden sollte nur, was der Auftrag vorsieht.
Im Protokoll nimmt ein A2A-Client im Auftrag des Benutzers Kontakt auf. Der A2A-Server stellt den entfernten Agenten bereit. Client und Server sind Kommunikationsrollen, keine Systemklassen: Bei einem anderen Auftrag kann dasselbe System die andere Rolle einnehmen.
```mermaid
flowchart LR
U["Benutzer gibt ein Ziel vor"] --> C["Aufrufender Agent A2A-Client"]
C -->|"Agent Card lesen"| S["Entfernter Agent A2A-Server"]
C -->|"Message Auftrag und Kontext"| S
S -->|"Task Zustand und Rückfragen"| C
S -->|"Artifacts Ergebnisse"| C
S --> M["Interne Modelle, Tools und Datenquellen"]
C -.->|"kein automatischer Zugriff"| M
```
## Die Agent Card ist die Beschreibung, nicht die Berechtigung
Bevor ein Client einen Auftrag sendet, muss er wissen, was der andere Agent anbietet und wie er erreichbar ist. Dafür dient die Agent Card, ein JSON-Dokument mit Metadaten. Die veröffentlichte A2A-1.0-Spezifikation beschreibt darin unter anderem Identität, unterstützte Schnittstellen und angebotene Skills; als Bezugswege nennt sie eine standardisierte Adresse (`https://{domain}/.well-known/agent-card.json`), daneben Kataloge oder eine feste Konfiguration.
Das folgende fiktive Publishing-Beispiel ist auf die hier benötigten Felder reduziert und beansprucht keine vollständige A2A-1.0-Agent-Card.
```json
{
"name": "Publishing Agent",
"description": "Builds previews and prepares approved releases",
"supportedInterfaces": [
{
"url": "https://publishing.example.com/a2a",
"protocolBinding": "HTTP+JSON",
"protocolVersion": "1.0"
}
],
"version": "1.0.0",
"capabilities": {
"streaming": true,
"pushNotifications": true,
"extendedAgentCard": true
},
"defaultInputModes": ["text/plain", "application/json"],
"defaultOutputModes": ["text/markdown", "application/json"],
"skills": [
{
"id": "prepare-publication",
"name": "Prepare publication",
"description": "Creates a preview from approved knowledge",
"tags": ["publishing", "preview", "content"]
}
]
}
```
Die Agent Card ist mit einer öffentlichen Leistungsbeschreibung vergleichbar. Dass dort ein Skill aufgeführt ist, erlaubt noch keinen Aufruf. Anmeldung und Autorisierung bleiben eigene Sicherheitsentscheidungen: Der Server muss bei jedem Auftrag prüfen, wer anfragt und was dieser Auftraggeber tun darf. Eine öffentliche Agent Card sollte außerdem keine internen Fähigkeiten oder vertraulichen Endpoints verraten.
## Message, Part, Task und Artifact
Message, Part, Task und Artifact bezeichnen unterschiedliche Bausteine eines Auftrags.
| Begriff | Bedeutung | Beispiel bei delegierter Arbeit |
| --- | --- | --- |
| Message | Ein Gesprächsbeitrag des Benutzers oder Agenten | „Analysiere diese Abhängigkeit und schlage eine Änderung vor.“ |
| Part | Ein Bestandteil einer Message oder eines Artifacts | Anweisung als Text, eine Datei oder strukturierte Daten |
| Task | Eine zustandsbehaftete Arbeitseinheit mit eindeutiger ID | Der Auftrag wartet auf eine Rückfrage oder arbeitet weiter |
| Artifact | Ein vom Agenten erzeugtes Ergebnis | Analysebericht, vorbereitete Änderung, Vorschau-URL |
Eine Message kann sofort mit einer anderen Message beantwortet werden. Das passt zu einer kurzen Unterhaltung ohne dauerhaften Arbeitszustand. Muss die Arbeit weiterlaufen oder über mehrere Gesprächsrunden erhalten bleiben, antwortet der entfernte Agent mit einem Task.
Der Task ist mehr als eine technische Anfrage-ID. Er hält den Zustand einer fachlichen Arbeitseinheit. Der Client kann ihn später lesen, auf eine Rückfrage antworten oder eine Stornierung anfordern. Nach der Spezifikation können mehrere Messages über eine `contextId` zu demselben Gesprächszusammenhang gehören; eine `taskId` bezeichnet die konkrete Arbeit. Ein vereinfachtes, nicht normatives Beispiel:
```http
POST /message:send HTTP/1.1
Host: agents.example.com
Authorization: Bearer
Content-Type: application/a2a+json
A2A-Version: 1.0
{
"message": {
"role": "ROLE_USER",
"messageId": "msg-123",
"parts": [
{
"text": "Prepare a limited change proposal. Do not merge it."
},
{
"data": {
"repository": "product-service",
"scope": ["dependency-upgrade"]
},
"mediaType": "application/json"
}
]
}
}
```
Die Parts trennen unterschiedliche Inhalte innerhalb derselben Message: Text trägt eine Anweisung, eine Datei übergibt ein Dokument, strukturierte Daten erlauben ein vereinbartes Schema ohne erneutes Auslesen aus Prosa. Der Empfänger muss Medientyp, Größe, Herkunft und Berechtigung jedes Inhalts prüfen.
Artifacts sind die Arbeitsergebnisse, nicht bloß Gesprächsbeiträge. Laut Spezifikation kann ein Task mehrere Artifacts liefern, und ein Artifact kann während eines Datenstroms schrittweise ergänzt werden. Der Client sollte deshalb Artifact-ID und Task-ID speichern, statt nur den letzten sichtbaren Text zu kopieren. Eine typische erste Antwort sieht so aus – der Server hat angenommen, aber noch nicht abgeschlossen:
```json
{
"task": {
"id": "task-456",
"contextId": "context-789",
"status": {
"state": "TASK_STATE_WORKING",
"timestamp": "2026-08-07T10:05:00Z"
},
"artifacts": []
}
}
```
## Der Lifecycle macht längere Arbeit sichtbar
A2A ist auf asynchrone Aufgaben ausgelegt. Ein Server kann sofort einen Task zurückgeben und im Hintergrund weiterarbeiten. Für Aktualisierungen sieht die Spezifikation drei Zustellwege vor: Queries, einen fortlaufenden Datenstrom oder Push Notifications.
```mermaid
stateDiagram-v2
[*] --> SUBMITTED
SUBMITTED --> WORKING
WORKING --> INPUT_REQUIRED: Rückfrage
INPUT_REQUIRED --> WORKING: weitere Message
WORKING --> AUTH_REQUIRED: zusätzliche Freigabe
AUTH_REQUIRED --> WORKING: Berechtigung erteilt
WORKING --> COMPLETED
WORKING --> FAILED
SUBMITTED --> REJECTED
WORKING --> CANCELED
COMPLETED --> [*]
FAILED --> [*]
REJECTED --> [*]
CANCELED --> [*]
```
Das Diagramm vereinfacht den in der Spezifikation von Version 1.0 definierten Zustandsraum. `INPUT_REQUIRED` bedeutet, dass der Agent weitere fachliche Angaben braucht. `AUTH_REQUIRED` signalisiert eine während des Auftrags nötige Autorisierung; Zugangsdaten gehören dabei nicht als Klartext in eine Message, sondern laufen über einen getrennten, zuvor vereinbarten Weg. Als Endzustände definiert die Spezifikation `COMPLETED`, `FAILED`, `CANCELED` und `REJECTED`. Ein Client darf einen Endzustand nicht durch blindes Wiederholen wiederbeleben, sondern muss bewusst einen neuen Task anlegen.
Polling, Streaming und Push lösen dasselbe Zustellungsproblem auf unterschiedliche Weise. Beim Polling fragt der Client in sinnvollen Abständen nach dem Task – einfach, bei langen Pausen aber verschwenderisch. Beim Streaming bleibt eine Verbindung offen und der Server sendet Status- und Artifact-Updates als Events; nach einer Unterbrechung muss der Client den gespeicherten Task erneut lesen, denn ein Datenstrom ist kein Archiv. Push Notifications ersparen die dauerhafte Verbindung, verlangen dafür einen abgesicherten HTTP-Endpoint beim Client, inklusive Authentifizierung, Schutz vor internen Zieladressen und Behandlung mehrfacher Zustellungen.
## Delegation erzeugt keine neue Berechtigung
A2A nimmt einem System keine Sicherheitsentscheidung ab. Ein aufrufender Agent sollte einer gefundenen Agent Card nicht allein deshalb vertrauen, weil sie formal korrekt ist. Vor einem Auftrag muss feststehen, welchem Anbieter das eigene System vertraut, welche Daten es verlassen dürfen und welche Wirkung der entfernte Agent auslösen kann.
Der A2A-Server steht in derselben Pflicht: Er muss bei jedem Auftrag prüfen, wer anfragt und was dieser Auftraggeber tun darf, und Messages als nicht vertrauenswürdige Eingaben behandeln. Der wichtigste Grundsatz dahinter: Delegation darf keine neue Berechtigung erzeugen. Wer einen Auftrag übermittelt, darf dadurch nicht mehr Rechte im Zielsystem erhalten, und der ausführende Agent darf nicht stillschweigend die Rechte seines Auftraggebers erben. Der Auftrag bleibt begrenzt.
Ein Zielsystem kann diese Begrenzung explizit machen: Ein delegierter Auftrag ist dann an einen aktiven, menschlich freigegebenen Auftragsstand gebunden. Was dieser Stand nicht erlaubt, kann auch ein technisch korrekter A2A-Aufruf nicht auslösen. Ein menschlicher Freigabeschritt bleibt damit eine fachliche Entscheidung im Zielsystem – ein Agent darf eine Freigabe nicht aus einer freundlichen Formulierung in einer Message ableiten.
## MCP, A2A und Weboberfläche sind verschiedene Zugänge, keine Etiketten
MCP stellt einer Agentenanwendung Werkzeuge und Kontext bereit; die Verantwortung für die offene Aufgabe bleibt in der Anwendung. A2A verbindet eigenständige Agentensysteme: Der Auftraggeber übergibt ein Ziel, der entfernte Agent verantwortet die Ausführung und führt einen eigenen Task-Lifecycle. MCP und A2A modellieren damit unterschiedliche Verantwortlichkeiten und Lifecycles.
| Frage | MCP | A2A |
| --- | --- | --- |
| Gegenüber | Fähigkeitsserver | Eigenständiges Agentensystem |
| Auffindbare Beschreibung | Werkzeuge und Kontextquellen | Agent Card mit Skills und Schnittstellen |
| Typische Arbeit | Werkzeug auswählen und aufrufen | Ziel oder Teilaufgabe delegieren |
| Länger laufender Zustand | Durch die Anwendung modelliert | Task-Lifecycle ist Protokollkonzept |
| Ergebnis | Tool-Ergebnis oder Resource | Message oder ein oder mehrere Artifacts |
| Interne Umsetzung | Fähigkeit mit definiertem Schema | Entfernter Agent bleibt intern eigenständig |
Dazu kommt eine Weboberfläche als Zugang für Menschen. Diese Zugänge haben unterschiedliche Aufgaben, und ein System kann mehrere davon anbieten, ohne dass daraus mehrere Fachmodelle werden.
Ein System kann etwa begrenzte Analyse- und Änderungsaufträge über A2A 1.0 anbieten, während REST, MCP, A2A und Weboberfläche denselben strukturierten Task- und Ergebnisdatensatz lesen.
## Wann A2A sinnvoll ist
A2A lohnt sich, wenn mehrere Bedingungen gleichzeitig zutreffen: Die beteiligten Agenten werden unabhängig entwickelt oder betrieben. Die Arbeit dauert möglicherweise länger als eine einzelne Anfrage, benötigt Rückfragen oder erzeugt mehrere Ergebnisse. Der Auftraggeber legt Ziel und zulässige Wirkung fest, der entfernte Agent verantwortet die interne Ausführung.
Für eine bekannte Folge fester Schritte ist ein deterministischer Workflow meist einfacher. Bloß verschiedene Rollennamen, mehrere Sprachmodelle oder getrennte Prompts rechtfertigen noch keine verteilte Agentenarchitektur – sie erzeugen nur eine zusätzliche Netzgrenze ohne zusätzliche Verantwortungsgrenze.
Die Entscheidung lässt sich daran festmachen, wer die Verantwortung für die offene Aufgabe trägt. Bleibt sie in der eigenen Anwendung und benötigt sie lediglich Werkzeuge oder Kontext, kann MCP genügen. Übernimmt ein unabhängiges System einen begrenzten Auftrag mit eigenem Task-Lifecycle, ist A2A der passende Vertrag. Wer diese Ebenen auseinanderhält, baut keine unnötigen Agenten – und erkennt, welche Merkmale die hier beschriebene Delegation besitzt: eine Agent Card, ein authentifizierter Aufruf, ein nachverfolgbarer Task und ein begrenzter Auftrag.
## Weiterführende Quellen
- [A2A Protocol Specification 1.0](https://a2a-protocol.org/latest/specification/)
- [A2A: Core Concepts](https://a2a-protocol.org/latest/topics/key-concepts/)
- [A2A: Life of a Task](https://a2a-protocol.org/latest/topics/life-of-a-task/)
- [A2A und MCP im Vergleich](https://a2a-protocol.org/latest/topics/a2a-and-mcp/)
- [Model Context Protocol: Architektur](https://modelcontextprotocol.io/docs/learn/architecture)
- [MCP, HTTP, Webhooks und A2A einfach erklärt](https://www.mikebild.dev/de/blog/mcp-http-webhooks-a2a-einfach-erklaert/)
---
# Stündlich ist nicht Echtzeit
URL: https://www.mikebild.dev/de/blog/stuendlich-ist-nicht-echtzeit/
Datum: 2026-07-20
Ein stündlicher Report fragt nicht nach dem aktuellen Zustand, sondern nach der gerade abgeschlossenen Stunde. Was um 14:00:00 UTC passiert, gehört bereits in das nächste Zeitfenster. Der Lauf beginnt deshalb erst, wenn das Zeitfenster geschlossen ist, und veröffentlicht seinen Stand einige Minuten später. Für einen Alarm wäre das viel zu spät. Für eine verlässliche Zusammenfassung ist es genau die gewünschte Verzögerung.
Diese zeitliche Entscheidung trennt den Stundenreport von laufender Betriebsbeobachtung. Ein abgeschlossener Report beantwortet eine andere Frage als Monitoring: Er hält einen begrenzten Zeitraum als prüfbaren Stand der Beobachtungen fest, während Monitoring auf neue Signale reagieren muss. Der Unterschied liegt nicht zuerst in Prometheus, Grafana oder Markdown. Er liegt darin, wie schnell ein neuer Wert eine Reaktion auslösen muss und ob sich die betrachtete Aussage später noch verändern darf.
Der Beitrag [„Markdown Reports statt Dashboard-Zwang“](https://www.mikebild.dev/de/blog/markdown-reports-statt-dashboard/) beschreibt bereits den Unterschied zwischen flüchtiger Ansicht und prüfbarem Stand. Hier geht es enger um die Zeitmechanik eines regelmäßigen Produktreports: geschlossene Zeitfenster, verspätete Daten, Wiederholungen und die Grenze zu echter Betriebsbeobachtung.
## Zwei Zeitachsen, zwei Aufgaben
Monitoring arbeitet möglichst nah am Event. Eine Fehlerrate steigt, ein Alarm wird ausgewertet, jemand öffnet Logs und Traces. Neue Daten verändern die Darstellung fortlaufend. Ein Report wartet dagegen, bis sein Zeitraum beendet ist. Er kann dann feststellen, welche Quellen vollständig vorlagen, seine Fakten hashen und denselben Stand später erneut ausliefern.
```mermaid
flowchart LR
E["Ereignis"] --> M["Live-Metrik Sekunden bis Minuten"]
M --> A["Alarm oder Untersuchung"]
E --> W["geschlossenes Stundenfenster"]
W --> R["unveränderlicher Report"]
R --> V["Vergleich und Einordnung"]
```
Beide Wege dürfen dasselbe Event sehen und trotzdem zu verschiedenen Ergebnissen kommen. Das Monitoring kann um 13:42 auf fünf Fehler in zwei Minuten reagieren. Der Stundenreport hält später fest, dass im Zeitfenster von 13 bis 14 Uhr fünf Fehler bei 1.200 Ausführungen auftraten, welche Quellen abgedeckt waren und ob die Häufung im Vergleich zu früheren Zeitfenstern auffällt.
Eine laufend aktualisierte Oberfläche für die zweite Aufgabe würde unvollständige Zwischenstände zeigen. Während des laufenden Zeitfensters sind Zähler unvollständig. Ein Wert von null um 13:01 sagt fast nichts über die Stunde aus. Ein wachsender Balken lädt dazu ein, Zwischenstände ungekennzeichnet mit abgeschlossenen Stunden zu vergleichen. Ohne Berücksichtigung der unterschiedlichen Abdeckung ist dieser Vergleich nicht belastbar.
## Die Grenzen des Zeitfensters
Die Sammlung verwendet halboffene UTC-Intervalle. Anfang eingeschlossen, Ende ausgeschlossen. Diese Schreibweise verhindert, dass ein Event an der Grenze in zwei Reports landet.
```ts
type ClosedWindow = {
from: string; // inclusive RFC 3339 timestamp
to: string; // exclusive RFC 3339 timestamp
bucket: "hour";
};
const window: ClosedWindow = {
from: "2026-07-18T13:00:00.000Z",
to: "2026-07-18T14:00:00.000Z",
bucket: "hour"
};
```
UTC vermeidet einen unangenehmen Sonderfall: In Europa hat der Tag der Sommerzeitumstellung nicht immer 24 lokale Stunden. Speicherung und Sammlung bleiben deshalb in UTC. Die Reportseite kann ein Datum später für ihre Leser lokalisieren, ohne die fachliche Grenze zu verändern.
Zwischen dem Ende des Zeitfensters und der Frischeprüfung sieht dieser Ablauf eine ausdrücklich festgelegte Reserve vor. Wird die Sammlung umfangreicher, müssen Startzeitpunkt, Timeout und Prüfgrenze gemeinsam angepasst werden. Eine heimlich verlängerte Reserve würde echte Verzögerungen nur später sichtbar machen.
## Verspätete Daten und fehlende Läufe getrennt halten
Ein HTTP-Aufruf kann vorübergehend fehlschlagen. Ein Workflow kann nach dem Schreiben des Artefakts abbrechen, bevor er seinen Status aktualisiert. Ein Release kann erfolgreich sein, obwohl die Antwort beim Client nicht mehr ankommt. Darum darf ein Retry nicht einfach „noch einmal alles“ bedeuten.
Jeder Lauf hat ein eindeutiges Zeitfenster. Cadence-markierte Reports werden hier als immutable Veröffentlichungen behandelt: Ein einmal veröffentlichter Stundenstand ändert sich nicht mehr. Ein wiederholter erfolgreicher Versuch darf deshalb keinen zweiten, abweichenden Stundenreport für dasselbe Zeitfenster sichtbar machen.
Erst nach der vorgesehenen Reserve wird zwischen verspätet und fehlend unterschieden. Ein verspäteter Lauf kann noch erfolgreich abschließen und denselben Report veröffentlichen. Ein fehlender Lauf hinterlässt eine Lücke in der erwarteten Stundenfolge. Verspätung, Messlücke und geschlossenes Zeitfenster bleiben damit drei getrennte Sachverhalte, die der Report getrennt benennen sollte.
## Was aus einer fehlenden Beobachtung folgt
Ein kritischer Fall für einen Stundenreport ist eine Stunde ohne Daten. Ein Beobachtungsdienst sollte dafür ausdrücklich vier Zustände unterscheiden: Eine Quelle wurde noch nie beobachtet, sie wurde geprüft und der erwartete Inhalt ist nicht vorhanden, sie ist zugangsgeschützt, oder sie ist tatsächlich fehlerhaft. Eine fehlende Beobachtung darf dabei weder als gesunder Zustand noch als Zahlenwert null ausgegeben werden.
Für einen Stundenreport heißt das: Liegt für eine Stunde keine Messung vor, existiert für diese Stunde kein Wert. Der Report darf dann nicht behaupten, es habe null Events gegeben, denn diese Aussage würde eine Messung unterstellen, die nie stattgefunden hat. Er muss stattdessen ausweisen, dass die Quelle im betrachteten Zeitraum nicht beobachtet wurde und die Aussage offen bleibt. Wurde die Quelle dagegen geprüft und der erwartete Inhalt nicht gefunden, ist dieser Zustand beobachtet; daraus folgt aber nicht automatisch ein allgemeiner Fehlerzähler von null.
## Wann Prometheus und Grafana fehlen würden
Werkzeuge wie Prometheus und Grafana unterstützen unter anderem die laufende Untersuchung: Eine Query lässt sich während der Analyse anpassen und der Zeitraum verschieben. Diese Arbeitsweise ist wertvoll, wenn die Frage nicht vorab feststand.
Eine Oberfläche für Stundenreports kann dagegen auf abgeschlossene Reportzeiträume ausgerichtet sein. Diese Ausrichtung passt, solange die Oberfläche abgeschlossene Zeiträume erklären soll. Für eine Incident-Analyse kämen Warnungen dagegen zu spät, und die stündliche Auflösung reicht für eine Ursachensuche bis auf einzelne Requests nicht aus. Ein stündlicher Report ersetzt weder Alarmierung noch laufende Betriebsbeobachtung; er setzt beides als eigenständige Aufgaben voraus.
## Vier Fragen vor der Werkzeugwahl
„Dashboard oder Report?“ ist zu grob. Vier Fragen trennen die Anforderungen: Reaktionszeit, Veränderlichkeit, Untersuchung und Auflösung.
Die erste betrifft die Reaktionszeit. Muss jemand innerhalb von Sekunden oder wenigen Minuten handeln, gehört die Beobachtung in ein Monitoring- und Alerting-System. Darf ein Team den Stand im nächsten regelmäßigen Arbeitszyklus prüfen, kann ein stündlicher oder täglicher Report reichen.
Die zweite betrifft die Veränderlichkeit. Soll dieselbe URL morgen neue Werte zeigen, ist eine Live-Query passend. Muss später noch genau der Stand vom 18. Juli lesbar sein, braucht es ein immutable Artefakt oder einen ausdrücklich gespeicherten Snapshot.
Die dritte betrifft die Untersuchung. Sind die Fragen vorab bekannt – Anzahl Releases, Fehler, Quellenabdeckung –, kann ein begrenztes Schema sie präzise abbilden. Entstehen die Fragen erst beim Blick auf eine Auffälligkeit, werden Query Language, variable Zeiträume und Drill-down wichtig.
Die vierte betrifft die Auflösung. Ein stündlicher Zähler kann zeigen, dass etwas häufiger fehlschlug. Er kann nicht erklären, welcher einzelne Request langsam war oder welche Logzeile zu einem Trace gehört. Für diese Untersuchung müssen die hochaufgelösten Daten in ihrem Betriebswerkzeug bleiben.
```yaml
decision:
reaction_time: next_work_cycle
immutable_history: required
questions_known_in_advance: true
per_request_drilldown: false
result: scheduled_report
```
Sobald eine Antwort kippt, kann auch das passende Werkzeug wechseln. Ein Report und ein Live-System dürfen denselben Dienst beobachten, solange sie nicht vortäuschen, dieselbe Aufgabe zu erfüllen.
## Der Scheduler ist Teil der Aussage
Ein manuell erzeugter Report belegt nur, dass irgendwann jemand einen Knopf gedrückt hat. Ein geplanter Lauf macht zusätzlich sichtbar, ob die erwartete Regelmäßigkeit eingehalten wurde. Eine Prüfung dieser Regelmäßigkeit muss deshalb zwischen geplanten und manuell ausgelösten Läufen unterscheiden: Manuelle Läufe dürfen eine ausgefallene geplante Stunde nicht verdecken, sonst zählt die Prüfung Erfolge, die nichts über die Zusage der Regelmäßigkeit aussagen.
Auch eine Pause ist kein Fehler, wenn sie während eines Releases ausdrücklich gesetzt wurde. Sie muss jedoch sichtbar sein und nach dem Rollout bewusst aufgehoben werden. Ein vergessener Pause-Schalter ist kein Datenproblem, sondern eine unterbrochene Zusage über Regelmäßigkeit.
## Was ein Stundenreport erklären muss
Ohne ausgewiesene Quellenabdeckung kann ein Operator eine Messlücke als Ergebnis lesen. Ein Stundenreport muss deshalb selbst erklären, worauf er sich stützt. Überblick, Frage, Schlussfolgerung und nächste Handlung lassen sich aus demselben semantischen Report-Dokument ableiten; ein zweiter, parallel gepflegter Dashboard-Datensatz ist dafür nicht nötig. Eine passende Oberfläche zeigt diese Antwort in abnehmender Wichtigkeit: zuerst Zustand und Ausnahme, dann wenige Signale, danach Evidenz und Provenienz.
Eine Seite mit dreißig Metrics ohne Frage ist schwerer zu prüfen als eine Seite mit einer klaren Frage, einem belegten Stand und einer benannten nächsten Entscheidung. Die Faktendefinition muss dafür auch Datenlücken abbilden: Sie sollte vorhandene, fehlende und veraltete Quellen getrennt nennen, damit eine offene Aussage nicht wie eine beantwortete aussieht.
```md
## Data quality
The source window is complete for four product APIs.
External acquisition data is not connected yet and is shown as unavailable.
No value is inferred from missing input.
```
Auch die Aggregation braucht eine Erklärung. Eine wöchentliche Median-Laufzeit beantwortet eine andere Frage als das Maximum der langsamsten Stunde. Der Report nennt Zeitraum, erwartete und vorhandene Unterfenster sowie die verwendete Verdichtung. Sonst sieht eine präzise Zahl geprüfter aus, als sie ist.
## Verdichtung über größere Zeiträume
Tages-, Wochen-, Monats- und Jahresreports entstehen aus bereits abgeschlossenen Artefakten. Ein Tagesreport kann auf den immutable Stundenständen aufsetzen, statt dieselben Quellen für jede Stunde erneut abzufragen, und dabei ausweisen, welche Stundenfenster ihm fehlen. Cadence-markierte Reports bleiben immutable Veröffentlichungen; ein Rollup ersetzt keinen Stundenstand, er verdichtet ihn.
```mermaid
flowchart TD
H["24 Stundenartefakte"] --> D["Tagesreport"]
D --> W["Wochenreport"]
W --> M["Monatsreport"]
M --> Y["Jahresreport"]
H --> Q["Abdeckung und fehlende Fenster"]
Q --> D
```
Ein Tagesreport, dem einzelne Stundenfenster fehlen, kann trotzdem hilfreicher sein als gar kein Report – aber nur, wenn er sich klar als unvollständig ausweist. Er darf nicht dieselbe visuelle Sicherheit ausstrahlen wie ein vollständig abgedeckter Zeitraum. Die Datenqualität gehört neben die Kennzahlen, nicht in eine Fußnote.
Eine Oberfläche kann den neuesten abgeschlossenen Zeitraum vor weiteren Entscheidungshorizonten und einer begrenzten Historie anordnen. Welche Frage jeder gröbere Report beantwortet, ist eine Gestaltungsentscheidung. Eine naheliegende Aufteilung: Die Stunde prüft den Datenfluss und frische technische Signale. Der Tag beantwortet, was heute Aufmerksamkeit braucht. Die Woche vergleicht Tagesverläufe und wiederkehrende Ausnahmen. Der Monat ordnet Aktivitätsmuster, Betriebsrisiken und Messlücken für die nächste Planung ein. Das Jahr verdichtet nur jene Evidenz, die eine strategische Entscheidung tragen kann. Nur den Datumsfilter zu verbreitern wäre formal korrekt und inhaltlich schwach.
Auch Zahlen sind dabei nicht bloß Werte. Eine Faktendefinition sollte Zähler, Bestände, Laufzeiten, Verhältnisse und Datenmengen unterscheiden, die Einheit nennen und festlegen, ob ein Rollup Summe, letzten Wert oder Mittelwert bevorzugt. Eine Maschine muss dann nicht aus einem Metriknamen raten, wie der Wert über mehrere Intervalle gelesen werden soll.
## Einfache Technik braucht eine klare Grenze
Der stündliche Ansatz kann ohne zusätzliche, dauerhaft laufende Auswertungsplattform auskommen, wenn vorhandene Systeme Sammlung, Planung und Veröffentlichung übernehmen. Seine Fragen stehen vor dem Lauf fest, und sein Ergebnis erscheint als immutable Veröffentlichung. Entscheidend ist die Verantwortungsgrenze: Der Report sammelt, schließt ab und veröffentlicht; die laufende Beobachtung bleibt bei den dafür gebauten Systemen.
Diese Einfachheit bleibt nur erhalten, wenn das System zu seiner Aufgabe steht. Ein Report darf eine fehlende Datenquelle zeigen, statt eine neue Datenerfassung heimlich einzubauen. Er darf auf eine externe Incident-Ansicht verweisen, statt selbst zur Leitstelle zu werden. Und er darf eine Frage unbeantwortet lassen, wenn dafür weder Fakt noch Connector vorhanden ist.
Stündlich bedeutet hier nicht „fast live“. Es bedeutet: regelmäßig, abgeschlossen, wiederholbar und langsam genug, um einen vollständigen Stand zu prüfen. Wer schneller reagieren muss, braucht Monitoring und Alarmierung. Wer später nachvollziehen will, was in einem klaren Zeitraum bekannt war, braucht einen Stundenreport. Beide bestehen nebeneinander, mit klar zugeordneten Aufgaben: Monitoring liefert laufende Signale, Alarmierung stößt daraus eine Reaktion an, und der Stundenreport bewahrt den abgeschlossenen, prüfbaren Beobachtungsstand.
## Weiterführende Quellen
- [Prometheus Overview](https://prometheus.io/docs/introduction/overview/)
- [Grafana Dashboards](https://grafana.com/docs/grafana/latest/visualizations/dashboards/)
- [W3C Trace Context](https://www.w3.org/TR/trace-context/)
---
# Claims: klein, belegt, prüfbar
URL: https://www.mikebild.dev/de/blog/claims-klein-belegt-pruefbar/
Datum: 2026-07-20
„Unser Publishing ist sicher, schnell und zuverlässig.“ Der Satz klingt gut und taugt kaum als Claim. Drei Bewertungen stecken darin, keine besitzt ein Kriterium, und eine Quelle könnte höchstens Teile davon belegen. Eine prüfende Person müsste den ganzen Satz annehmen oder ablehnen, obwohl sie vielleicht nur einen belegten Rollback-Mechanismus als Teil der Zuverlässigkeit bestätigen kann.
Eine Wissensbasis sollte deshalb kleine Aussagen als `subject / predicate / object` speichern. Der Seitentext bleibt für Menschen lesbar. Claims bilden darunter jene Einheiten, die einzeln zitiert, geprüft, bestritten und stillgelegt werden können. Confidence und Status beantworten dabei verschiedene Fragen.
## Ein Claim sagt genau eine Sache
Das Subjekt benennt den Gegenstand, das Prädikat die Beziehung oder Eigenschaft und das Objekt den konkreten Wert. Ein guter Claim lässt sich ohne den restlichen Seitenabsatz verstehen.
```json
{
"subject": "content-release",
"predicate": "rollback_mechanism",
"object": "switch the active pointer to an immutable revision"
}
```
Die Form ähnelt einem einfachen RDF-Triple, ist aber kein Zwang, die gesamte Fachlichkeit als universellen Graphen zu modellieren. Innerhalb eines Space entsteht ein kontrolliertes Vokabular, das zu dessen Fragen passt. `rollback_mechanism` kann dort sinnvoll sein, wo Releases verglichen werden; in einem HR-Space wäre es ohne Bedeutung.
Zu große Claims verbinden mehrere prüfbare Aussagen. Zu kleine Claims verlieren ihren Sinn. `content-release / uses / pointer` wäre zwar atomar, erklärt aber nicht, wofür der Pointer verwendet wird. Die Formulierung sollte eng genug für einen Widerspruch und vollständig genug für einen Leser sein.
```mermaid
flowchart TD
A["Aussage aus Quelle"] --> Q{"eine fachliche Behauptung?"}
Q -->|mehrere| S["in mehrere Claims teilen"]
Q -->|eine| C{"ohne Absatz verständlich?"}
C -->|nein| E["Objekt präzisieren"]
C -->|ja| V["Zitat und Status ergänzen"]
```
## Das Zitat trägt die Aussage
Jeder Claim verweist über Citations auf eine oder mehrere Quellen. Die Citation enthält einen wörtlichen Ausschnitt und optional einen Locator. Eine Zitatprüfung kann sicherstellen, dass das Zitat wörtlich im archivierten Quelltext vorkommt. Ein Claim, dessen Beleg nur paraphrasiert oder erfunden ist, sollte verworfen werden, bevor er den Review erreicht.
```json
{
"subject": "content-release",
"predicate": "rollback_mechanism",
"object": "switch the active pointer to an immutable revision",
"confidence": 0.94,
"citations": [
{
"source_id": "source_release_docs",
"quote": "Rollback changes the active release pointer to a previous immutable revision.",
"locator": "Rollback"
}
]
}
```
Ein Zitat muss die Aussage in ihrem Geltungsbereich stützen. Wenn die Quelle nur von einer Preview-Umgebung spricht, darf der Claim daraus keine allgemeine Produktionsregel machen. Diese Prüfung kann nicht allein über Zeichenketten erfolgen. Die prüfende Person liest den Kontext.
Mehrere Citations sind nützlich, wenn eine Aussage aus Vertrag und beobachtetem Verhalten gemeinsam gestützt wird. Die API-Dokumentation kann den vorgesehenen Mechanismus beschreiben, ein Produktionsreport seine tatsächliche Nutzung belegen. Viele schwache Quellen machen einen Claim jedoch nicht automatisch stärker.
## Confidence ist keine Wahrheitsskala
`confidence` beschreibt, wie sicher die erzeugende Synthese bei ihrer Zuordnung war. Sie kann der prüfenden Person helfen, unsichere Vorschläge zuerst anzusehen. Sie ist kein Ersatz für Status und keine Wahrscheinlichkeit, dass eine Aussage in der Welt wahr ist.
```ts
type ClaimStatus = "proposed" | "verified" | "disputed" | "deprecated";
type Claim = {
subject: string;
predicate: string;
object: string;
confidence: number;
status: ClaimStatus;
};
```
Ein Claim mit `confidence: 0.99` bleibt vor der Freigabe `proposed`. Ein freigegebener Claim mit `confidence: 0.78` kann `verified` sein, weil ein Mensch Quelle und Formulierung geprüft hat. Später kann ein neuer Beleg ihn `disputed` machen, ohne den alten Confidence-Wert umzudeuten.
Diese Trennung verhindert eine bequeme Abkürzung. Eine Grenze wie „ab 0.9 automatisch freigeben“ würde Modellselbstsicherheit mit fachlicher Verbindlichkeit verwechseln. Sinnvoller ist es, aus jeder Wissensänderung einen Änderungsvorschlag zu machen, unabhängig vom Wert in `confidence`. Er wird erst nach menschlicher Freigabe übernommen.
## Status bildet den Lifecycle ab
`proposed` ist Staging und für normale Leser unsichtbar. `verified` bezeichnet eine freigegebene Aussage. `disputed` macht einen nachvollziehbaren Konflikt sichtbar. `deprecated` hält eine überholte Aussage in der Geschichte, ohne sie als aktuellen Stand zu behandeln.
Der Lifecycle erlaubt präzisere Antworten als Löschen. Wenn ein Dienst bis Version 2 einen statischen Retry-Wert verwendete und seit Version 3 ein Budget teilt, sind beide Aussagen historisch relevant. Die alte wird nicht aus allen Revisionen entfernt. Sie erhält einen Status und bleibt mit ihrer Quelle verbunden.
```mermaid
stateDiagram-v2
[*] --> proposed
proposed --> verified: human approval
proposed --> [*]: rejection
verified --> disputed: conflicting evidence
disputed --> verified: conflict resolved
verified --> deprecated: superseded
disputed --> deprecated: superseded
```
Der Übergang von `proposed` zu `verified` geschieht nicht automatisch, sondern erst nach einer menschlichen Entscheidung. Der sichtbare Seitentext kann den aktuellen Stand anschließend flüssig erklären. Die Claims darunter bewahren, welche Einzelaussagen diese Erklärung tragen und welche Konflikte noch offen sind.
## Funktionale Prädikate machen Konflikte exakt
Manche Beziehungen dürfen gleichzeitig mehrere Objekte haben. Ein System kann mehrere Exportformate unterstützen. `supports_format=markdown` widerspricht `supports_format=okf` nicht. Andere Beziehungen sollen für ein Subjekt nur einen aktuellen Wert besitzen, etwa `primary_database`.
Ein Space kann solche funktionalen Prädikate deklarieren. Treffen dort zwei unterschiedliche Objekte für dasselbe Subjekt und Prädikat aufeinander, kann die Wissensbasis beide Claims als `disputed` markieren und über `contradicts` verbinden.
```json
{
"settings": {
"functional_predicates": [
"primary_database",
"current_owner",
"default_retention_days"
]
}
}
```
Diese Regel bleibt deterministisch. Ein Modell muss nicht entscheiden, ob zwei frei formulierte Absätze semantisch kollidieren. Das kontrollierte Prädikat benennt vorher, wo genau ein einzelner aktueller Wert erwartet wird.
Zu viele funktionale Prädikate wären schädlich. `supports_format` als funktional zu markieren würde ergänzende Fakten fälschlich in Konflikt setzen. Das Vokabular ist deshalb eine fachliche Entscheidung des Space und gehört ins Review.
## Einen Absatz in Claims zerlegen
Ein praktisches Beispiel zeigt die Größenentscheidung. Angenommen, eine Quelle sagt: „The service runs as a single binary, migrates PostgreSQL on startup, and exposes health and readiness endpoints.“ Daraus sollte kein Claim mit dem Objekt `single binary with migrations and probes` entstehen. Drei Eigenschaften ändern sich unabhängig voneinander.
```json
[
{
"subject": "service-runtime",
"predicate": "distribution",
"object": "single self-contained binary"
},
{
"subject": "service-runtime",
"predicate": "database_migration",
"object": "runs automatically on startup"
},
{
"subject": "service-runtime",
"predicate": "exposes_probe",
"object": "/health and /ready"
}
]
```
Wenn später ein Sidecar hinzukommt, betrifft das den Distribution-Claim. Die Migration und die Probes können unverändert bleiben. Eine prüfende Person sieht genau den kleinen Diff. Ein Agent kann weiterhin die beiden bestätigten Aussagen verwenden, während die erste geprüft wird.
Die Gegenprobe hilft: Würde eine Änderung des Objekts automatisch die anderen Teile der Aussage ändern? Falls nein, sind mehrere Claims angemessen. Würde ein Claim ohne Nachbarsatz missverständlich, braucht er ein genaueres Subjekt oder Objekt.
Auch Zeit und Geltungsbereich gehören in die Formulierung. `uses PostgreSQL` passt zu einer aktuellen Architektur, wenn die Quelle den gesamten Dienst beschreibt. Bezieht sie sich nur auf die Produktionsbereitstellung, sollte das Subjekt `service-production-deployment` lauten. Präzision entsteht oft besser über ein engeres Subjekt als über einen langen Objekttext.
Ein Claim ist kein vollständiger Satz für die Blogprosa. Er darf maschinenlesbar und knapp bleiben. Die Konzept-Seite erklärt anschließend, wie die drei Eigenschaften zusammenwirken.
## Ein Konzept ist mehr als seine Claims
Claims allein ergeben keine gut lesbare Erklärung. Ein Konzept besitzt weiterhin Titel, Zusammenfassung, Markdown und Beziehungen zu anderen Konzepten. Die Seite kann ein Beispiel, Einschränkungen und den historischen Zusammenhang erklären.
Die Claims erfüllen eine andere Aufgabe. Sie erlauben:
- eine einzelne Aussage bis zum Originalzitat zurückzuverfolgen;
- einen Widerspruch ohne Ablehnung der ganzen Seite zu markieren;
- bei einer neuen Revision nur die tatsächlich veränderten Behauptungen zu prüfen;
- Suchtreffer und Agentenantworten auf sichtbare, freigegebene Einheiten zu begrenzen.
Seitentext und strukturierte Ebene sollten gemeinsam revisioniert werden. Ein Vorschlag darf nicht bereits neuen Text zeigen, während seine Claims für Leser unsichtbar oder unvollständig sind. Die atomare Freigabe macht die neue Revision als Einheit aktuell.
## Beziehungen verbinden, Claims belegen
Neben Claims kann eine Wissensbasis gerichtete Beziehungen zwischen Konzepten kennen: `related`, `part_of`, `depends_on`, `contradicts` und `supersedes`. Eine Relation beantwortet, wie zwei Seiten zusammenhängen. Sie ersetzt keinen Claim und keine Citation.
```json
{
"from_slug": "content-release",
"kind": "depends_on",
"to_slug": "immutable-revision"
}
```
Die Relation macht Navigation und Kontext möglich. Der belegte Sachverhalt bleibt als Claim auf einer der Seiten. Sonst würde ein bloßer Link eine fachliche Aussage tragen, ohne ihren Wortlaut oder ihre Quelle zu nennen.
`contradicts` kann als Folge der funktionalen Prädikatlogik entstehen. `supersedes` eignet sich für eine nachvollziehbare Ablösung, bei der der neue Begriff oder die neue Regel den alten Stand ersetzt. Beziehungen selbst werden mit der Konzept-Revision geprüft und veröffentlicht.
## Revisionen beantworten die Zeitfrage
Ein aktueller Claim erklärt nicht allein, wann er eingeführt wurde. Eine Konzept-History sollte freigegebene, abgelehnte und vorgeschlagene Revisionen mit ihrer Herkunft führen: Welches Modell und welche Prompt-Version haben den Vorschlag erzeugt, welche Quellen wurden verwendet und welche Person hat freigegeben.
Diese Angaben machen ein Modell nicht zum Autor im rechtlichen oder fachlichen Sinn. Sie dokumentieren, welcher technische Syntheseweg den Vorschlag erzeugte. Prüfende Person, Notiz und Zeitstempel erklären die menschliche Entscheidung. Freigabe, Status und Revision zusammen machen sichtbar, wie eine Aussage in den gültigen Wissensstand gelangt ist – und wie sie ihn wieder verlassen kann.
Die History erlaubt eine zeitbezogene Frage: Welche Aussage war im März sichtbar, bevor die Retention-Regel geändert wurde? Ein Wissensdienst, der immer nur den aktuellen Absatz zurückgibt, kann sie nicht zuverlässig beantworten. Revisionen erhalten den damaligen Stand, ohne alte Claims als heute gültig auszugeben.
Für Teams wird diese Spur besonders nach Modell- oder Promptwechseln nützlich. Wenn eine neue Syntheseversion auffällig andere Claims vorschlägt, lassen sich betroffene Revisionen identifizieren und gezielt prüfen. Damit lässt sich neben der Quelle auch nachvollziehen, welches Modell und welche Prompt-Version den Vorschlag erzeugt haben.
## Ein Schritt über „Sauberes Grounding II“ hinaus
[Sauberes Grounding II](https://www.mikebild.dev/de/blog/sauberes-grounding-antworten-erden/) sortierte Grounding in Konventionen, Dokumente und API-Beschreibungen. Die zentrale Frage lautete, welches Material für eine konkrete Aufgabe in den knappen Kontext gehört und wie teuer seine Wiederbeschaffung wäre. Das war ein Arbeitsmodell für einzelne Sessions.
Hinzu kommt eine kleinere, dauerhafte Einheit zwischen Dokument und Kontext: der Claim. Ein Agent muss nicht jedes Mal eine ganze Seite als gleichmäßig verbindlich behandeln. Er kann die aktuelle Konzept-Revision lesen, sichtbare Claims samt Status prüfen und bei Bedarf ihre Citations öffnen. Aus „passendes Dokument in den Kontext“ wird „passende, freigegebene Aussage mit Rückweg zur Quelle“.
Der ältere Artikel [Fuzzy Matching mit expliziten Grenzen](https://www.mikebild.dev/de/blog/fuzzy-matching-mit-grenzen/) trennte eine Behauptung mit Confidence von einem Fakt. Dieselbe Vorsicht gilt hier. Confidence hilft beim Sortieren eines Vorschlags. Erst Beleg, Review und Status bestimmen, wie die Aussage in der Wissensbasis erscheint.
## Claims im Review prüfen
Bei einem neuen Vorschlag genügen vier Fragen. Behauptet der Claim genau eine Sache? Ist er ohne den umgebenden Absatz verständlich? Trägt das Zitat genau diesen Geltungsbereich? Würde ein abweichender neuer Wert als klarer Widerspruch erkennbar?
Wenn eine Antwort nein lautet, wird der Claim geteilt, enger formuliert oder abgelehnt. Das ist keine formale Wortübung. Kleine Claims senken später den Aufwand. Eine geänderte Retention-Regel erfordert dann keine komplette Neufassung der Seite über Storage. Nur die betroffene Aussage und ihre Erklärung werden angepasst.
Strukturiert werden nur Behauptungen, die für Suche, Review, Konflikte oder Herkunft relevant sind. Es geht nicht darum, jeden Satz als universelle Ontologie abzubilden. Alles andere bleibt Prosa; dafür entsteht kein Claim.
## Weiterführende Quellen
- [W3C RDF 1.1 Concepts](https://www.w3.org/TR/rdf11-concepts/)
- [W3C PROV-O](https://www.w3.org/TR/prov-o/)
- [Sauberes Grounding II](https://www.mikebild.dev/de/blog/sauberes-grounding-antworten-erden/)
- [Fuzzy Matching mit expliziten Grenzen](https://www.mikebild.dev/de/blog/fuzzy-matching-mit-grenzen/)
---
# Produkte berichten über ihre API
URL: https://www.mikebild.dev/de/blog/produkte-berichten-ueber-ihre-api/
Datum: 2026-07-19
Eine Statistik-API ist eine Produktfunktion. Dieser Satz klingt selbstverständlich, wurde in der Arbeit an einem produktübergreifenden Reporting aber erst nach zwei schlechteren Entwürfen klar. Zunächst sollte ein zentraler Sammler direkt auf mehrere PostgreSQL-Datenbanken zugreifen. Danach standen besondere private Reporting-Endpoints und eigene Schlüssel im Raum. Beides hätte den Report tiefer in die Produkte eingebaut, als es für seinen Zweck nötig ist.
Übrig blieb ein kleinerer Vertrag. Ein Publishing-System, eine Wissensbasis und ein Orchestrator verdichten ihre eigenen Daten selbst und bieten ihre Sicht über normale, authentifizierte HTTP-Endpoints an. Ein nachgelagerter Ablauf führt die Aggregate für ausdrücklich begrenzte Zeitfenster zusammen – er sieht weder Tabellen noch Markdown, Namen, Schlüssel oder interne IDs.
Diese Aufteilung ist kein spezieller Kniff für Dashboards. Jeder autorisierte Verbraucher kann dieselben Statistikressourcen verwenden: ein Kapazitätsreport, eine Qualitätsprüfung, eine lokale Auswertung oder ein späteres Exportwerkzeug.
## Datenbesitz ist mehr als Speicherort
Wer eine Tabelle besitzt, kennt ihre Bedeutung. Ein Publishing-System weiß, wann eine Revision erstellt und ein Release tatsächlich aktiviert wurde. Eine Wissensbasis unterscheidet einen gestarteten Ingest von einem geprüften Wissensstand. Ein Orchestrator verdichtet seine Ausführungsdaten dort, wo die Läufe tatsächlich stattfinden. Ein zentraler Sammler müsste diese Bedeutungen nachbauen und bei jeder Produktänderung mitziehen.
Direktes SQL macht diesen Nachbau besonders leicht – und damit gefährlich. Eine Query funktioniert, obwohl sie vielleicht einen Zwischenstatus mitzählt, den das Produkt selbst niemals als abgeschlossen anzeigen würde. Eine neue Migration kann den Report brechen, ohne dass sich die öffentliche Produkt-API geändert hat. Der Datenbankzugriff umgeht außerdem die normale Rechteprüfung und zieht Credentials mehrerer Systeme an eine Stelle.
Mit einer Produkt-API liegt die fachliche Verdichtung dort, wo auch die Zustandsänderung implementiert ist:
:::process{title="Fachliche Verdichtung bleibt im Produkt" role="primary" preferredPattern="connected-process"}
1. Produktaktion · erzeugt einen fachlich definierten Zustandsübergang
2. Eigener Datenspeicher · bewahrt den fachlich maßgeblichen Zustand des Produkts
3. Aggregation · übersetzt interne Zustände in begrenzte fachliche Kennzahlen
4. Statistik-API · liefert authentifizierte Werte mit Zeitraum und Bedeutung
5. Collector · führt kompatible Antworten zusammen, ohne sie neu zu definieren
6. Report · erklärt den eingefrorenen gemeinsamen Stand
:::
Der Sammler darf die Antworten zusammenführen, aber nicht neu deuten, was ein erfolgreicher Release oder ein verifizierter Claim ist. Diese Begriffe gehören dem Produkt.
## Einheitlich ist die Zeit, nicht die Fachlichkeit
Ein gemeinsamer Vertrag bedeutet nicht, dass alle Produkte dieselben Kennzahlen liefern. Das wäre künstliche Gleichmacherei. Gemeinsam sind nur die Eigenschaften, die ein Collector für zuverlässige Zeitfenster benötigt:
- `bucket` bestimmt die Auflösung: Stunde, Tag, Monat oder Jahr.
- `from` ist der eingeschlossene Anfang des Fensters.
- `to` ist das ausgeschlossene Ende.
- `tz` macht die Zeitzone ausdrücklich, hier durchgehend UTC.
- `buckets` enthält eine dichte Reihe einschließlich leerer Intervalle.
- `totals` fasst genau das angefragte Fenster zusammen.
Die Nutzlast bleibt fachlich benannt. Ein Publishing-System kann etwa auf eine Site begrenzte Aggregate für Releases, Inhalte und Leserzugriffe bereitstellen, eine Wissensbasis auf einen Space begrenzte Aggregate für Nutzung, Abdeckung und Reviews, ein Orchestrator auf einen Tenant begrenzte Laufzeitstatistiken für Ausführungen und Connectoren. Kein Produkt muss die Begriffe eines anderen Produkts übernehmen; alle müssen denselben Zeitvertrag erfüllen.
```json
{
"bucket": "hour",
"tz": "UTC",
"from": "2026-07-18T10:00:00.000Z",
"to": "2026-07-18T12:00:00.000Z",
"buckets": [
{ "ts": "2026-07-18T10:00:00.000Z", "items_created": 2 },
{ "ts": "2026-07-18T11:00:00.000Z", "items_created": 0 }
],
"totals": { "items_created": 2 }
}
```
Die halboffene Schreibweise `[from,to)` verhindert Doppelzählungen. Das Fenster von 10 bis 11 Uhr enthält ein Event um 10:59:59, aber keines um 11:00:00. Das nächste Fenster beginnt genau dort. Ein Retry fragt dasselbe Zeitfenster erneut ab und erhält dieselbe Bedeutung.
## Gemessene Null, fehlende Beobachtung, unvollständiges Fenster
Eine dichte Zeitreihe enthält auch leere Buckets. Das ist praktisch, weil der Collector keine fehlenden Stunden erraten oder auffüllen muss. Eine Null ist dabei ein gemessener Wert: Das Produkt hat das Fenster ausgewertet und kein entsprechendes Event gefunden.
Davon zu unterscheiden sind zwei andere Zustände. Fehlend bedeutet, dass für die Kennzahl keine Beobachtung vorliegt – etwa weil eine Quelle nicht angeschlossen ist oder eine Quote ohne Grundmenge nicht berechnet werden kann. Im hier beschriebenen Reporting-Ablauf bestimmt der nachgelagerte Report außerdem die Unvollständigkeit: Ein erwarteter Snapshot fehlt, oder das Fenster war zum Zeitpunkt der Erfassung noch nicht abgeschlossen. Diese drei Fälle dürfen im Report nicht gleich aussehen, denn sie tragen verschiedene Konsequenzen: Null technische Fehler sind beruhigend, null Seitenaufrufe können stimmen, ein fehlender Analytics-Anschluss ist eine offene Verbindung und keine Messung.
Ein Produkt kann die Unterscheidung zwischen gemessen und fehlend zum Teil der Antwort machen und Messwerte etwa mit `value_state` und `value_kind` kennzeichnen. Eine Quote ohne Beobachtungen trägt den Zustand `missing` und wird nicht als gemessene Null ausgegeben:
```json
{
"metric": "engagement_rate",
"value_kind": "ratio",
"value_state": "missing"
}
```
Für jemanden, der einen Report liest, ist dieser Zustand wichtiger als eine weitere Nachkommastelle. Zeitfenster, Datenzustand und Messbedeutung gehören deshalb in den Vertrag selbst – nicht in eine Fußnote der Reportseite.
## Datenschutz beginnt bei der Antwortform
Aggregate sollten Informationen weglassen, die der Zweck nicht benötigt. Eine Statistik kann erfolgreiche, fehlgeschlagene und rate-limitierte Leserzugriffe zählen, ohne dafür Benutzernamen, IP-Adresse, Session-ID, Markdown-Inhalte, URLs, Job-IDs oder Credentials in der Statistikstabelle zu speichern. Eine Wissensbasis muss über ihre Statistikressourcen keine Quellentexte ausgeben.
Eine solche Negativliste gehört in die Dokumentation und in Vertragstests. „Wir geben aktuell keine Namen zurück“ ist schwächer als ein Schema, in dem es für Namen gar kein Feld gibt. Der Collector kann dann keinen sensiblen Wert versehentlich in ein JSON-Artefakt oder eine Reportseite übernehmen.
Auch Trace-Daten bleiben auf ihren Zweck begrenzt. W3C Trace Context standardisiert `traceparent` und `tracestate`, damit ein Aufruf über mehrere Dienste korreliert werden kann. Die W3C-Empfehlung warnt ausdrücklich davor, personenbezogene oder andere sensible Informationen in diesen Headern zu transportieren. Eine Trace-ID verbindet technische Schritte; sie beschreibt keinen Menschen.
```http
GET /v1/sites/example/stats/releases?bucket=hour&from=2026-07-18T10:00:00Z&to=2026-07-18T11:00:00Z
Authorization: Bearer
traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
```
## Zero-config heißt: vorhandene Begriffe verwenden
Vollständig konfigurationslos ist Telemetrie selten. Ein Dienst braucht zumindest eine dauerhafte Ablage und eine Information darüber, ob er in Entwicklung, Test oder Produktion läuft. „Zero-config“ ist hier enger gemeint: Für den Reporting-Ablauf wird im Produkt kein Sondermodus aktiviert, kein besonderer Schlüssel erzeugt und kein Reportziel eingetragen.
Die Statistik-Endpoints können vorhandene Produktgrenzen verwenden: ein Publishing-System etwa die Site und einen normalen Lese-Key, eine Wissensbasis den Space und ihren Lese-Scope, ein Orchestrator den Mandanten.
OpenTelemetry liefert dafür ein brauchbares gemeinsames Vokabular. `service.name` benennt den logischen Dienst, `deployment.environment.name` unterscheidet `development`, `staging`, `production` und `test`; Stand August 2026 ist der ältere Schlüssel `deployment.environment` in den OpenTelemetry-Konventionen als veraltet markiert. Solche standardisierten Felder verhindern, dass ein Dienst `prod`, ein anderer `live` und ein dritter `production-eu` als dasselbe Konzept behandelt. Das Produkt setzt diese Werte einmal für seine Laufzeit; der Reporting-Collector muss keine Etiketten reparieren.
Die gemeinsame Bezeichnung allein genügt allerdings nicht. Liest ein Aggregator andere Feldnamen, als ein älterer Schreibpfad noch liefert, können erfolgreiche Aufrufe als Fehler erscheinen. Ein solcher Übergang lässt sich in beide Richtungen kompatibel machen: Der Leser versteht alte und neue Felder, der Schreiber liefert vorerst beide, und Tests verwenden echte Auditzeilen statt handgebauter Idealobjekte.
## Begrenzte Queries statt versteckter Last
Eine allgemeine Statistik-API braucht harte Grenzen, etwa eine maximale Fensterlänge je Auflösung. Ungültige oder zu große Fenster liefern `422`, statt die Produktdatenbank mit einer unerwarteten Vollauswertung zu belasten.
Diese Grenzen gehören zum Produktvertrag, weil nur das Produkt seine Kosten kennt. Ein Collector sollte nicht versuchen, sie mit vielen überlappenden Queries zu umgehen. Für einen langen Zeitraum verwendet er die gröbere Auflösung oder arbeitet in eindeutigen, nicht überlappenden Seiten.
Dasselbe gilt für Aufbewahrung. Anonyme Rohereignisse können im Produkt eine eigene Aufbewahrungsfrist haben. Ein Reportartefakt kann länger bestehen, wenn sein verdichteter Inhalt dafür vorgesehen ist. Rohereignis, Produktaggregat und veröffentlichter Report haben verschiedene Lifecycles; sie müssen nicht in einem Speicher enden.
## Bestehende Schlüssel statt einer Hintertür
Ein eigener „Reporting-Key“ wirkt zunächst ordentlich, schafft aber eine zweite Sicherheitslogik. Was darf dieser Schlüssel lesen? Gilt er für eine Site, einen Space oder das ganze Produkt? Wer rotiert ihn? Sobald jedes Produkt darauf eine andere Antwort gibt, wird aus dem vermeintlich einfachen Collector ein Sonderfall mit weitreichenden Rechten.
Die Statistik-APIs sollten deshalb vorhandene Scopes verwenden. Ein reiner Lese-Key einer Site darf dann genau die Statistiken der Site lesen, für die er ausgestellt wurde. Ein Lese-Key der Wissensbasis bleibt auf seinen Space begrenzt. Ohne passenden Schlüssel bleibt jeder dieser Endpoints geschlossen.
Für den Collector gilt damit dieselbe Regel wie für andere API-Nutzer: pro Produkt ein eigener, möglichst enger Schlüssel; Secrets ausschließlich in der Credential-Ablage; keine Schlüssel in Workflowdefinition, JSON-Artefakt, Log oder Report. Der Workflow kennt nur eine `credential_ref`; der tatsächliche Wert wird beim HTTP-Aufruf eingesetzt und erscheint weder im gespeicherten Ablauf noch in dessen Ergebnis. Diese Trennung lässt sich testen: Ein Aufruf ohne Schlüssel muss `401` liefern, ein Schlüssel ohne passenden Scope `403`, ein korrekter Schlüssel `200`.
## PostgreSQL ist intern, nicht verboten
Die Ablehnung direkter Datenbankabfragen bedeutet nicht, dass Aggregate außerhalb der Produktdatenbank liegen müssen. Für ein Publishing-System oder eine Wissensbasis kann PostgreSQL gerade der passende Ort sein. Event und fachlicher Zustand lassen sich dort transaktional erfassen, nach Site oder Space begrenzen und mit denselben Migrationen weiterentwickeln wie der Rest des Produkts.
Wichtig ist die Richtung der Abhängigkeit. Das Produkt darf seine eigene Datenbank kennen. Ein fremder Collector darf sie nicht kennen müssen. Ob eine Antwort aus einer vorberechneten Tabelle, einer begrenzten SQL-Aggregation oder einem Cache entsteht, bleibt eine interne Entscheidung. Entscheidend ist, dass jedes Produkt seine interne Ablage nach dem eigenen Betriebsmodell gestalten kann und nach außen denselben verlässlichen Zeitvertrag erfüllt.
## Dokumentation gehört zum Vertrag
Ein neuer Endpoint ist erst fertig, wenn OpenAPI, `llms.txt`, `llms-full.txt`, README und die ausführliche Produktdokumentation dasselbe erzählen. Sonst findet ein Mensch einen Scope in der README, ein Client generiert aus einer älteren OpenAPI-Datei und ein Agent liest eine dritte Variante.
Darum prüfen die Repositories ihre generierten Dokumente auf Drift. Vertragstests schicken gültige, ungültige, zu große und nicht autorisierte Fenster an die Handler. Integrationstests verwenden die echte Produktablage. Ein Binärtest stellt sicher, dass die ausgelieferte Datei dieselben Routen und dieselbe Versionsnummer enthält wie der Quellstand. Diese Prüfungen verhindern, dass der Collector von einer veralteten oder nur intern bekannten Antwortform abhängt.
## APIs machen Austausch möglich
Der unmittelbare Effekt dieser Trennung zeigt sich beim Testen. Jede Produkt-API lässt sich mit einem festen Fenster gegen ihr eigenes Schema prüfen. Der Collector erhält Fixtures ohne Zugriff auf die Datenbank. Ein Produktrelease lässt sich auf API-Ebene unabhängig zurückrollen, solange der veröffentlichte Vertrag erhalten bleibt.
Ein neuer Verbraucher braucht keine neue Tabelle im Produkt. Ein anderes Reporting-Werkzeug kann dieselbe API ebenso aufrufen. Ein Produkt darf seine interne Ablage ändern, ohne dass die Statistikressource neu erfunden wird.
Das hält auch die Produkte verständlich. Jedes Produkt behält seine Rolle – als Publishing-System, Wissensbasis oder Orchestrator. Ihre Statistikressourcen beschreiben die eigene Arbeit als begrenzte, fachlich benannte Aggregate. Alles Weitere geschieht außerhalb ihrer Grenzen. Solange der veröffentlichte Vertrag erhalten bleibt, kann ein Teil ersetzt werden, ohne die anderen anzupassen.
## Was sich seit damals geändert hat
Der Beitrag [HTTP-APIs: klein, stabil, lesbar](https://www.mikebild.dev/de/blog/http-apis-klein-stabil-lesbar/) formulierte 2014 einen Endpoint als langfristiges Versprechen an unbekannte Clients. Kleine Ressourcen, eindeutige Zeitstempel, stabile Bedeutungen und lesbare Fehler sollten verhindern, dass jeder Client eine eigene Abwehrschicht baut. Diese Anforderungen gelten weiterhin.
Neu ist der Blick auf interne Produktstatistiken. Ein Statistikpfad wird nicht für ein bestimmtes Dashboard gebaut, sondern als begrenzte Projection der eigenen Produktdaten. Er verwendet bestehende Schlüssel und Scopes, liefert Zeitgrenzen und Datenzustand mit und veröffentlicht nur Aggregate. Damit bleibt die API klein, unabhängig davon, ob ein Mensch, ein Workflow oder ein Agent sie aufruft.
## Weiterführende Quellen
- [W3C Trace Context](https://www.w3.org/TR/trace-context/)
- [OpenTelemetry Service Semantic Conventions](https://opentelemetry.io/docs/specs/semconv/resource/service/)
- [OpenTelemetry Deployment Attributes](https://opentelemetry.io/docs/specs/semconv/registry/attributes/deployment/)
- [HTTP-APIs: klein, stabil, lesbar](https://www.mikebild.dev/de/blog/http-apis-klein-stabil-lesbar/)
---
# Vom Organigramm zur Produktverantwortung
URL: https://www.mikebild.dev/de/blog/vom-organigramm-zum-arbeitsfluss/
Datum: 2026-07-18
Ein KI-Assistent erzeugt einen Entwurf – und danach wartet der Vorgang auf Freigabe, Review und Release wie zuvor. Wer trägt ihn vom beobachteten Kundenproblem bis zur messbaren Wirkung? Diese Frage beantwortet keine noch so schnelle Entwurfserzeugung. KI kann den Arbeitsfluss vom ersten Kundensignal über Plan und Umsetzung bis zu Review und Wirkung durchgängiger machen – wenn die Verantwortung für Problem, Entscheidung, Prüfung und Wirkung an einer Stelle zusammengeführt wird.
KI beseitigt Organisationsgrenzen nicht automatisch. Sie senkt die Kosten, sich in den nächsten Schritt einzuarbeiten. Ob daraus ein zusammenhängender Vorgang wird oder nur ein schnellerer Zulauf auf dieselben Wartepunkte, entscheidet die Organisation, nicht das Modell.
## Der Arbeitsfluss vom Kundenproblem bis zur Wirkung
Mit Arbeitsfluss meine ich hier eine konkrete Kette: Ein Kundensignal wird beobachtet, daraus entsteht eine Hypothese, aus der Hypothese ein Plan, aus dem Plan eine Umsetzung, aus der Umsetzung ein Review mit fachlicher Abnahme, danach ein Release und schließlich eine beobachtbare Wirkung, die wieder als Signal in den nächsten Durchlauf einfließt.
```mermaid
flowchart LR
S[Kundensignal] --> H[Hypothese und Plan]
H --> E[Entwurf und Umsetzung]
E --> Q[Review und Abnahme]
Q --> R[Release]
R --> W[Wirkung beobachten]
W --> S
A[KI: Kontext, Varianten, Tests und Dokumentation] --> H
A --> E
A --> Q
```
Die Ausgangshypothese lautet, dass diese Kette in arbeitsteiligen Organisationen selten durchgängig ist: Ein Ticket beschreibt den Wunsch, ein anderer Mensch entscheidet über das Design, ein dritter baut die Schnittstelle, ein vierter prüft den Release. Jede Rolle kann ihre Aufgabe sehr gut erledigen, während das Ergebnis für den Kunden trotzdem unvollständig bleibt. Wer nur einen kleinen Ausschnitt sieht, kann kaum beurteilen, ob eine neue Funktion das Kundenproblem löst oder lediglich einen Teilprozess sauberer macht.
KI verändert an dieser Kette vor allem einen Kostenfaktor: das Einarbeiten in den jeweils nächsten Schritt. Ein Assistent kann einen unbekannten Service erklären, vorhandene Entscheidungen zusammentragen, einen Datenfluss skizzieren und passende Tests vorschlagen. Er ersetzt dabei kein Fachwissen. Er senkt die Hürde, Fachwissen aus anderen Teilen der Organisation rechtzeitig einzubeziehen – bevor eine Entscheidung getroffen ist, nicht nachdem eine fertige Lösung abgeliefert wurde.
## Übergaben verkürzen sich nicht automatisch
Meine These ist: KI kann Übergaben verkürzen, wenn die Verantwortung für Problem, Entscheidung, Prüfung und Wirkung zusammengeführt wird. Das ist eine Hypothese über Organisation, kein nachgewiesenes Gesetz. Bleibt die Verantwortung verteilt wie zuvor, beschleunigt KI lediglich die Produktion von Zwischenständen, die weiterhin auf dieselben Freigaben warten.
Der [Beitrag über schnellere Entwicklung und unveränderte Prozesse](https://www.mikebild.dev/de/blog/ki-im-konzern-schnellere-entwicklung-andere-prozesse/) beschreibt diese Kehrseite: Wenn eine Organisation denselben alten Ablauf nur schneller füllt, verschiebt sich der Stau. Mehr Entwürfe warten auf dieselben Reviewer, und mehr Dokumente widersprechen sich. Der Gewinn entsteht erst, wenn die frei gewordene Zeit in das Verständnis des gesamten Vorgangs fließt.
Zusammengeführte Verantwortung bedeutet dabei nicht, dass ein Mensch gleichzeitig Produktmanager, Designer, Sicherheitsfachmann und Betriebsverantwortlicher sein muss. Gemeint ist, dass ein klar begrenzter Ausschnitt des Produkts von derselben Stelle weiterverfolgt wird: vom beobachteten Problem über eine Hypothese und eine Änderung bis zur Rückmeldung aus der Nutzung. Spezialdisziplinen bleiben unverzichtbar. Der Unterschied liegt im Zeitpunkt: Spezialisten werden früher und gezielter einbezogen, statt am Ende einer langen Kette eine fertige Lösung entgegenzunehmen.
Das Organigramm verschwindet dadurch nicht. Menschen brauchen klare Zuständigkeiten, Entwicklungsperspektiven und Entscheidungen, die nicht zwischen Teams verloren gehen. Aber der durchgängige Arbeitsfluss kann wichtiger werden als die Grenzen zwischen den Kästchen – dort, wo Verantwortung tatsächlich zusammengeführt ist.
## Vertikale Schnitte als überprüfbare Hypothese
Vertikale Arbeitspakete machen diese These überprüfbar. Statt eine Änderung nach technischen Schichten zu zerlegen – zuerst Datenmodell, dann API, dann Oberfläche – wird ein kleiner, nutzbarer Ausschnitt durch alle Schichten geführt. Ein solcher Schnitt hat einen klaren Zweck, eine sichtbare Wirkung und eine überschaubare Zahl offener Entscheidungen.
Bereits ohne generative KI war diese Arbeitsweise sinnvoll. Ein möglicher Hinderungsgrund war der Aufwand, sich in fremde Teile des Systems einzuarbeiten: Ein Entwickler kannte etwa das Frontend, nicht die Regeln im Backend. Das Produktteam kannte die Wirkung für Anwender, nicht die Folgen für Betrieb oder Datenmodell. Also wurden Arbeitspakete entlang von Zuständigkeiten geschnitten und anschließend über viele Meetings wieder zusammengesetzt.
```mermaid
flowchart TD
P[Produktproblem] --> V[Vertikaler Schnitt]
V --> U[Oberfläche]
V --> F[Fachlogik]
V --> D[Daten und Verträge]
V --> B[Betrieb und Beobachtung]
U --> X[Ein überprüfbares Ergebnis]
F --> X
D --> X
B --> X
K[KI: Abhängigkeiten und Vorschläge sichtbar machen] --> V
```
Kleinere vertikale Schnitte sind eine überprüfbare Organisationshypothese, keine pauschale Aussage über jedes Team. Die Hypothese lautet, dass ein Team mit KI-Unterstützung mehr von diesem Zusammenhang selbst erkunden kann – welche Services betroffen sind, welche Verträge sich ändern, welche Testfälle fehlen, welche Dokumentation angepasst werden muss. Ob die Beobachtungen im konkreten Kontext für diese Hypothese sprechen, lässt sich anhand von Wartezeit, Zahl der Übergaben, Nacharbeit und Zeit bis zum Nutzerfeedback prüfen. Die Werte werden mit identischer Definition vor und nach einem begrenzten Piloten erhoben; andere Prozessänderungen müssen festgehalten werden, weil ein solcher Vergleich keine eindeutige Ursache beweist. Fällt die Messung anders aus als erwartet, ist die Hypothese für diesen Kontext zunächst nicht bestätigt, nicht das Team gescheitert.
Ein vertikaler Schnitt darf nicht zum Vorwand werden, jede Spezialdisziplin auf wenige Menschen abzuwälzen. Wo Sicherheit, Regulierung oder tiefe Fachkenntnis nötig sind, bleibt Zusammenarbeit Pflicht. Der Schnitt verändert die Reihenfolge der Beteiligung, nicht ihre Notwendigkeit.
## Technologie wird wieder zur Option
Viele Technologiewahlen entstehen aus dem, was ein Team gerade kennt. Das ist verständlich: Eine unbekannte Plattform verlangt Recherche, kleine Versuche und die Sorge, später allein damit dazustehen. Darum werden Anforderungen gelegentlich an die vorhandenen Werkzeuge angepasst, obwohl ein anderer Weg besser passen könnte.
KI verändert diese Rechnung. Sie kann Dokumentation durchsuchen, Beispiele aus einem Repository erklären, Varianten gegenüberstellen und einen kleinen Prototypen vorbereiten. Aus einer unbekannten Technologie wird dadurch noch keine gute Entscheidung. Aber es wird günstiger, die Entscheidung auf Basis eines echten Versuchs zu treffen statt auf Basis der Gewohnheit.
Eine brauchbare Untersuchung hält dabei mehrere Möglichkeiten offen:
- Was ist die kleinste Änderung, mit der wir etwas über das Kundenproblem lernen?
- Welche vorhandenen Systeme, Daten und Verträge müssen wir wirklich verstehen?
- Welche Annahme übernimmt die KI, und wie lässt sie sich prüfen?
- Welche Wirkung erwarten wir nach dem Release, und woran merken wir das Gegenteil?
Die Antworten müssen nicht immer wie eine Architekturentscheidung dokumentiert werden. Bei einer kleinen Änderung reicht oft ein sauberer Pull Request mit Tests und einer kurzen Begründung. Entscheidend ist, dass die KI nicht bloß mehr Optionen produziert, sondern hilft, Optionen schneller zu bewerten und schlechte Ideen früher zu verwerfen.
## Erstellen wird billiger, Review und Abnahme werden wichtiger
Das sichtbarste Ergebnis von KI ist oft ein Entwurf: Code, ein Test, eine Zusammenfassung, eine API-Beschreibung, ein Release-Hinweis. Der Entwurf kann erstaunlich gut sein. Er kann aber auch eine falsche Voraussetzung mit großer Überzeugung weitertragen. Je günstiger das Erstellen wird, desto stärker wächst deshalb der Wert von Review und fachlicher Abnahme.
Review meint hier mehr als den Pull Request. Es umfasst die fachliche Prüfung einer Anforderung, den Blick auf Widersprüche im vorhandenen Wissen, den Test unter realistischen Bedingungen und die Frage, ob der Release das Produkt verbessert. Qualitätssicherung ist damit kein letztes Tor vor dem Ausrollen. Sie begleitet den gesamten Schnitt.
```yaml
review_focus:
product_question: "Does this solve the observed customer problem?"
domain_question: "Which business rule could make this wrong?"
technical_question: "Which contract or dependency can break?"
quality_signal: "What evidence would change our decision?"
release_check: "Can we observe the result and recover safely?"
```
Dieses Beispiel ist keine neue Checkliste für jede Kleinigkeit. Es zeigt die Verschiebung: Bei KI-gestützten Entwürfen kann sich der Engpass von der Erzeugung zur Prüfung verschieben. Wichtiger wird dann, schnell und zuverlässig zu entscheiden, was von einem Entwurf behalten, geändert oder verworfen werden muss.
Die NBER-Studie „Generative AI at Work“ liefert dazu einen begrenzten empirischen Hinweis. Bei mehr als 5.000 Beschäftigten im Kundensupport erhöhte ein KI-Assistent die Zahl gelöster Fälle pro Stunde im Mittel um 14 Prozent, wobei weniger erfahrene Beschäftigte besonders profitierten. Diesen Befund zu den weniger erfahrenen Beschäftigten lese ich als Hinweis darauf, dass KI bewährte Vorgehensweisen verbreiten kann – das ist meine Interpretation, kein direkter Studienbefund. Ein Beleg für dieselbe Wirkung in jeder Aufgabe oder gar in der Produktentwicklung ist die Studie ohnehin nicht. Für die Produktarbeit bleibt daraus vor allem: Der erste Entwurf wird zugänglicher. Erfahrung entwertet das nicht. Erfahrung wird sichtbarer dort, wo sie zählt – bei der Auswahl einer Richtung, beim Erkennen eines untypischen Falls und beim Urteil über Qualität.
## Verantwortung technisch verankern
Wenn diese These ernst gemeint ist – zusammengeführte Verantwortung für Problem, Entscheidung, Prüfung und Wirkung –, dann muss sie sich auch in den Systemen wiederfinden, durch die Arbeit fließt. Sonst bleibt sie ein Vorsatz. Zwei Beispiele zeigen, wie eine solche Verankerung aussehen kann.
Eine Auftragssteuerung kann HTTP, MCP, A2A, Webhooks und Chat in denselben Planungspfad führen und Ausführung an explizite Auftragsautorität, Budgets, Verträge, Evidenz und Review binden. Das ist die technische Form dieser Verantwortungsbündelung: Egal über welchen Kanal ein Auftrag eintrifft, er läuft durch dieselbe Planung, und die Ausführung ist an explizite Autorität gebunden.
Eine Workflow-Engine kann wiederkehrende Arbeit über mehrere Systeme als genehmigten, protokollierten Workflow modellieren und Schritte mit Außenwirkung bis zur Bestätigung zurückhalten. Auch hier trennt das Design Vorbereitung und Ausführung von der bestätigten Außenwirkung: Ein Vorgang darf vorbereitet, geprüft und wiederholt werden, aber der Schritt, der nach außen wirkt, wartet auf die Abnahme.
Die Übertragung auf die Organisation ist eine Hypothese, keine Garantie. Wenn Wissen auffindbar ist, wenn Releases so vorbereitet sind, dass ein Team eine Änderung kontrolliert bis zur Wirkung verfolgen kann, und wenn Produkt- und Serviceinformationen aus denselben geprüften Quellen entstehen statt in getrennten Kopien zu altern – dann kann ein Vorgang mehr Lücken auf einmal schließen: Eine Produktänderung liefert zugleich Testfälle, Betriebsinformationen und einen Entwurf für die Kundendokumentation. Wiederkehrende Supportfragen zeigen früh, welche Produktregel oder Erklärung fehlt. Fehler und Rückfragen fließen zurück in Regeln, Tests und spätere Arbeitspakete. Ob diese Bedingungen erfüllt sind, muss jede Organisation an ihrem eigenen Arbeitsfluss prüfen.
## Ein vollständiger Schnitt als Test
Die Veränderung beginnt nicht mit einem neuen Organigramm. Sie beginnt mit einem echten, begrenzten Produktproblem. Ein Team nimmt einen Vorgang, der heute mehrere Übergaben hat, und führt ihn einmal vollständig durch: Kundenfrage verstehen, Annahme prüfen, Änderung bauen, Qualität bewerten, veröffentlichen und die Wirkung ansehen.
```yaml
vertical_slice:
customer_problem: "Describe the observed problem"
smallest_change: "Deliver one useful outcome"
ai_support:
- "Find relevant context"
- "Prepare tests and documentation"
human_review:
- "Validate domain assumptions"
- "Accept quality and release risk"
outcome_signal: "Measure customer use and failures"
```
Danach ist die Diskussion über Rollen und Struktur konkreter. Vielleicht zeigt sich, dass ein Team eine Schnittstelle selbst verantworten kann. Möglicherweise fehlt eine gemeinsame Wissensquelle. Oder ein Spezialist bleibt dauerhaft Teil des Ablaufs. Entscheidend ist, dass die Organisation aus beobachteter Arbeit lernt und nicht aus einem abstrakten Umbauplan – und dass sie die Hypothese verwirft, wo die Messung dagegen spricht.
KI macht vollständige Produktentwicklung nicht einfach. Sie macht sie dort öfter möglich, wo Verantwortung, Review und Wirkung zusammengehören und nicht über viele Stationen verteilt sind. Recherche, Entwurf, Tests, Dokumentation und Release-Vorbereitung rücken näher zusammen. Das Organigramm bleibt. Aber die Entscheidung, die jede Organisation jetzt treffen kann, ist konkret: einen ausgewählten, begrenzten Arbeitsfluss einmal durchgängig verantworten und an seiner Wirkung messen, ob die Hypothese trägt.
## Weiterführende Quellen
- [NBER: Generative AI at Work](https://www.nber.org/papers/w31161)
- [KI im Enterprise-Umfeld: Schnellere Entwicklung braucht andere Prozesse](https://www.mikebild.dev/de/blog/ki-im-konzern-schnellere-entwicklung-andere-prozesse/)
---
# llms.txt: Doku für Maschinen
URL: https://www.mikebild.dev/de/blog/llms-txt-und-llms-full-txt/
Datum: 2026-07-15
`llms.txt` liegt im Wurzelverzeichnis einer Website und sieht damit aus wie das nächste Signal für Suchmaschinen – ein Nachbar von `robots.txt` und `sitemap.xml`, angelegt in der Hoffnung auf Sichtbarkeit. Genau dieser Schluss geht am Zweck vorbei. Die Datei war nie als Ranking-Signal gedacht, und für eine Ranking-Wirkung liegt kein Beleg vor. Ihr Nutzen liegt nicht in Crawler-Signalen, sondern darin, Agenten kuratierten Dokumentationskontext bereitzustellen.
Es gibt zwei Dateien, `llms.txt` und `llms-full.txt`. Sie sehen nach Marketing-Infrastruktur aus, und ihr Nutzen liegt an einer anderen Stelle: bei der Frage, wie ein Modell an sauberen, kuratierten Kontext kommt, ohne sich vorher durch Navigationsleisten, Cookie-Banner und JavaScript zu arbeiten. Beide Dateien sind maschinenlesbare Selbstdokumentation eines Produkts.
## Zwei Dateien, ein Problem
Den Vorschlag hat Jeremy Howard, Mitgründer von Answer.AI, am 3. September 2024 veröffentlicht; die Beschreibung steht unter `llmstxt.org`. Der Ausgangspunkt ist eine nüchterne Beobachtung: Modelle stützen sich zunehmend auf Webinhalte, aber ihr Kontextfenster ist zu klein, um eine ganze Website am Stück aufzunehmen. Und rohes HTML in brauchbaren Text zu verwandeln, ist mühsam und ungenau – zwischen dem eigentlichen Inhalt steckt jede Menge Beiwerk, das nur Platz frisst.
Die Antwort besteht aus zwei Bausteinen, die man sauber auseinanderhalten sollte.
`llms.txt` liegt im Wurzelverzeichnis einer Site und ist ein kuratierter Index in Markdown. Das Format ist bewusst eng: eine H1-Überschrift mit dem Projektnamen, darunter ein Zitatblock mit einer kurzen Zusammenfassung, optional ein paar Sätze Kontext, danach H2-Abschnitte mit Linklisten. Jeder Link trägt eine knappe Beschreibung. Ein eigener Abschnitt `## Optional` markiert, was ein Modell bei knappem Platz zuerst weglassen darf. So kompakt sieht das aus:
```markdown
# Orderflow API
> Orderflow is a REST API for creating, tracking, and refunding orders.
> These docs are written for LLMs and coding agents.
Every write endpoint accepts an `Idempotency-Key` header, so retries stay safe.
## Core Documentation
- [Quick Start](https://docs.example.com/quickstart.md): Authenticate and create your first order
- [API Reference](https://docs.example.com/api.md): Endpoints, parameters, and error codes
- [Webhooks](https://docs.example.com/webhooks.md): Event types and signature verification
## Optional
- [Changelog](https://docs.example.com/changelog.md): Version history and breaking changes
```
`llms-full.txt` ist der zweite Baustein und konzeptionell schlichter: der vollständige Text der wichtigen Seiten, in einer einzigen Markdown-Datei aneinandergehängt. Kein Index mehr, sondern der ganze Inhalt am Stück, ohne HTML-Rauschen. Ein Agent oder Client kann den gebündelten Inhalt mit einer einzigen Anfrage laden, statt sich Seite für Seite durchzuhangeln – ob davon alles zur konkreten Aufgabe passt, ist eine andere Frage.
Ergänzend schlägt Howard vor, einzelne Seiten zusätzlich als saubere Markdown-Fassung unter derselben Adresse mit angehängtem `.md` bereitzustellen – aus `.../api` wird `.../api.md`. Das ist der Klebstoff zwischen Index und Inhalt: Der Index verweist auf Seiten, die schon in der Form vorliegen, die ein Modell ohnehin am besten verarbeitet.
Wichtig ist die Abgrenzung, weil hier viel durcheinandergeht. `robots.txt` regelt, was ein Crawler anfassen darf. `sitemap.xml` hilft beim Indexieren. `llms.txt` tut keines von beidem: Die Datei ordnet ein und kuratiert, gedacht für den Moment der Inferenz, nicht für den Crawl. Ein Agent, der sie liest, bekommt eine redaktionelle Aussage darüber, was an einem Produkt zählt – kein Versprechen an eine Suchmaschine. Die drei Dateien schließen sich nicht aus, sie beantworten verschiedene Fragen.
```mermaid
flowchart TD
A[Coding-Agent] -->|kennt llms.txt| B[llms.txt kuratierter Index]
B --> C{Welche Seite brauche ich?}
C -->|gezielt| D[seite.md saubere Markdown-Fassung]
C -->|alles auf einmal| E[llms-full.txt gesamter Inhalt]
A -.->|Alternative ohne llms.txt| F[HTML-Seite crawlen Navigation, Werbung, JS]
F -.->|viel Rauschen| G[Kontextfenster voll, Inhalt verwässert]
```
## Warum das etwas bringt
Beim Anbinden einer fremden Bibliothek lädt ein Agent ohne Markdown-Sicht häufig die vollständige HTML-Seite oder improvisiert fehlende Signaturen. Im ersten Fall zieht er Menü, Fußzeile und drei Codebeispiele herein, die er gar nicht braucht – ein spürbarer Teil des Fensters ist weg, bevor die eigentliche Aufgabe beginnt. Im zweiten Fall rät er. Mir ist in einem Code-Review aufgefallen, dass ein Agent eine API-Signatur schlicht erfunden hatte, plausibel und falsch, weil ihm die exakte Referenz zu teuer war, sie sich zu holen. Beides sind Symptome desselben Problems: zu viel Rauschen pro Token, zu wenig verlässliche Substanz.
`llms.txt` setzt genau dort an. Kuratiertes Markdown ohne Layout-Ballast bedeutet, dass mehr vom Fenster für den eigentlichen Inhalt übrig bleibt. Der Index zwingt außerdem zu einer Entscheidung: Nicht jede Seite ist gleich wichtig, und jemand mit Domänenwissen muss benennen, welche dreißig bis hundert Seiten den Kern ausmachen. Und wenn das Modell die genaue Fehlermeldung oder den exakten Parameter braucht, holt es sich die passende `.md`-Seite, statt zu improvisieren.
Der Punkt mit der Kuratierung wird oft übersehen. Eine gute `llms.txt` ist keine beliebige Linkliste, sondern eine redaktionelle Aussage darüber, was an einem Produkt zählt. Diese Festlegung ist die eigentliche Arbeit – nicht die Datei selbst.
## Wo es sich lohnt
Für ein Blog oder eine Marketing-Seite bringt `llms.txt` wenig: Für eine Ranking-Wirkung liegt kein Beleg vor, und wer die Datei in der Hoffnung auf bessere Sichtbarkeit anlegt, wird enttäuscht. Wer eine solche Wirkung verspricht, verspricht zu viel.
Die Ausnahme ist eng, aber real: technische Dokumentation und Coding-Agenten. Eine API-Referenz, eine Komponentenbibliothek, ein SDK – Inhalte, die ohnehin in Markdown gepflegt werden und die ein Agent in der IDE gezielt nachschlägt.
Für reine Marketingseiten ohne nachweisbare Agentennutzung rechtfertigt der Pflegeaufwand die Datei meist nicht; bei regelmäßig abgefragter technischer Dokumentation kann er sich lohnen. Server-Logs mit Anfragen auf `/llms.txt` liefern dafür einen Nutzungshinweis, tragen die Entscheidung aber nicht allein: Ausbleibende direkte Zugriffe belegen nicht zwingend fehlende Nutzung, etwa wenn dieselben Inhalte über andere Wege wie MCP-Ressourcen abgerufen werden.
## Aus der Quelle erzeugt, nicht von Hand gepflegt
Ein zentrales Risiko beim Einsatz ist organisatorisch, nicht technisch: zwei Fassungen desselben Inhalts, die getrennt gepflegt werden. Die Seite für Menschen hier, die Markdown-Fassung für Modelle dort. Läuft die `llms-full.txt` der echten Doku hinterher, füttert man Modelle mit veralteten Ständen – und das ist schlimmer als gar keine Datei, weil es falsches Vertrauen erzeugt. Ohne automatische Erzeugung aus derselben Quelle ist Drift nur eine Frage der Zeit.
Deshalb gehören beide Dateien in den Build, nicht in den Editor. Der Build kann pro Site und Locale `llms.txt`, `llms-full.txt` und Markdown-Zwillinge aus dem veröffentlichten Stand erzeugen. Entscheidend ist die gemeinsame Quelle für menschliche und maschinenlesbare Ausgaben; eine zweite, von Hand gepflegte Dokumentation würde erneut Drift ermöglichen.
Das ist die zweite Hälfte der Kuratierungsarbeit. Die redaktionelle Entscheidung, was in den Index gehört, trifft ein Mensch. Die Erzeugung der Dateien übernimmt der Build. Wer beides von Hand macht, hat sich eine zweite Doku eingehandelt, die leicht vom veröffentlichten Stand abweicht.
## Was ein MCP-Server daraus macht
Bis hierhin ist `llms.txt` eine statische Datei, die jemand irgendwann abholt. MCP ergänzt den statischen Index um gezielten Zugriff auf Ressourcen und Operationen. Das Model Context Protocol ist das offene Protokoll, das Anthropic Ende 2024 vorgestellt hat und über das ein Agent standardisiert mit externen Werkzeugen und Datenquellen spricht.
`llms.txt` beschreibt als Index, welche Inhalte es gibt und wo sie liegen; ein MCP-Server stellt Ressourcen und Operationen gezielt bereit. Das LangChain-Team hat mit `mcpdoc` genau so einen Doku-Server gebaut. Er bekommt eine Liste von `llms.txt`-Adressen und stellt dem Agenten zwei Werkzeuge bereit: eines, das die registrierten Quellen aufzählt, und eines, das eine bestimmte Seite daraus nachlädt.
Ein darauf ausgelegter MCP-Doku-Server kann Kontext gezielt nachladen, Aufrufe protokollierbar machen und Zugriffe beschränken – drei Verbesserungen gegenüber dem bloßen Herunterladen der Datei.
Erstens die Dosierung. Statt `llms-full.txt` komplett ins Fenster zu kippen, fragt der Agent über den Index nur die eine Seite ab, die zur Aufgabe passt – der Bereich zwischen „gar kein Kontext“ und „alles auf einmal“.
Zweitens die Nachvollziehbarkeit. Bei einem Doku-Server wie `mcpdoc` läuft das Nachladen über Werkzeugaufrufe, die man prüfen kann: welche Adresse geladen wurde und was zurückkam. Für Ressourcenabrufe gilt das nicht automatisch; dort braucht es eine eigene Logging auf der Serverseite. Ein direkter Download der Datei hinterlässt diese Spur im Agenten-Workflow nicht zwangsläufig. Bei interner oder geschützter Dokumentation kann diese Prüfbarkeit den zusätzlichen Betriebsaufwand rechtfertigen.
Drittens die Zugriffskontrolle. Der Server lässt sich auf erlaubte Domains beschränken, und für interne oder geschützte Doku legt man Authentifizierung davor. Wer berechtigungsgebundenen Zugriff braucht, kann die Dokumentation über einen authentifizierten MCP-Server als Ressource anbieten und dort Berechtigungen für jeden Abruf prüfen. Damit trägt die Konvention auch hinter der Firmen-Firewall: Der Server zeigt auf eine private `llms.txt`, und Modelle im Team bekommen kuratiertes Wissen, ohne dass die Inhalte offen im Netz stehen.
Kommt beides aus einem Produkt, kann es neben den erzeugten Dateien eine Remote-MCP-Oberfläche anbieten. In einem solchen Aufbau sind MCP-Ressourcen anwendungsverwalteter Kontext, den der Server dem Client als Dokumentation anbietet. Werkzeuge bleiben davon getrennt: Sie bilden domänenbezogene Operationen ab und sollten erst mit dem passenden Scope sichtbar werden. Ein solches System kann seine eigene `llms.txt`-Dokumentation zusätzlich als MCP-Ressource bereitstellen, sodass ein Client Werkzeugmodell und API-Grenzen lesen kann, ohne eine Webseite zu erraten. MCP ergänzt die statische Dokumentation also um gezielten Zugriff und um Operationen; berechtigungsgebunden wird dieser Zugriff erst, wenn der Server Ressourcenabrufe authentifiziert und autorisiert. Die Dokumentation ersetzt MCP nicht – ohne erzeugte, aktuelle Maschinensichten fehlte diesen Dokumentationsressourcen eine verlässliche Grundlage.
```mermaid
flowchart LR
H[Agent-Host Cursor, Claude Code] --> M[MCP Docs-Server z. B. mcpdoc]
M -->|Quellen auflisten| L[llms.txt registrierte Indizes]
M -->|Seite nachladen| P[nur die benötigte .md-Seite]
P --> H
```
Besonders `llms-full.txt` gewinnt in dieser Kombination. Man kann die Datei direkt als Wissensquelle an einen MCP-Server hängen – ohne Embedding-Pipeline, ohne Vektordatenbank. Treffender als „Ersatz für RAG“ ist die Beschreibung als werkzeuggestützte, prüfbare Variante davon: kein unvorhersehbares Ziehen aus einem großen Vektorindex, sondern nachvollziehbarer Zugriff auf kuratierte Seiten.
## Wo es hakt
`llms.txt` ist ein Vorschlag, kein verabschiedeter Standard. Es gibt kein Gremium dahinter und keine Garantie, dass ein bestimmtes Modell die Datei liest. Man stellt sie bereit; erzwingen lässt sich der Konsum nicht.
Die Größe ist eine echte Grenze. Eine mehrere Megabyte große `llms-full.txt` kann je nach Tokenisierung, Modell und Clientlimit nicht vollständig in den verfügbaren Kontext passen und wird dann nur in Bruchstücken geladen – womit der Vorteil „alles in einer Anfrage“ dahin ist. Für große Sites bleibt es beim kuratierten Index auf die wirklich zentralen Seiten, ergänzt um gezieltes Nachladen einzelner `.md`-Fassungen.
Und schließlich die Vertrauensfrage. Sobald ein Agent eine fremde `llms-full.txt` ungeprüft übernimmt, übernimmt er Inhalt, den er nicht kontrolliert. Das ist dieselbe Angriffsfläche wie bei jeder externen Datenquelle, die in den Kontext wandert – ein guter Grund, über einen MCP-Server mit Domain-Beschränkung zu gehen, statt beliebige Adressen einzusammeln.
## Fazit
`llms.txt` und `llms-full.txt` sind maschinenlesbare Selbstdokumentation. Der Index sagt, was zählt und wo es liegt; die Vollfassung liefert den Inhalt am Stück; die `.md`-Spiegel geben einzelne Seiten in der Form, die Modelle bevorzugen. Ein belastbarer Ranking-Faktor ist keines davon, und wer die Dateien mit dieser Erwartung anlegt, misst am falschen Ziel. Ihr Wert entsteht dort, wo Dokumentation auf Agenten trifft – bei SDKs, API-Referenzen und Coding-Werkzeugen.
Daraus folgen zwei Entscheidungen. Erstens: Die Dateien werden aus derselben Quelle erzeugt wie die Dokumentation für Menschen, oder man lässt sie weg – ein handgepflegter Doppelbestand driftet und untergräbt genau das Vertrauen, das er stiften soll. Zweitens: Wer gezielten oder berechtigungsgebundenen Zugriff braucht, kann die Dokumentation über einen authentifizierten MCP-Server als Ressource anbieten und dort Berechtigungen prüfen. MCP kann die statischen Sichten so um dosierten, prüfbaren und – bei serverseitiger Autorisierung – berechtigungsgebundenen Zugriff ergänzen; es bleibt darauf angewiesen, dass die Dokumentation dahinter stimmt.
## Weiterführende Quellen
- Der ursprüngliche Vorschlag und die Formatbeschreibung: [llmstxt.org](https://llmstxt.org/)
- Repository zum Vorschlag: [AnswerDotAI/llms-txt](https://github.com/answerdotai/llms-txt)
- MCP-Doku-Server, der `llms.txt` als Quelle liest: [langchain-ai/mcpdoc](https://github.com/langchain-ai/mcpdoc)
- Model Context Protocol: [modelcontextprotocol.io](https://modelcontextprotocol.io/)
---
# Hilfsmittel, die tragen: Konzepte, Methoden, Prozesse
URL: https://www.mikebild.dev/de/blog/hilfsmittel-konzepte-methoden-prozesse/
Datum: 2026-07-15
Für einen Agenten, der eine Fachdomäne verbindlich vertritt, gibt es kein Installationspaket. Installieren lassen sich verfügbare Modellgewichte und Laufzeiten; Protokolle lassen sich implementieren oder anbinden. Modellgewichte und Laufzeiten allein erzwingen jedoch keine fachliche Freigabe und erzeugen keinen fachlich aussagekräftigen Nachweis darüber, wer was entschieden hat. Der verbindliche Teil entsteht erst in der Auseinandersetzung mit der eigenen Domäne – mit ihren Begriffen, ihren Regeln und den Menschen, die für beides einstehen. Der Weg dorthin ist allerdings lernbar, und er ist unspektakulärer, als viele Framework-Debatten vermuten lassen.
*Teil 12 der Serie „Von der Session zum System“ – hier geht es [zum Auftakt](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/).*
Die [letzte Folge](https://www.mikebild.dev/de/blog/eigener-agent-pro-fachdomaene/) hat beschrieben, was so ein Agent können muss: Pläne prüfen, bevor sie wirken; Freigaben, die kein Modell wegformulieren kann; Nachweise, die Fragen von übermorgen beantworten. Offen geblieben ist der Weg dorthin. Er führt über drei Sorten von Hilfsmitteln: Konzepte, die tragen. Methoden, die den Anfang klein halten. Und Prozesse, die das Ganze im Betrieb am Leben erhalten, wenn die Aufmerksamkeit weiterzieht. Der Reihe nach.
## Konzepte: nichts davon ist neu
Wer die Fähigkeiten-Liste aus der letzten Folge durchgeht, findet darin keine einzige KI-Erfindung. Fachsprache und Domänenschnitt – dass ein System die Begriffe seiner Domäne sprechen soll und dass diese Begriffe nur innerhalb eines abgesteckten Zusammenhangs eindeutig sind – hat Eric Evans vor gut zwanzig Jahren in „Domain-Driven Design“ als ubiquitous language und Bounded Context beschrieben. Die Trennung von Vorschlag und Wirkung kennt jede Organisation, die Änderungen erst prüft und dann ausrollt, vom Vier-Augen-Prinzip in der Buchhaltung bis zu `terraform plan` und `apply`. Validierung, Autorisierung, Audit sind das Handwerkszeug jeder ernsthaften Fachanwendung. Und dass Antworten [auf echten Quellen stehen müssen statt auf plausiblem Raten](https://www.mikebild.dev/de/blog/sauberes-grounding-antworten-erden/) und [kuratiertes Wissen einen Kreislauf mit Besitzern braucht](https://www.mikebild.dev/de/blog/wissen-das-die-session-ueberlebt/), haben die mittleren Folgen dieser Serie behandelt – auch das ist im Kern Dokumentations- und Bibliotheksarbeit, kein Hexenwerk.
Neu ist allein der Abnehmer: eine Schleife, in der ein Modell handelt, statt einer Oberfläche, in der Menschen klicken. Für die Konzeptauswahl ist das eine kleine Verschiebung. Mir hilft seither eine einfache Prüffrage: Hat dieses Konzept schon getragen, bevor es KI gab? Domänenschnitt, Freigabe-Workflows, Versionierung, Audit – ja, jahrzehntelang. Ein Orchestrierungs-Framework, das es seit vier Monaten gibt – eher nicht. Das ist keine Abwertung von allem Neuen; irgendwo entsteht gerade tatsächlich das nächste tragende Konzept. Aber die Beweislast liegt beim Neuen, nicht beim Bewährten.
Dass sich die alten Konzepte direkt in Agentensysteme übertragen lassen, zeigt ein naheliegender Baustein: Eine Workflow-Engine kann Mission, Plan, Lauf und die dazu erteilte Autorität trennen – und für HTTP, MCP, A2A, Webhooks und Chat denselben Planungspfad nutzen. Das ist die alte Trennung von Vorschlag und Wirkung, konsequent auf jeden Eingangskanal angewendet: Egal, woher ein Vorhaben kommt, es nimmt denselben Planungspfad.
Für den Reflex, gleich die ganze Organisation als Agenten-Landschaft zu entwerfen, gibt es ebenfalls ein altes Konzept, und es trifft härter als jede Technikfrage. John Gall hat es in den Siebzigern als Beobachtung über Systeme formuliert: Ein komplexes System, das funktioniert, ist ausnahmslos aus einem einfachen System hervorgegangen, das funktioniert hat. Ein komplexes System, das am Reißbrett entworfen wurde, funktioniert nicht und lässt sich auch nicht reparieren – man muss von vorn anfangen, mit einem einfachen System. Zwölf verbundene Agenten auf einem Whiteboard sind der Reißbrett-Entwurf. Der erste Vorgang, der wirklich läuft und ein prüfbares Ergebnis liefert, ist der Anfang des Systems.
## Methode: erst die Regeln inventarisieren
Die erste der drei Fragen vom Ende der letzten Folge lautete: Welche Regeln gehören in den Pfad, welche dürfen Prosa bleiben? Die Antwort beginnt nicht bei der Technik, sondern bei einer Bestandsaufnahme, die unbeliebter ist, als sie sein müsste. Für die Inventur würde ich zunächst vier Fundorte prüfen: das Wiki, Instruktionsdateien wie CLAUDE.md oder AGENTS.md, Code-Review-Kommentare – und Köpfe, als das Wissen der einen Kollegin, die man sicherheitshalber vor jeder Preisänderung fragt. Vollständig ist diese Liste nicht; je nach Organisation kommen Tickets, Richtlinien, Konfiguration oder Fachverfahren hinzu. Die Inventur holt die Regeln an einen Ort und notiert zu jeder vier Dinge: Wo steht sie? Wie verbindlich ist sie gemeint? Was passiert bei einem Verstoß? Und wie oft wurde sie zuletzt tatsächlich verletzt?
Die letzte Spalte ist die wichtigste, denn sie ersetzt Meinung durch Befund. In der Chronik meiner Instruktionsdateien war die Ernüchterung, dass aufgeschriebene Regeln Empfehlungen bleiben; in der [Folge über Tools](https://www.mikebild.dev/de/blog/agent-modell-fachdomaene/) wurde daraus ein Übergangskriterium: Wenn dieselbe Regel zum dritten Mal in einer Instruktionsdatei auftaucht und zum zweiten Mal ignoriert wurde, ist sie ein Kandidat für die Durchsetzung im Pfad. Die Inventur macht aus diesem Bauchgefühl eine Liste:
```yaml
# rule inventory, one entry per rule
- rule: "Credit notes above 500 EUR require team lead approval"
source: wiki, AGENTS.md
violation_impact: money leaves the company
violated_recently: twice in Q2
decision: enforce # goes into the path
- rule: "Use the customer number, not the invoice number, in replies"
source: onboarding notes
violation_impact: confusion, no damage
violated_recently: unknown
decision: prose # stays a convention
```
Für die Einordnung halte ich drei Fragen für einen tragfähigen Startpunkt, und sie decken sich mit den Kriterien, die sich in dieser Serie nach und nach herausgeschält haben: Bewegt ein Verstoß Geld, personenbezogene Daten oder Wirkung nach außen? Muss hinterher jemand nachweisen können, wer was wann entschieden hat? Wurde die Regel trotz sauberer Dokumentation wiederholt gebrochen – von Menschen oder vom Modell? Ein Ja bei einer dieser Fragen ist für mich der Ausgangspunkt, die Regel in den Pfad zu nehmen: Prüfung, Freigabe, Nachweis. Eine Startheuristik bleibt das allerdings – wo der mögliche Schaden gering ist, ein Fehler sich leicht zurücknehmen lässt oder bestehende Kontrollen ihn ohnehin abfangen, kann eine Regel auch bei einem Ja Prosa bleiben. Dreimal Nein, und sie bleibt Prosa – als Konvention, die das Modell liest und meistens befolgt, und deren verbleibendes Risiko ausdrücklich akzeptiert wurde.
Die Inventur hat einen zweiten Ertrag, der leicht übersehen wird: Sie findet tote Regeln. Vorgaben, die seit Jahren niemand mehr braucht, deren Anlass längst verschwunden ist, die aber weiter in jedem Dokument mitgeschleppt werden. Die fliegen raus – nicht in den Pfad, sondern ganz. Ein Agent, der eine Fachdomäne vertritt, ist auch eine Gelegenheit, die Domäne selbst zu entrümpeln.
## Methode: die erste Domäne klein schneiden
Die zweite Frage: Wie schneidet man die erste Domäne, ohne sich zu verheben? Die kurze Antwort: einen Vorgang, keine Abteilung. Eine Abteilung bündelt viele Zustände und Verantwortlichkeiten, die nie gleichzeitig fertig sind; ein Vorgang hat einen prüfbaren Anfang und ein prüfbares Ende. „Rechnungswesen“ ist deshalb kein Schnitt, sondern ein Organigramm-Kästchen. „Gutschriften und Mahnstopps“ ist einer – ein abgrenzbarer Vorgang mit Anfang, Ende und einer Handvoll Verben.
Woran man einen tauglichen ersten Kandidaten erkennt:
- Der Vorgang hat einen klaren Anfang und ein klares Ende – kein Dauerzustand, kein Sammelbegriff.
- Eine Handvoll Verben genügt: Spätestens wenn die Tool-Liste beim Modellieren zweistellig wird, würde ich den Schnitt erneut prüfen.
- Es gibt heute schon eine fachlich zuständige Person – die Rolle, die auch ohne KI freigibt und entscheidet.
- Der Schmerz ist dokumentiert: Verstöße sind in der Vergangenheit tatsächlich passiert und haben nachweislich geärgert.
- Das Schadenspotenzial rechtfertigt den Aufwand, bleibt aber überschaubar – Gutschriften ja, Zahlungsverkehr mit dem Ausland vielleicht erst im zweiten Jahr.
Der letzte Punkt verdient einen Moment. Der erste Domänen-Agent ist nicht nur ein Werkzeug, er ist auch das Stück, an dem ein Team die drei Fähigkeiten – Prüfung, Freigabe, Nachweis – zum ersten Mal baut und betreibt. Solche ersten Stücke wählt man so, dass Fehler lehrreich sind, nicht existenzbedrohend.
Zum kleinen Schnitt gehört auch ein kleiner Übergang. Niemand reißt die bestehende Arbeitsweise ab und ersetzt sie durch den Agenten; die Prosa-Variante bleibt der Prototyp, aus dem Regeln einzeln in den Pfad wandern, sobald ihre Verbindlichkeit sich erwiesen hat. Martin Fowler hat für dieses Muster – das Neue wächst am Alten entlang, bis das Alte entbehrlich ist – das Bild der Würgefeige geprägt, die einen Baum umwächst. Auf Regeln übertragen: Erst gilt die 500-Euro-Regel als Satz in der Instruktionsdatei, dann zusätzlich als Prüfung im Pfad, und irgendwann ist der Satz nur noch Dokumentation der Prüfung. Kein großer Umstellungstag, keine riskante Migration über ein Wochenende.
Der Rest der großen Skizze stirbt dabei nicht – er wird Backlog, sortiert nach genau den Kriterien oben. Das kann sich wie ein Rückzug anfühlen. Es ist das Gegenteil: der erste Schritt, der tatsächlich gegangen werden kann und ein überprüfbares Ergebnis liefert.
## Prozesse: Besitzer, Änderungsweg, Rhythmus
Bleibt die dritte Sorte Hilfsmittel, und sie ist die am leichtesten unterschätzte. Konzepte kann man lernen, Methoden kann man anwenden – Prozesse muss man im Betrieb durchhalten. Drei halte ich für tragend.
Erstens: Jede Regel hat einen Besitzer, und der sitzt im Fachbereich. Die Entwicklung besitzt die Durchsetzung – den Code, der prüft, das Gatter, das wartet, das Protokoll, das schreibt. Aber ob 500 Euro die richtige Schwelle ist, ob „Kulanz“ und „Preisfehler“ verschiedene Wege gehen, entscheidet die Fachseite, die diese Verantwortung schon immer trug. Die Diskussion über das Vorschlagen, Prüfen und Freigeben von Regeln ist dabei kein Hindernis auf dem Weg zum Prozess. Sie ist der Prozess – wer sie überspringt, hat Regeln ohne Legitimation, und die erodieren beim ersten Konflikt.
Zweitens: Regeländerungen gehen denselben Weg wie Regeln. Vorschlag, Prüfung, Freigabe, Versionierung – dieselbe Sorgfalt, die für Code selbstverständlich ist. Dass der Nachweis die geltende Regelversion festhält, war in der letzten Folge ein Detail am Rand; im Betrieb wird es zur Voraussetzung dafür, dass man Regeln überhaupt anfassen kann, ohne die Vergangenheit umzudeuten. Wie das aussehen kann, zeigen zwei Bausteine: Ein Wissenssystem kann fachliche Leitlinien in einem versionierten, menschenverantworteten Charter halten und Änderungen am abgeleiteten Wissensbestand durch einen Review-Prozess führen. Eine Workflow-Engine kann genehmigte Abläufe als wiederholbar ausgeführte Workflows beschreiben und jeden Lauf protokollieren – nicht beschriebene und nicht genehmigte Arbeit wird nicht improvisiert. Beides sind Ausprägungen desselben Prinzips: Der Änderungsweg ist in das System eingebaut.
Drittens, und am wichtigsten: aus den Neins lernen, in festem Rhythmus. Der Agent erzeugt im Betrieb zwei Ströme – Ausführungen und Ablehnungen. Für zu enge oder fehlende Regeln sind die Ablehnungen oft der ergiebigere Ausgangspunkt; Stichproben erfolgreicher Läufe bleiben trotzdem nötig, weil auch eine durchgewunkene Ausführung eine falsche Entscheidung enthalten kann. Das Ablehnungsprotokoll gehört deshalb regelmäßig auf den Tisch – anfangs in einem festen Abstand von wenigen Wochen, später abhängig von Ablehnungsrate und Schadenspotenzial – mit drei Fragen: Welche Neins waren richtig und bleiben? Welche waren zu eng und brauchen eine angepasste Schwelle oder einen neuen Gutschriftsgrund? Und welche Sonderfälle tauchen so regelmäßig auf, dass sie ein eigenes Verb verdienen? Das ist derselbe Kreislauf, den [die Folge über kuratiertes Wissen](https://www.mikebild.dev/de/blog/wissen-das-die-session-ueberlebt/) beschrieben hat, nur mit Regeln statt Erkenntnissen: Der Betrieb liefert Kandidaten, die Kuration macht Verbindliches daraus – die Organisation ändert dabei Regeln und Schnittstellen; das Modell bleibt unverändert.
```mermaid
flowchart LR
I["Inventur Regeln sammeln und bewerten"] --> K["Einordnung Pfad oder Prosa"]
K --> B["Bauen Verben · Prüfung · Freigabe"]
B --> O["Betrieb Ausführungen und Ablehnungen"]
O --> S["Sichtung im Rhythmus aus den Neins lernen"]
S --> I
```
Zusammen ergeben die drei Prozesse das, was in der letzten Folge nur behauptet wurde: dass so ein Agent ein Produkt mit Lebenszyklus ist. Ein Produkt hat Besitzer, einen Änderungsweg und einen Takt, in dem es besser wird. Fehlt eines davon, verfällt es – bei Regeln schneller als bei Code, weil eine veraltete Schwelle keinen Build fehlschlagen lässt und deshalb gezielt durch Review oder Betriebsmetriken erkannt werden muss.
## Moden, die man auslassen kann
Und die Gegenliste? Vier Muster halte ich für Aufmerksamkeitsfresser, die weder Prüfung noch Freigabe oder Nachweis verbessern – das ist ein Urteil, kein Messergebnis.
Das Multi-Agenten-Orchester ab Tag eins: viele Agenten, die einander Messages schicken, bevor auch nur einer eine einzige verbindliche Regel durchsetzt – der Reißbrett-Entwurf in Software gegossen. Der häufige Framework-Wechsel, bei dem die Fachlogik jedes Mal ein Stück tiefer in Anbieter-Konventionen einsinkt; das Gegenmittel – Fachlogik in eigene Dienste, Tool-Schicht als dünner Adapter – stand schon [in der Folge über Agent, Modell und Fachdomäne](https://www.mikebild.dev/de/blog/agent-modell-fachdomaene/). Die Modell-Vergleichstabelle als Strategieersatz, gegen die [diese Serie früh argumentiert hat](https://www.mikebild.dev/de/blog/gut-genug-modelle/): Ob mehrere Modelle die eigenen Aufgaben gut genug lösen, zeigt eine konkrete Prüfung gegen genau diese Aufgaben – und dort, wo das der Fall ist, gehört die Energie in den eigenen Anteil, nicht in die Tabelle. Und das endlose Feilen an Formulierungen: Wenn dieselbe Anweisung zum dritten Mal umformuliert wird, damit das Modell sie „endlich versteht“, ist das kein Schreibproblem. Es ist das Signal, dass die Regel in den Pfad gehört, nicht in schönere Worte.
Die Prüffrage ist immer dieselbe, und sie macht die Liste kurz: Hilft es, Prüfung, Freigabe oder Nachweis zu bauen – oder fühlt es sich nur nach Fortschritt an? Viele derzeit diskutierte Frameworks und Agentenmuster kann man in Ruhe reifen lassen. Sie laufen nicht weg, und was davon trägt, ist in einem Jahr noch da.
## Zwischenstand
Damit sind die drei Fragen vom Ende der letzten Folge beantwortet, so gut ich es nach diesen Monaten kann: mit einer Inventur, die Befunde statt Meinungen liefert, einem Schnitt von der Größe eines Vorgangs und Prozessen, die Besitzer, Änderungsweg und Rhythmus festlegen. Beginnen würde ich deshalb mit einem belegten Regelverstoß in einem bereits klein geschnittenen Vorgang – dort ist der Schmerz dokumentiert, der Schnitt klein und das Ergebnis prüfbar. Die Konzepte dahinter sind alt, und das ist ihre wichtigste Eigenschaft: Sie haben schon einmal gehalten.
Vor gut acht Monaten begann diese Serie mit einer Session auf meinem Rechner und der Beobachtung, dass sich meine Arbeit verändert; jetzt endet der Weg vorläufig bei Organisationen, die Regeln, Wissen und Verantwortung in eigene Agenten legen. Die nächste Folge prüft die Erwartungen aus dem Auftakt: Was davon ist eingetreten, was nicht – und wohin führt das alles?
## Weiterführende Quellen
- [Domain-Driven Design Reference (Eric Evans)](https://www.domainlanguage.com/ddd/reference/) – ubiquitous language und Bounded Context als Entwurfsarbeit
- [John Gall: Systemantics](https://en.wikipedia.org/wiki/John_Gall_%28author%29) – warum funktionierende komplexe Systeme aus einfachen funktionierenden Systemen entstehen
- [Martin Fowler: Strangler Fig Application](https://martinfowler.com/bliki/StranglerFigApplication.html) – das Muster für Übergänge ohne großen Umstellungstag
- [Building Effective AI Agents (Anthropic)](https://www.anthropic.com/engineering/building-effective-agents) – der Rat, mit dem einfachsten funktionierenden Aufbau zu beginnen
---
# KI-Agenten pro Fachdomäne: Regeln, Freigaben und Nachweise
URL: https://www.mikebild.dev/de/blog/eigener-agent-pro-fachdomaene/
Datum: 2026-07-14
Ein KI-Agent pro Fachdomäne verbindet die Werkzeuge eines Arbeitsfelds mit dessen Regeln, Rechten und Vorgangszustand. Entscheidend ist nicht ein weiterer Chat, sondern ein ausführbarer Pfad, der zusammengehörige Aktionen prüft, bevor sie wirken. Dieser Artikel zeigt, welche Verantwortung dafür beim Modell, beim Tool und beim betriebenen Agentensystem liegt.
Ein konstruiertes Beispiel: Ein Agent soll 740 Euro Kulanz erstatten. Über 500 Euro braucht es die Freigabe der Teamleitung. Der Tool-Aufruf über 740 Euro wird abgelehnt; zwei Aufrufe über je 370 Euro würden eine rein aufrufbezogene Prüfung dagegen bestehen. Jeder Aufruf wäre einzeln zulässig, die gemeinsame Wirkung nicht. Genau diese Lücke muss eine Regel über den gesamten Vorgang schließen.
*Teil 11 der Serie „Von der Session zum System“ – hier geht es [zum Auftakt](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/).*
Das Beispiel beschreibt eine mögliche Schwachstelle, keinen beobachteten Vorfall. Ob ein Modell tatsächlich zwei Teilbeträge vorschlägt, ist offen. Die Architektur muss eine solche Umgehung trotzdem verhindern: Eine Vorgangsregel lässt sich nicht allein als isolierte Prüfung einzelner Aufrufe ausdrücken.
Diese Folge löst damit zwei Versprechen ein, die in der Serie offen sind. Die Chronik meiner Instruktionsdateien endete mit dem Befund, dass nur das eine Regel ist, was die Umgebung erzwingt. Die [letzte Folge](https://www.mikebild.dev/de/blog/agent-modell-fachdomaene/) schloss mit der Frage, warum verbindliche Regeln auf einen eigenen, an die Fachdomäne gebundenen Agenten hinauslaufen – und was der können muss. Die Gutschriften-Konstruktion gibt die Antwort in Kurzform: Regeln brauchen einen Ort, an dem der Zusammenhang sichtbar ist.
## Ein Tool sieht den Aufruf, nicht den Vorgang
Zur Erinnerung, wo die Serie steht: Die letzte Folge hat die Fachdomäne aus dem Prompt in die Tools verlegt – typisierte Operationen, deren Namen aus der Fachsprache kommen, deren Eingaben validiert und deren Aufrufe autorisiert werden. Die Prüfung läuft damit im ausführbaren Pfad statt im Prompt: Die 500-Euro-Regel wurde von einer Empfehlung, die das Modell lesen und abwägen kann, zu Code, der bei jedem Aufruf gleich entscheidet.
In diesem Beispiel sieht die Prüfung nur einen Aufruf. Ein Tool kann auch Vorgangszustand laden und prüfen; entscheidend ist, dass diese Verantwortung ausdrücklich umgesetzt wird. Ohne sie bleiben drei Dinge verborgen.
Der Zusammenhang. Fachliche Regeln sind selten Regeln über Aufrufe – sie sind Regeln über Vorgänge. „Nicht mehr als 500 Euro Kulanz“ meint: pro Fall, pro Kunde, pro Zeitraum. Zwei Gutschriften à 370 Euro zum selben Vorgang verletzen die Regel, ohne dass irgendein einzelner Aufruf sie verletzt. Eine Autorisierung, die nur die Eingabe des aktuellen Aufrufs erhält, kann das nicht bemerken – nicht weil das Tool technisch unfähig wäre, sondern weil ihr der gebundene Vorgangszustand fehlt.
Die Wirkung. Manche Fehler erkennt man nicht am einzelnen Schritt, sondern erst am Gesamtbild – an dem, was nach zwanzig Schritten entstanden sein wird. Wer erst nach der Ausführung prüft, prüft zu spät; die Gutschrift ist dann schon beim Kunden.
Das Gedächtnis. Ob ein Muster auffällig ist, entscheidet sich über Sessions hinweg: dieselbe Rechnung, dreimal in zwei Wochen, von zwei verschiedenen Personen angestoßen. Der einzelne Aufruf weiß davon nichts, und das einzelne Tool ebenso wenig.
Was dem einzelnen Tool-Aufruf fehlt, kann der Agent zusammenführen: den Verlauf, einen materialisierten Plan und persistenten Vorgangszustand – vorausgesetzt, diese Zustände werden explizit gespeichert und an den Vorgang gebunden. Deshalb wandert die Durchsetzung eine Ebene nach oben – aus dem Tool in den Agenten, der die Schleife betreibt. Damit ist der Agent kein austauschbares Zubehör mehr, sondern der Ort, an dem die verbindlichen Regeln einer Fachdomäne liegen: ein betriebenes Softwaresystem mit Plan, Rechten, Freigaben, Nachweisen und klarer Zuständigkeit.
## Vom Vorschlag zum Nachweis: fünf Stationen
Wie sieht diese Durchsetzung aus? Der tragende Gedanke ist alt und stammt nicht aus der KI-Welt: Bauen und Ausführen trennen. Wer Infrastruktur als Code betreibt, kennt ihn als `terraform plan` und `terraform apply` – erst entsteht eine vollständige Vorschau dessen, was sich ändern würde, dann entscheidet sich getrennt davon, ob das auch geschieht. Zwischen Vorschlag und Wirkung liegt eine Prüfung, und die sieht nicht den einzelnen Handgriff, sondern das ganze Vorhaben.
Auf Agenten übertragen umfasst der Weg von der Idee zur Wirkung fünf Stationen.
Am Anfang steht der Modellvorschlag: eine textuelle oder strukturierte Ausgabe, so eloquent wie unverbindlich. Ob das Modell Prosa liefert oder fertig formatierte Tool-Aufrufe – es erzeugt damit zunächst nur eine Absichtserklärung ohne autorisierte Wirkung. Daraus wird zweitens ein ausführbarer Plan: eine geordnete Folge typisierter Operationen mit konkreten Parametern, als immutable Revision gespeichert und an den geprüften Zustand gebunden; die Operationen und Parameter sind maschinell auswertbar, eine Begründung kann ergänzend Freitext bleiben. Drittens die fachliche Autorisierung: Der Plan wird als Ganzes gegen die Regeln der Fachdomäne geprüft. Hier fallen zwei Gutschriften zum selben Vorgang auf, hier greifen Summen- und Häufigkeitsregeln, hier entscheidet sich, ob das Vorhaben zulässig, abzulehnen oder freigabepflichtig ist. Viertens, wo die Regeln es verlangen, die menschliche Freigabe: eine Bestätigung durch eine Rolle der Fachdomäne, die das Modell weder erteilen noch ersetzen kann – es darf Vorschläge machen, aber keine menschliche Entscheidung selbst bestätigen. Und fünftens der Nachweis, in zwei Formen: ein Entscheidungsnachweis für jede Ablehnung und jede Freigabe, ein Ausführungsnachweis für jede tatsächlich ausgeführte Operation – wer, was, wann, mit welchem Ergebnis, unter welcher Regelversion.
```mermaid
flowchart LR
M["Modellvorschlag textuell oder strukturiert, unverbindlich"] --> P["Plan alle geplanten Operationen"]
P --> R{"fachliche Autorisierung Regeln der Fachdomäne"}
R -- "verletzt" --> N["Ablehnung begründet und protokolliert"]
R -- "freigabepflichtig" --> H["menschliche Freigabe"]
R -- "zulässig" --> D{"gebundener Zustand noch aktuell?"}
H -- "bestätigt" --> D
H -- "abgelehnt" --> A
D -- "ja" --> E["Ausführung"]
D -- "nein" --> R
E --> A["Entscheidungs- oder Ausführungsnachweis wer · was · wann · Regelversion"]
N --> A
```
Im Kleinen kennt das jeder, der mit Coding-Agenten arbeitet: erst der Diff, dann der Commit. Der Unterschied ist, dass dort ein Mensch freiwillig hinschaut – und am Freitagnachmittag eben auch mal nicht. In einem Agenten, der eine Fachdomäne verantwortet, ist die Prüfung keine Gewohnheit, sondern Teil des Pfads. Sie findet statt, ob jemand daran denkt oder nicht.
## Ein Nein, das ein Nein bleibt
Die zweite Fähigkeit folgt direkt aus der Konstruktion vom Anfang. Ein Modell, das auf eine Ablehnung trifft, kann umformulieren, verhandeln, Umwege suchen. Das wäre keine Böswilligkeit: Weitersuchen ist genau das Verhalten, das wir an anderer Stelle schätzen, wenn ein Modell einen Testfehler dreimal anders angeht, bis der Build grün ist. Statt diese Beharrlichkeit wegtrainieren zu wollen, kann man ihr eine Grenze setzen, die nicht mitverhandelt.
Dafür muss die Freigabe außerhalb des Gesprächs liegen. Eine freigabepflichtige Operation wartet, bis ein Mensch sie bestätigt – und kein noch so eloquenter Text im Kontext bewegt dieses Gatter, weil das Gatter den Text gar nicht liest. Das Modell kann seine zwei 370-Euro-Gutschriften vorschlagen, so oft es will: Die Summenregel schlägt beim Plan an, die Freigabe bleibt offen, der Vorgang liegt beim zuständigen Menschen. Wichtig ist dabei, wer dieses Ja gibt: nicht „irgendein Admin“, sondern eine Rolle aus der Fachdomäne – die Teamleitung, die auch ohne KI über 500-Euro-Kulanzen entscheidet. Die Freigabe bildet eine bestehende fachliche Verantwortung ab, sie erfindet keine neue.
Skizziert an der Tool-Definition aus der letzten Folge sieht die Erweiterung ungefähr so aus. Der Codeblock ist eine vereinfachte, illustrative Skizze: Die API `defineTool` und die Rolle `billing_team_lead` sind frei gewählte Platzhalter.
```ts
const issueCreditNote = defineTool({
name: "issue_credit_note",
input: z.object({
invoiceId: z.string(),
amount: z.number().positive(),
reason: z.enum(["complaint", "goodwill", "pricing_error"]),
}),
approval: {
required: ({ input, history }) =>
input.amount + history.totalCreditedFor(input.invoiceId) > 500,
approvers: ["billing_team_lead"],
},
audit: { record: ["user", "input", "approval", "result"] },
});
```
Die entscheidende Zeile ist die mit `history`. Die Freigabepflicht hängt nicht am einzelnen Betrag, sondern an der Summe über den Vorgang. Autoritativ liegt dieser Zustand in der Fachdomäne, nicht im Gespräch: Der Agent bindet einen geprüften Stand des Vorgangs an den Plan und reicht ihn als Eingabe in die Autorisierung – genau die Sicht, die der isolierten Einzelaufrufprüfung fehlt. Eine Bindung allein genügt allerdings nicht: Damit parallele Aufrufe die 500-Euro-Grenze nicht doch überschreiten, muss die Ausführung den gebundenen Stand vorab erneut gegen den aktuellen Domänenzustand prüfen und bei zwischenzeitlichen Änderungen abbrechen oder neu autorisieren.
## Nachweis statt Erinnerung
Die dritte Fähigkeit ist die unscheinbarste: Jede Ausführung hinterlässt einen Nachweis. Wer hat den Vorgang angestoßen, welche Planrevision wurde geprüft, was genau wurde ausgeführt, mit welchen Eingaben, was kam heraus, wer hat freigegeben – und, leicht zu übersehen: welche Fassung der Regeln galt dabei. Fachregeln ändern sich. Aus 500 Euro werden 300, ein Freigabeweg wird umgebaut. Wenn drei Monate später jemand fragt, warum eine Gutschrift damals durchging, muss die Antwort lauten können: nach Regelstand vom März war sie zulässig, hier ist der Eintrag.
Ein solches Protokoll existiert nicht, weil jemand daran gedacht hat mitzuschreiben. Es existiert, weil der Pfad es erzeugt – Ablehnungen eingeschlossen. Auch das Nein hinterlässt eine Spur, und gerade die Neins zeigen, wo Regeln zu eng oder Tools zu grob geschnitten sind. Auditierbarkeit ist keine Compliance-Übung, die man hinterher anbaut. Sie ist eine Eigenschaft des Pfads, oder sie ist nicht.
## Warum pro Fachdomäne
Bis hierher ist begründet, warum verbindliche Regeln in prüfbare Zustandsübergänge und Autorisierungsgrenzen gehören statt nur in Prompt-Prosa. Offen ist der zweite Teil der Frage aus der letzten Folge: Warum ein *eigener* Agent pro Fachdomäne – und nicht ein großer, der alles kann?
Weil jede der drei Fähigkeiten Fachlichkeit voraussetzt. Eine Plan-Prüfung kann nur bewerten, was sie versteht: Dass zwei Gutschriften zum selben Vorgang gehören, dass ein Kunde im Mahnverfahren steckt, dass „Kulanz“ und „Preisfehler“ verschiedene Folgen haben – das sind Begriffe und Zusammenhänge einer Domäne, keine generischen Konzepte. Die Freigabe braucht Rollen, die es nur dort gibt. Der Nachweis muss in der Sprache geführt werden, in der später jemand fragt. Ein generischer Agent kann Dateien lesen und Kommandos ausführen; er kann nicht wissen, was eine unzulässige Gutschrift ist.
Dazu kommen die Rechte. Ein Agent, der die Tools aller Domänen trägt, kann einen entsprechend breiten Berechtigungsumfang benötigen, wenn Rechte nicht pro Aufruf delegiert und begrenzt werden – und wird mit solchen dauerhaften Rechten zu einem lohnenden Angriffsziel. Die OWASP führt „Excessive Agency“ in ihren Top-10-Risiken für LLM-Anwendungen: zu viele Tools, zu weite Berechtigungen, zu viel Autonomie in einem einzigen System. Simon Willison hat mit seiner „lethal trifecta“ die giftigste Kombination benannt – Zugriff auf private Daten, Kontakt mit nicht vertrauenswürdigen Inhalten und die Fähigkeit, nach außen zu kommunizieren, in einem Agenten vereint. Der Zuschnitt nach Fachdomänen ist deshalb auch eine Sicherheitsentscheidung – eine durchsetzbare Grenze wird er allerdings erst mit getrennten Identitäten, Rechten, Zuständen und Schnittstellen: wenige Tools, eng gefasste Berechtigungen, klarer Wirkungskreis. Der Gutschriften-Agent kann keine Deployments anstoßen, und der Deployment-Agent kennt keine Kundendaten.
Und schließlich das Wissen. Kuratierte Erkenntnisse, [geerdete Antworten](https://www.mikebild.dev/de/blog/sauberes-grounding-antworten-erden/), [Wissen, das die Session überlebt](https://www.mikebild.dev/de/blog/wissen-das-die-session-ueberlebt/) – all das gehört immer zu einer bestimmten Domäne. Ein Agent, der eine Fachdomäne verantwortet, trägt ihre Quellen, ihre Konventionen, ihre Sonderfälle. Nicht als domänenübergreifendes Sammelsurium, sondern als gepflegter, überschaubarer Bestand mit Besitzern.
An dieser Stelle schließt sich auch der Bogen zur [Varianz aus dem Team-Teil dieser Serie](https://www.mikebild.dev/de/blog/mein-erfolg-laesst-sich-nicht-kopieren/). Damals war der Befund: Zwischen Personen, Aufgaben und Sessions streut das Ergebnis, und Dateien mit Regeln ändern daran wenig. Der Domänen-Agent löst dieses Problem nicht, indem er Menschen gleich macht. Er verschiebt die Grenze, unterhalb derer Varianz Schaden anrichten kann. Oberhalb bleibt alles verschieden: Wie jemand formuliert, erkundet, delegiert, welchen Weg eine Session nimmt. Unterhalb ist es gleich: Was am Ende wirkt, geht durch dieselbe Autorisierung, dieselbe Freigabe, denselben Nachweis – bei der erfahrenen Kollegin genauso wie beim Praktikanten, am Freitagnachmittag genauso wie am Dienstagmorgen.
## Was der eigene Agent können muss
Damit lässt sich die Frage aus der letzten Folge kompakt beantworten. Ein Agent, der eine Fachdomäne verbindlich vertreten soll, braucht:
- Tools in der Fachsprache der Domäne – typisiert, validiert, autorisiert
- die Trennung von Modellvorschlag und Wirkung, mit Prüfung des ganzen Plans statt einzelner Aufrufe
- Regeln über Vorgänge: Summen, Häufigkeiten, Zusammenhänge über Aufrufe und Sessions hinweg
- Freigaben im Pfad, außerhalb des Gesprächs, durch Rollen der Fachdomäne
- Nachweis jeder Ausführung und jeder Ablehnung – mit Planrevision, Regelrevision, Freigabeentscheidung, Aufrufer, Ergebnis und Fehlerstatus
- die Rechte des jeweiligen Aufrufers statt eigener Allmacht – eng geschnitten, domänenbezogen
- kuratierte Wissensquellen der Domäne, mit Besitzern und Pflege
Auf dieser Liste steht nichts, was ein erfahrenes Team nicht längst gebaut hätte: Validierung, Autorisierung, Workflow, Audit, Berechtigungsmodell. Neu ist allein, wofür – nicht für eine Oberfläche, in der Menschen klicken, sondern für eine Schleife, in der ein Modell handelt. Wer so einen Agenten baut, legt gewöhnliche, solide Software um variable Modellvorschläge herum. Genau deshalb ist die Aufgabe zu schaffen.
Zu schaffen heißt nicht nebenbei. Was hier entsteht, ist ein betriebenes Softwaresystem mit Lebenszyklus, kein Wochenendprojekt – die Gegenrechnung aus der letzten Folge gilt unverändert, vom Pflegeaufwand bis zur Gefahr, aus lauter Vorsicht ein Formular mit Chat-Oberfläche zu bauen. Und es gehört niemandem allein: Die Regeln kommen aus dem Fachbereich, die Durchsetzung aus der Entwicklung, und keiner von beiden kann den Teil des anderen übernehmen. Unabhängig vom Implementierungsaufwand muss das Team klären, wer solche Regeln künftig vorschlagen, prüfen und freigeben darf – das ist Organisationsarbeit.
## Zwischenstand
Der Weg dieser Serie lässt sich jetzt in drei Stationen erzählen. Regeln als Prosa: gelesen, gewichtet, gelegentlich überstimmt – Empfehlungen, wie ich sie ein halbes Jahr lang vergeblich verschärft habe. Regeln im Tool: geprüft bei jedem Aufruf, verlässlich im Einzelnen, blind für den Zusammenhang. Und Regeln im Pfad: ein eigener Agent, der die Fachdomäne kennt, Pläne prüft, bevor sie wirken, Freigaben einholt, die kein Modell wegformulieren kann, und Nachweise erzeugt, die Fragen von übermorgen beantworten. Erst auf dieser Stufe ist aus der Empfehlung eine Regel geworden, die auch dann hält, wenn niemand hinschaut.
Was diese Folge bewusst offenlässt: den Weg dorthin. Die Regeln einer Fachdomäne liefert kein installiertes Produkt automatisch mit – sie entstehen in der Auseinandersetzung mit der Domäne selbst, und die wirft sofort praktische Fragen auf. Wie findet ein Team heraus, welche Regeln in den Pfad gehören und welche Prosa bleiben dürfen? Wie schneidet man die erste Domäne, ohne sich zu verheben? Welche Konzepte, Methoden und Prozesse tragen dabei – und welche Moden kann man getrost auslassen? Von diesen Hilfsmitteln handelt die nächste Folge.
## Was SubKit dazu beiträgt
[SubKit](https://subkit.mikebild.dev/de/) ist mein Werkzeug für wiederkehrende Abläufe: Ein Assistent entwirft den Workflow, eine Person prüft ihn und gibt seine Reichweite frei. Die Ausführung folgt den festgelegten Schritten; Rechte und Ergebnisse werden nachvollziehbar. KI-Clients können freigegebene Workflows über MCP als Werkzeuge nutzen.
Das ersetzt nicht die Modellierung der Fachdomäne. Eine fallbezogene Kulanzgrenze, gemeinsam genutzter Vorgangszustand und der Umgang mit parallelen Anfragen müssen im jeweiligen Ablauf und den angebundenen Systemen ausdrücklich umgesetzt werden. SubKit liefert dafür nicht automatisch die Geschäftsregeln. Die [Anwendungsfälle](https://subkit.mikebild.dev/de/anwendungsfaelle/) zeigen mögliche Einstiege; die Rolle der Schnittstelle erläutert der Artikel [MCP: Wenn Software Fähigkeiten anbietet](https://www.mikebild.dev/de/blog/mcp-softwarefaehigkeiten-agenten/).
## Weiterführende Quellen
- [Terraform: plan und apply](https://developer.hashicorp.com/terraform/cli/commands/plan) – die Trennung von Vorschlag und Wirkung im Infrastruktur-Alltag
- [OWASP Top 10 für LLM-Anwendungen: Excessive Agency](https://genai.owasp.org/llmrisk/llm062025-excessive-agency/) – zu viele Tools, zu weite Rechte, zu viel Autonomie
- [Simon Willison: The lethal trifecta](https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/) – warum die Kombination aus Datenzugriff, Fremdinhalten und Außenkommunikation gefährlich ist
- [Domain-Driven Design Reference (Eric Evans)](https://www.domainlanguage.com/ddd/reference/) – Fachsprache und Domänenschnitt als Entwurfsarbeit
---
# MCP-Sicherheit: Tools, Rechte und Freigaben für KI-Agenten
URL: https://www.mikebild.dev/de/blog/mcp-softwarefaehigkeiten-agenten/
Datum: 2026-07-13
# MCP-Sicherheit: Tools, Rechte und Freigaben für KI-Agenten
Ein MCP-Tool kann Daten lesen, eine Revision veröffentlichen oder einen externen Dienst aufrufen. Damit wird aus einer Modellantwort eine Handlung mit Folgen. Für Entwickler und Betreiber lautet die Sicherheitsfrage deshalb: Wer darf welche Operation ausführen, an welchen Daten und nach welcher Freigabe?
Das Model Context Protocol standardisiert die Verbindung zu solchen Fähigkeiten. Die Regeln deiner Anwendung musst du weiterhin selbst durchsetzen. Dieser Artikel zeigt das an einem konstruierten Publishing-Beispiel: dieselben Rechte über Weboberfläche, HTTP und MCP, eine überprüfbare Freigabe vor der Veröffentlichung und ein nachvollziehbarer Umgang mit Wiederholungen und fremden Inhalten.
Zur Einordnung der Schnittstellen findest du hier die [Unterschiede zwischen MCP, HTTP, Webhooks und A2A](/de/blog/mcp-http-webhooks-a2a-einfach-erklaert/).
## Nicht die App, sondern die Fähigkeit
Das Model Context Protocol ist ein offener Standard, mit dem KI-Anwendungen externe Systeme anbinden können. Die offizielle Dokumentation beschreibt MCP als Verbindung zwischen KI-Anwendungen und Datenquellen, Tools und Workflows. Die Spezifikation spricht von Hosts, Clients und Servern: Eine LLM-Anwendung ist der Host, darin sitzt ein Client, und ein Server stellt Kontext oder Fähigkeiten bereit.
Das klingt zunächst nach Integrationsinfrastruktur. Tatsächlich steckt darin eine größere Verschiebung. Eine Anwendung ist dann nicht mehr allein eine Oberfläche für Menschen. Sie ist zugleich eine Menge adressierbarer Fähigkeiten für Agenten.
Der klassische Bedienpfad sieht so aus:
```mermaid
flowchart LR
Human[Mensch] --> UI[Benutzeroberfläche]
UI --> App[Anwendung]
App --> Result[Ergebnis]
```
Der Mensch öffnet eine Oberfläche, sucht die richtige Stelle, füllt Felder aus, klickt auf Vorschau, klickt auf Veröffentlichen, prüft danach Feed und Suche. Die Anwendung ist das sichtbare Bündel aus Bedienung, Fachlogik und Zustand.
Mit einem Agenten kommt ein zweiter Pfad hinzu:
```mermaid
flowchart LR
Human[Mensch] --> Agent[Agent]
Agent --> Validate[validate_markdown]
Agent --> Preview[create_preview]
Agent --> Publish[publish_revision]
Agent --> Rollback[rollback_release]
Agent --> Search[rebuild_search_index]
```
Die Oberfläche verschwindet dadurch nicht, und sie wird auch nicht zweitrangig. Aber sie ist nicht mehr der einzige Zugang zur Arbeit. Ein Agent muss nicht wissen, wo der Button sitzt. Er muss wissen, welche Fähigkeit existiert, welche Eingaben sie erwartet, welche Ergebnisse zurückkommen und welche Regeln gelten.
Das ist der Kern: MCP macht Softwarefähigkeiten für Agenten adressierbar. Was es nicht tut: die Produktdomäne ersetzen oder ihre menschliche Bedienoberfläche verdrängen.
## Ein Publishing-System als Beispiel
Das folgende Publishing-System ist ein konstruiertes Architekturbeispiel, keine fertige Integration und kein Kundenfall. Der Ablauf ist vertraut: Markdown kommt hinein, eine Vorschau wird gebaut, jemand prüft sie, danach wird eine Revision veröffentlicht. Im Fehlerfall braucht es Rollback. Nach dem Release müssen Index, Feed und Cache stimmen.
In einer klassischen Oberfläche sind diese Schritte an Seiten und Buttons gebunden. Für Menschen ist das sinnvoll: Eine gute GUI zeigt Kontext, kann ungültige Eingaben blockieren und macht Zustände wie Freigabestände sichtbar. Für einen Agenten ist dieselbe Oberfläche dagegen Umweg und Fehlerquelle. Er müsste klicken, warten, aus HTML lesen, interpretieren, wieder klicken. Das ist Automatisierung auf der falschen Ebene.
Als MCP-Fähigkeit sähe derselbe Arbeitsschritt anders aus:
```ts
const publishRevision = defineTool({
name: "publish_revision",
description: "Publish an approved content revision",
inputSchema: {
type: "object",
properties: {
site: { type: "string" },
revisionId: { type: "string" },
reason: { type: "string" }
},
required: ["site", "revisionId", "reason"]
}
});
```
Der wichtige Teil ist nicht die konkrete Syntax. Der wichtige Teil ist die Verschiebung: Aus einem Bedienpfad wird eine benannte Fähigkeit. `publish_revision` ist nicht „klicke auf den grünen Button“. Es ist eine fachliche Operation mit Eingaben, Ergebnis, Rechten und Fehlern.
Sobald die Operation so vorliegt, kann ein Agent damit arbeiten. Er kann vorher `validate_markdown` aufrufen, bei Warnungen zurückfragen, eine Vorschau anfordern, den Freigabestand prüfen und erst danach veröffentlichen. Der Agent bedient dabei keinen Bildschirm. Der hier beschriebene MCP-Server stellt ihm fachliche Werkzeuge mit Eingabeschema und Berechtigungsprüfung bereit.
## Drei Zugänge, eine Domäne
Ein solches Publishing-System kann unter `/mcp` eine domänenorientierte Werkzeugoberfläche bereitstellen, die über dieselbe Veröffentlichungsdomäne läuft wie REST und die Weboberfläche. Die MCP-Werkzeuge bleiben dabei an die Produkt-Scopes gebunden.
Entscheidend ist, was diese Konstruktion nicht ist: MCP ist kein zweites System neben dem Produkt. Weboberfläche, HTTP und MCP greifen auf dieselbe Veröffentlichungsdomäne mit ihren Revisionen und Berechtigungsgrenzen zu. Die gemeinsame Domänenlogik entscheidet, was gilt – nicht der Kanal, über den die Anfrage kam.
Das hat eine praktische Folge für die Werkzeugliste selbst. Werkzeuge, die der aktuelle Principal nicht verwenden darf, müssen gar nicht erst in der Liste erscheinen. Der Agent entdeckt also nur Fähigkeiten, die seine Scopes hergeben. Und wo eine menschliche Freigabe vorgesehen ist, liefert der Agent diese Freigabe nicht selbst – sie bleibt ein eigener Schritt außerhalb seiner Reichweite.
Diese Filterung ist mehr als Komfort, aber sie ist Sichtbarkeit, nicht der eigentliche Schutz. Ein Agent, der ein Werkzeug nicht in der Liste sieht, entdeckt es nicht auf regulärem Weg. Der Schutz vor unberechtigten Aufrufen entsteht durch die serverseitige Autorisierung; die Werkzeuge bleiben an die Scopes des jeweiligen Produkts gebunden. Ein fehlendes Release-Recht lässt sich deshalb auch nicht dadurch beschaffen, dass man von der Weboberfläche zu MCP wechselt. Der Zugang wechselt, die Berechtigung nicht.
## Tool-Zugriff ist eine Berechtigung
Ein Agent, der Text schreibt, kann Unsinn produzieren. Ein Agent, der Tools aufruft, kann Wirkung erzeugen. Er kann Daten lesen, Dateien ändern, Releases auslösen oder externe Systeme benachrichtigen. Deshalb ist Tool-Zugriff kein Komfortfeature, sondern eine Berechtigung. Dass ein Werkzeug auffindbar ist, ist noch keine Erlaubnis zur Wirkung; der Aufruf bleibt eine autorisierte Operation, die das System prüft. In einem Remote-MCP-Zugang sind diese Aufgaben verteilt: Die Zustimmung des Nutzers vor einem Tool-Aufruf ist nach der MCP-Spezifikation Sache des Hosts, während das Produkt jeden Aufruf serverseitig gegen die Scopes des Principals prüft.
Die MCP-Spezifikation sagt selbst, dass solche Fähigkeiten Sicherheits- und Vertrauensfragen mitbringen: Nutzer müssen Datenzugriff und Operationen verstehen und kontrollieren können, Tools sind mit Vorsicht zu behandeln, Hosts müssen Zustimmung vor Tool-Aufrufen einholen. Zustimmung und Zugriffskontrolle gehören deshalb in den Ausführungspfad jedes Tool-Aufrufs.
In einem produktiven System reicht deshalb eine Tool-Definition nicht aus. Daneben gehört eine Policy:
```ts
type ToolPolicy = {
tool: string;
allowedRoles: string[];
requiresApproval: boolean;
requiresIdempotencyKey: boolean;
maxRuntimeMs: number;
};
type ToolAuditEntry = {
tool: string;
inputHash: string;
idempotencyKey?: string;
decision: "allowed" | "blocked" | "approved";
outcome: "succeeded" | "failed" | "unknown";
actorId: string;
runId: string;
};
```
Damit wird aus „der Agent darf veröffentlichen“ eine überprüfbare Regel. Wer durfte welchen Aufruf machen? Welche Eingabe wurde verwendet? War eine Freigabe nötig? Wurde der Aufruf ausgeführt oder blockiert? Bei schreibenden Operationen kommt eine weitere Frage hinzu: Was passiert, wenn der Agent nach einem Timeout denselben Aufruf wiederholt? Ein Idempotenzschlüssel hilft nur, wenn der Server ihn an die Operation und ihre Eingaben bindet, konkurrierende Wiederholungen abfängt und das Ergebnis zuverlässig speichert. Bei externen Nebenwirkungen muss auch der nachgelagerte Dienst Wiederholungen erkennen oder das System den unklaren Ausgang abgleichen. Ein Schlüssel allein garantiert keine einmalige Ausführung.
MCP standardisiert Auffindbarkeit und Aufruf eines Tools. Es macht die Operation weder fachlich sicher noch automatisch idempotent oder auditierbar. Diese Eigenschaften muss die angebotene Fähigkeit selbst tragen.
## Prompt Injection: Inhalte dürfen keine Rechte vergeben
Ein eingelesener Artikel kann Anweisungen enthalten, etwa eine andere Revision zu veröffentlichen oder Daten an eine fremde Adresse zu schicken. Behandle solche Inhalte als nicht vertrauenswürdige Daten. Ein Prompt, der das Modell zum Ignorieren auffordert, ist keine ausreichende Zugriffskontrolle. Die erlaubten Operationen, Zieladressen und Freigaben müssen außerhalb des gelesenen Dokuments geprüft werden.
Auch Tool-Beschreibungen und Kennzeichnungen wie „nur lesend“ sind kein Beweis für das tatsächliche Verhalten eines fremden Servers. Prüfe, welchen Server du verbindest und welche Rechte du ihm gibst. Die [Sicherheitsgrundsätze der MCP-Spezifikation](https://modelcontextprotocol.io/specification/2025-06-18#security-and-trust--safety) benennen diese Vertrauensgrenze ausdrücklich.
Für einen Remote-MCP-Server kommt die Absicherung der Anmeldung hinzu: Prüfe, ob ein Zugriffstoken für deinen Server bestimmt ist; reiche empfangene Tokens nicht ungeprüft an nachgelagerte Dienste weiter. Fordere nur die benötigten Rechte an. Diese Maßnahmen und die Risiken von Token-Weitergabe beschreibt die offizielle Dokumentation zu [MCP Security Best Practices](https://modelcontextprotocol.io/docs/2025-11-25/tutorials/security/security_best_practices).
Für das Publishing-Beispiel würde ich vor dem Betrieb mindestens folgende Fälle prüfen:
- Ein Nutzer ohne Veröffentlichungsrecht ruft das Tool direkt auf: Der Server lehnt ab, auch wenn der Tool-Name bekannt ist.
- Eine Freigabe gilt für Revision A, der Aufruf nennt Revision B: Der Server lehnt ab.
- Ein Dokument verlangt den Versand an eine fremde Adresse: Die konfigurierte Grenze bleibt wirksam.
- Ein Aufruf läuft in einen Timeout: Vor einem erneuten Schreibversuch wird sein Ergebnis geklärt oder die Wiederholung wirksam dedupliziert.
- Eine fehlgeschlagene oder abgelehnte Operation erscheint im Verlauf mit ihrem tatsächlichen Ergebnis.
Das ist eine Prüfliste für dieses Architekturbeispiel, kein vollständiger Sicherheitsnachweis.
## Der falsche und der richtige Schnitt
Ich glaube nicht, dass Anwendungen in kleine MCP-Dienste zerfallen und danach keine Produkte mehr sind. Eine gute Anwendung bündelt mehr als Funktionen: Sie bündelt Verständnis, Bedienung, Datenmodell, Rechte, Feedback und Verantwortung. Aber an den Rändern werden Fähigkeiten einzeln adressierbar, die bisher an Bedienpfade gebunden waren.
Eine Fähigkeit ist gut geschnitten, wenn sie fachlich verständlich, technisch prüfbar und betrieblich verantwortbar ist. Der falsche Schnitt wäre ein generisches `run_sql` oder `click_button` – ein Werkzeug, das die Fachregeln umgeht, statt sie zu tragen. Der bessere Schnitt ist eine Operation mit Fachabsicht: `publish_revision`, `rollback_release`, `create_preview`. Der Agent soll nicht an der Datenbank vorbeiarbeiten. Er soll innerhalb derselben Regeln arbeiten, die auch für Weboberfläche und HTTP gelten.
Ein Standard nimmt dabei Integrationsarbeit weg, aber keine Produktverantwortung. Anthropic hat MCP Ende 2024 gegen genau das Problem eingeführt, dass jede neue Datenquelle eine eigene Anbindung brauchte. Die Spezifikation standardisiert den Austausch über JSON-RPC und beschreibt Resources, Prompts und Tools. Schlechte Fähigkeiten bleiben schlecht, auch wenn sie standardisiert angeboten werden.
## Was mit Bedienoberflächen passiert
Die stärkste Version der Zukunftsthese lautet: Wenn Agenten Software bedienen, werden GUIs zweitrangig. Ich halte das für falsch.
Routinepfade werden sich verschieben. Wenn ich einem Agenten sagen kann, er soll einen Entwurf prüfen, eine Vorschau bauen und mir nur die Abweichungen zeigen, dann will ich dafür nicht durch fünf Masken klicken. Das gilt besonders für wiederkehrende Arbeit, die gut beschrieben und sauber begrenzt ist.
Aber Menschen brauchen Oberflächen für Exploration, Kontrolle, Ausnahmefälle und Vertrauen. Eine Vorschau ist eine GUI. Ein Diff ist eine GUI. Ein Audit-Log ist eine GUI. Ein Freigabedialog ist eine GUI. Gerade wenn Agenten mehr ausführen, werden gute Kontrolloberflächen wichtiger. Die Kontrolloberfläche dient dazu, dass ein Mensch versteht, was ein Agent getan hat, und dort eingreift, wo sein Urteil gefragt ist.
Kontrolloberfläche und MCP konkurrieren also nicht um dieselbe Aufgabe. Die Kontrolloberfläche richtet sich an menschliche Bedienung und Kontrolle, MCP an agentische Aufrufe. Für beide gelten die Berechtigungsgrenzen derselben Domäne.
## Was ich daraus mitnehme
MCP ist für mich weniger eine spektakuläre Technik als ein guter Anlass, Software anders zu beschreiben. Nicht allein über die Daten, die ein System hält, und nicht allein über die Oberfläche, die es anbietet – sondern über die Arbeit, die es sicher, nachvollziehbar und prüfbar erledigen kann.
Das ist eine Architekturfrage. Wer Fähigkeiten nur als dünne Hülle um interne Funktionen veröffentlicht, baut wahrscheinlich neue Risiken. Ein fachlicher Schnitt, Rechte, Idempotenz und Auditierbarkeit schaffen eine kontrollierbare Grundlage für Agenten – eine Qualitätsgarantie sind sie nicht.
Nicht jede Anwendung braucht sofort einen MCP-Server. Viele Systeme sind mit einer guten API, einem CLI oder einer klaren Oberfläche besser bedient. Wo es passt, gilt aber: Software, die von Agenten genutzt werden soll, muss ihre Fähigkeiten explizit machen – und sie muss dieselben Berechtigungsgrenzen über jeden Zugang durchsetzen.
## Wo SubKit dazu passt
Bei [SubKit](https://subkit.mikebild.dev/de/) hilft die KI beim Entwerfen eines Workflows. Eine Person prüft die Vorschau und gibt seine Reichweite frei. Danach läuft der festgelegte Workflow; die KI entscheidet beim Ausführen nicht über den weiteren Weg. Jeder Lauf wird auf Rechte geprüft und aufgezeichnet.
MCP wird in beide Richtungen genutzt: Ein Workflow kann als Tool für einen KI-Client dienen; ein externer MCP-Server kann als Konnektor angebunden werden. Welche externen Tools verwendet werden dürfen, wird dabei gesondert festgelegt. Der zusätzliche Zugang ersetzt weder die Freigabe noch die Rechte der aufrufenden Person.
Das ist ein konkreter Produktbezug, keine Behauptung, dass SubKit jeden MCP-Server sicher macht oder fachliche Regeln automatisch kennt. Die Regeln deiner Domäne und die Rechte externer Systeme bleiben zu prüfen. Wie solche Regeln von Modellentscheidungen getrennt werden können, vertieft der Artikel [KI-Agenten pro Fachdomäne: Regeln, Freigaben und Nachweise](/de/blog/eigener-agent-pro-fachdomaene/).
:::note
**Einordnung und Quellenstand**
Das Publishing-System und die Codeausschnitte sind konstruiert und illustrieren Architekturentscheidungen. Der Beitrag verwendet die MCP-Spezifikation vom 18. Juni 2025 und die verlinkten Security Best Practices. Die Sicherheitsabschnitte wurden am 9. November 2026 gegen diese Primärquellen geprüft; daraus folgt keine Aussage über die Sicherheit einer konkreten Installation. Der SubKit-Abschnitt beruht auf der bestätigten Produktbeschreibung vom 8. November 2026.
:::
## Weiterführende Quellen
- [Model Context Protocol: Spezifikation 2025-06-18](https://modelcontextprotocol.io/specification/2025-06-18)
- [Model Context Protocol: Security Best Practices](https://modelcontextprotocol.io/docs/2025-11-25/tutorials/security/security_best_practices)
- [Model Context Protocol: Einführung](https://modelcontextprotocol.io/docs/getting-started/intro)
- [SubKit: Workflows, Freigaben und Betrieb](https://subkit.mikebild.dev/de/)
---
# Agent, Modell, Fachdomäne
URL: https://www.mikebild.dev/de/blog/agent-modell-fachdomaene/
Datum: 2026-07-13
Vor einiger Zeit saß ich in einem großen Konzern in einer Runde, die eine „Agenten-Strategie“ für das kommende Jahr beschließen sollte. An der Wand eine Folie mit drei Spalten: drei Anbieter, darunter Häkchen für Funktionen, Preise pro Nutzer, Compliance-Siegel. Eine Stunde lang drehte sich das Gespräch um die Frage, welcher Agent der beste sei. Irgendwann habe ich eine andere Frage gestellt: Was von alledem gehört uns hinterher eigentlich? Wenn wir in drei Jahren den Anbieter wechseln – was nehmen wir mit? Es wurde still. Nicht, weil die Frage besonders originell gewesen wäre, sondern weil die Folie auf sie keine Antwort hatte.
*Teil 10 der Serie „Von der Session zum System“ – hier geht es [zum Auftakt](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/).*
Die [letzte Folge](https://www.mikebild.dev/de/blog/wissen-das-die-session-ueberlebt/) endete mit der Frage, wem ich kuratiertes Wissen in die Hand gebe – und wo der generische Agent an seine Grenzen kommt. Um sie zu beantworten, muss ich zuerst auseinandernehmen, was in dem Wort „Agent“ alles zusammengepackt wird. Denn die stille Minute im Konferenzraum hatte einen einfachen Grund: Die Runde hat über Agenten gesprochen wie über ein Gerät, das man kauft, aufstellt und benutzt. Dieses Bild führt in die Irre – und zwar genau an der Stelle, an der es fürs Unternehmen teuer wird.
## Ein Agent ist Software
Was ein Agent wirklich ist, lässt sich in einem Satz sagen. Simon Willison formulierte im Herbst 2025 eine dafür brauchbare Arbeitsdefinition: Ein Agent ist ein Modell, das in einer Schleife Tools aufruft, um ein Ziel zu erreichen. Mehr steckt nicht dahinter. Kein Bewusstsein, keine Absicht, keine Magie.
Da ist eine Schleife: Das Modell bekommt eine Aufgabe und den bisherigen Verlauf, schlägt den nächsten Schritt vor, der Agent führt ihn aus, das Ergebnis fließt zurück – bis eine Stoppbedingung greift. Da sind Tools: Funktionen, die der Agent dem Modell anbietet und deren Aufrufe er ausführt. Da ist Kontext: alles, was der Agent dem Modell mitgibt, von Dateien über Suchergebnisse bis zu Instruktionen. Da ist Zustand: was zwischen den Schritten und über die Session hinaus erhalten bleibt. Und da sind Rechte: was der Agent überhaupt ausführen darf, mit wessen Berechtigungen, mit welchen Nachweisen.
Jedes einzelne dieser fünf Dinge ist gewöhnliche Software. In Folge 3 habe ich beschrieben, dass genau dieser Rahmen – der Harness – den Unterschied zwischen einem beeindruckenden und einem brauchbaren Werkzeug ausmacht. Damals meinte ich das persönlich: mein Rechner, meine Werkzeuge, meine Arbeitsweise. Heute lese ich denselben Satz organisatorisch. Was für meine Kommandozeile gilt, gilt für das Unternehmen erst recht: Das Modell erzeugt Ausgaben, etwa Vorschläge, Klassifikationen und Formulierungen. Der Agent bestimmt Schleife, Kontext, Zustand, Rechte und Tool-Anbindung. Diese Teile lassen sich gestalten.
## Was man mietet und was man kontrollieren kann
Diese Arbeitsteilung lohnt einen genauen Blick, weil sie ökonomisch zwei völlig verschiedene Dinge beschreibt.
Ein proprietäres Modell, das man über die API eines Anbieters bezieht, mietet man: Es gehört dem Anbieter, und über Versionswechsel bestimmt man nur in dem Rahmen mit, den API-Vertrag und Anbieter vorgeben. Man besitzt daran nichts – und das ist verkraftbar, wenn mehrere Modelle die eigenen, konkret geprüften Aufgaben hinreichend gut lösen. Wer seine Strategie auf „das beste Modell“ baut, baut auf etwas, das er weder besitzt noch kontrolliert. Den ausführlichen Gedanken dazu habe ich [früh in dieser Serie](https://www.mikebild.dev/de/blog/gut-genug-modelle/) beschrieben.
Der Agenten-Layer kann dagegen unter eigener Kontrolle stehen. Die Schleife, der Kontextaufbau, der Zustand, die Rechte, vor allem die Tools – all das kann eigener Code und eigene Konfiguration sein, versionierbar, testbar und überprüfbar. Auch die Anbindung wird weniger proprietär: MCP liegt seit Dezember 2025 zusammen mit AGENTS.md und goose bei der Agentic AI Foundation unter dem Dach der Linux Foundation. Eine Garantie, dass jeder Anbieter dieselben Fähigkeiten auf dieselbe Weise bereitstellt, ist das nicht.
```mermaid
flowchart TB
subgraph rented["gemietet – austauschbar"]
M["Modell Vorschläge · Klassifikation · Sprache"]
end
subgraph owned["gestaltbar – unter eigener Kontrolle"]
A["Agent Schleife · Kontext · Zustand · Rechte"]
W["Tools und Schnittstellen typisierte Operationen"]
F["Fachdomäne Begriffe · Regeln · Abläufe"]
A --> W
W --> F
end
A -- "fragt an" --> M
M -- "schlägt Schritte vor" --> A
```
Wenn das Modell gemietet und die Anbindung zunehmend standardisiert ist, bleibt ein besonders wichtiger eigener Anteil: das, was ein Unternehmen in den Agenten hineinlegt. Seine Begriffe, seine Regeln, seine Abläufe, seine Daten – kurz: seine Fachdomäne. Damit steht die Frage dieses Beitrags im Raum. Wo liegt die Fachdomäne?
## Variante A: die Fachdomäne als Prosa
Der naheliegende Ort ist der Prompt. In der Praxis heißt das: Instruktionsdateien wie CLAUDE.md oder AGENTS.md, Systemprompts, angehängte Richtlinien-Dokumente. Dort steht dann so etwas wie: „Gutschriften über 500 Euro darf nur eine Teamleitung auslösen. Kunden im laufenden Mahnverfahren erhalten keine Kulanzgutschrift. Preisänderungen gelten erst ab dem Folgemonat.“
Ich will diese Variante nicht kleinreden. Sie ist schnell: Wenn es einen freigegebenen Pflegeweg gibt, kann die Fachabteilung den Text ändern, ohne die Fachanwendung anzufassen. Die geänderte Fassung steht dem Modell zur Verfügung, sobald der Agent sie lädt. Für exploratives Arbeiten reicht das oft – und am Anfang ist es fast immer der richtige Weg, weil man erst einmal herausfinden muss, welche Regeln überhaupt gebraucht werden.
Aber sie ist fragil, und zwar strukturell, nicht bloß handwerklich. Erstens ist Prosa ungeprüft: Niemand validiert sie, kein Compiler meldet, dass Satz 12 und Satz 47 sich widersprechen, keine Typprüfung merkt, dass „500 Euro“ an einer Stelle brutto und an der anderen netto gemeint war. Zweitens ist Prosa für das Modell eine Empfehlung, kein verlässlicher Enforcement-Mechanismus – das war die zentrale Ernüchterung meiner vergeblichen Versuche mit Instruktionsdateien: Das Modell kann Anweisungen befolgen, ihre Einhaltung lässt sich damit aber nicht erzwingen. Drittens greift die Session-Lotterie: Derselbe Satz wird heute beachtet und morgen überlesen, je nachdem, was sonst noch im Kontext liegt. Und viertens – im Unternehmen wiegt das am schwersten – lässt sich zwar die Datei versionieren, aber nicht das Verhalten. Die Instruktionsdatei allein stellt keine deterministische, blockierende Prüfung bereit, die eine regelwidrige Gutschrift verhindert; ohne zusätzliche Prüfung fällt der Verstoß erst hinterher auf.
Prosa skaliert mit der Menge des Wissens. Sie skaliert nicht mit dessen Verbindlichkeit.
## Variante B: die Fachdomäne als Schnittstelle
Die Alternative: das Fachwissen nicht neben den Agenten legen, sondern in seine Tools einbauen. Statt dem Modell generischen Datenbank- und Dateizugriff zu geben und die Regeln als Text daneben zu stellen, bekommt der Agent typisierte Operationen, deren Namen aus der Fachsprache kommen und deren Eingaben geprüft werden:
```ts
const issueCreditNote = defineTool({
name: "issue_credit_note",
description: "Issue a credit note for an existing invoice",
input: z.object({
invoiceId: z.string(),
amount: z.number().positive(),
reason: z.enum(["complaint", "goodwill", "pricing_error"]),
}),
authorize: ({ user, input }) =>
input.amount <= 500 || user.hasRole("team_lead"),
execute: (input, ctx) => billing.issueCreditNote(input, ctx.audit),
});
```
Der Unterschied ist grundsätzlicher, als der kurze Codeblock aussieht. Die 500-Euro-Regel ist keine Bitte mehr, sondern Code: Sie wird bei jedem Aufruf geprüft, in jeder Session gleich, unabhängig von Tagesform und Kontextlage des Modells. Es gibt sie genau einmal, sie hat einen Besitzer, ein Review, einen Test. Die KI formuliert, die Schnittstelle entscheidet, was überhaupt möglich ist.
Das ist die konsequente Fortsetzung von zwei Gedanken aus den letzten Folgen. In [Folge 8](https://www.mikebild.dev/de/blog/sauberes-grounding-antworten-erden/) ging es darum, Antworten zu erden: nachschlagen statt raten, echte Quellen statt plausibler Vermutungen. Ein Tool ist geerdetes Wissen in ausführbarer Form – der Agent muss die Gutschriften-Regeln nicht erraten, er kann nur innerhalb von ihnen handeln. Und in [Folge 9](https://www.mikebild.dev/de/blog/wissen-das-die-session-ueberlebt/) ging es um Wissen, das die Session überlebt: Eine Tool-Definition überlebt sie von selbst, weil sie Teil des Systems ist und nicht Teil des Gesprächs.
Die Tool-Namen schließen dabei direkt an Domain-Driven Design an: Sie werden zur verbindlichen Fachsprache. Was Eric Evans vor gut zwanzig Jahren „ubiquitous language“ nannte – eine gemeinsame, präzise Sprache zwischen Fachbereich und Entwicklung – bekommt eine sehr handfeste Existenzform. Wenn `issue_credit_note` und `waive_dunning_fee` die einzigen Verben sind, die der Agent kennt, muss die Organisation sich einigen, was diese Verben genau bedeuten. Das Modellieren der Tools ist Domänenarbeit, keine Infrastrukturarbeit. Die Schnittstelle kann Eingaben und Berechtigungen einzelner Aufrufe verlässlich prüfen; Ablaufregeln über mehrere Aufrufe brauchen zusätzliche Zustandsprüfung und gegebenenfalls eine Prüfung des geplanten Ablaufs.
## Die Gegenrechnung
So weit die Chance. Zur selben Rechnung gehören Lock-in, Pflegeaufwand, Verantwortung und Übersteuerung.
Da ist zuerst der Lock-in. Tool-Definitionen, Skill-Formate, Agent-Konfigurationen folgen heute Anbieter-Konventionen. MCP normt den Transport, nicht die Semantik: Das Protokoll legt fest, wie ein Tool aufgerufen wird, nicht, wie meine Gutschriften-Logik strukturiert ist. Wer seine Fachlogik direkt in die Formate eines Agent-Frameworks gießt, hat sie in drei Jahren genau dort liegen – und der Umzug kostet. Das Gegenmittel ist ein altes: die Fachlogik in eigene Dienste legen und die Tool-Schicht als dünnen Adapter bauen. Aber das muss man tun, es passiert nicht von allein, und unter Termindruck passiert regelmäßig das Gegenteil.
Dann der Pflegeaufwand. Eine eigene Tool-Schicht verursacht dauerhaften Pflege- und Betriebsaufwand. Fachregeln ändern sich: Aus der 500-Euro-Schwelle werden 300, ein neuer Gutschriftsgrund kommt dazu, eine Rolle wird umgebaut. Jemand muss das pflegen, priorisieren, testen und ausrollen – neben allem anderen. Die Prosa-Variante war auch deshalb so verführerisch, weil sie diesen Aufwand versteckt hat. Die Tool-Variante macht ihn sichtbar, und Sichtbarkeit fühlt sich zunächst wie Verteuerung an, obwohl der Aufwand vorher nur woanders lag: in den Korrekturen hinterher.
Drittens Prüfbarkeit und Verantwortung. Wer haftet für eine Tool-Definition? Die Frage klingt juristisch, ist aber vor allem organisatorisch. Bei rein beratender Nutzung kann ein Mensch die Antwort verwerfen. Darf der Agent Tools ohne Freigabe ausführen, kann ein Fehler in deren Autorisierung unmittelbar wirken: Eine falsche Obergrenze gilt dann verlässlich falsch, in jeder Session, für jeden Nutzer. Tool-Definitionen brauchen deshalb dieselbe Sorgfalt wie jede produktive Schnittstelle: Review, Tests, klare Zuständigkeit, Änderungshistorie. Und die Verantwortung verschiebt sich spürbar: weg vom Einzelnen, der einen Prompt formuliert hat, hin zum Team, das das Tool definiert hat. Das ist konsequent und richtig – aber eine Organisation muss das wollen, entscheiden und aushalten.
Und schließlich die Übersteuerung. Es ist verlockend, nach dem ersten Zwischenfall jede denkbare Abweichung wegzudefinieren, bis der Agent nur noch einen einzigen, engen Pfad kennt. Dann hat man ein Formular gebaut, mit einer Chat-Oberfläche davor – teurer, langsamer und launischer, als das Formular es gewesen wäre. Die Stärke des Modells liegt gerade im Unvorhergesehenen: im Sonderfall, in der Rückfrage, im Zusammenhang zwischen zwei Vorgängen, an den beim Entwurf niemand gedacht hat. Wer dem Agenten nur Tools für das Erwartbare gibt, hätte klassische Automatisierung billiger haben können. Zu enge Tools können Risiken begrenzen, aber auch so viel Handlungsspielraum nehmen, dass klassische Automatisierung die passendere Lösung wäre.
## Wann generische Tools reichen – und wann nicht
Für meine Entscheidung sind vier Kriterien maßgeblich: die Art der Arbeit, die Verantwortlichen, das Schadenspotenzial und der Reifegrad des Fachwissens. Generische Tools – Dateizugriff, Shell, Suche – reichen erstaunlich weit, solange ein paar Bedingungen zusammenkommen:
- Die Arbeit ist explorativ: analysieren, prototypisieren, recherchieren, migrieren – Aufgaben, deren Ergebnis ohnehin ein Mensch begutachtet.
- Es arbeitet eine Einzelperson, die das Ergebnis selbst verantwortet und selbst beurteilen kann.
- Das Schadenspotenzial ist klein: alles reversibel, nichts verlässt das Haus, kein Geld bewegt sich.
- Das Fachwissen ist noch im Fluss – es wäre schlicht zu früh, es in Schnittstellen zu gießen.
Umgekehrt gehört die Fachdomäne in den Agenten, sobald sich das Bild dreht:
- Ein Ablauf wiederholt sich im Team: dieselbe Operation, viele Personen, unterschiedliche Sorgfalt und Erfahrung.
- Regeln sind verbindlich, nicht empfohlen – sie müssen auch am Freitagnachmittag um 17 Uhr gelten.
- Es gibt Audit- oder Nachweispflichten: Wer hat wann was ausgelöst, mit welcher Begründung?
- Das Schadenspotenzial ist hoch: Geld, personenbezogene Daten, Wirkung nach außen.
Dazwischen nutze ich einen pragmatischen Übergang: Die Prosa-Variante ist der Prototyp der Schnittstelle. Wenn dieselbe Regel zum dritten Mal in einer Instruktionsdatei auftaucht – und zum zweiten Mal ignoriert wurde –, ist sie für mich ein Kandidat für ein Tool. So wandert die Fachdomäne Stück für Stück von der Empfehlung in die Struktur, entlang ihrer tatsächlichen Verbindlichkeit statt entlang eines großen Vorabplans.
## Zwischenstand
Für mich verschiebt die bisherige Serie die Verantwortung von der Session zum System. Am Anfang stand die Session: die Erfahrung, dass die Modelle für meine Arbeit gut genug sind und der Unterschied in meinem eigenen Rahmen liegt – Tools, Kontext, Arbeitsweise. Dann kam das Team: die Ernüchterung, dass sich mein Arbeitserfolg nicht per Datei kopieren lässt und Instruktionsdateien Empfehlungen bleiben, so sorgfältig man sie auch schreibt. Dann das Wissen: sauberes Grounding statt überzeugendem Raten, kuratierte Erkenntnisse, die Sessions überleben. Und jetzt das System: die Einsicht, dass das Modell gemietet ist und gemietet bleibt – und dass der dauerhaft kontrollierbare Anteil im Agenten liegt. Genauer: in den Tools, mit denen der Agent die Fachdomäne berührt.
Offen bleibt die Frage, wie verbindliche Regeln über einzelne Tool-Aufrufe hinweg durchgesetzt werden. Tools entscheiden, was in einem einzelnen Aufruf möglich ist – darüber hinaus braucht es Freigaben, bevor etwas wirkt; Nachvollziehbarkeit, nachdem es gewirkt hat; ein Nein, das ein Nein bleibt, auch wenn das Modell freundlich weiterformuliert. Warum das am Ende auf einen eigenen, an die Fachdomäne gebundenen Agenten hinausläuft – und was der können muss –, ist einen eigenen Beitrag wert.
## Weiterführende Quellen
- [Building Effective AI Agents](https://www.anthropic.com/engineering/building-effective-agents) – Anthropics Unterscheidung von Workflows und Agenten
- [Writing effective tools for AI agents](https://www.anthropic.com/engineering/writing-tools-for-agents) – Tool-Design für Agenten aus der Praxis
- [Designing agentic loops](https://simonwillison.net/2025/Sep/30/designing-agentic-loops/) – Simon Willison über Schleifen, Tools und Stoppbedingungen
- [Model Context Protocol](https://modelcontextprotocol.io/) – Spezifikation und Dokumentation des Tool-Protokolls
- [Gründung der Agentic AI Foundation](https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation) – MCP, AGENTS.md und goose unter dem Dach der Linux Foundation
---
# Wissen, das die Session überlebt
URL: https://www.mikebild.dev/de/blog/wissen-das-die-session-ueberlebt/
Datum: 2026-06-23
Dienstagvormittag, dritte Session in dieser Woche. Ich tippe zum dritten Mal dieselbe Erklärung. Unser Fehlermodell unterscheidet zwischen erwartbaren und unerwarteten Fehlern; erwartbare Fehler kommen als Werte zurück, und um Serviceaufrufe sollen keine try/catch-Kaskaden entstehen. Die Session davor wusste das. Sie hatte es verstanden, angewendet und sogar einen Grenzfall sauber gelöst, auf den ich selbst nicht gekommen wäre. Jetzt sitze ich wieder in einer neuen Session ohne diese Erklärung und schreibe sie noch einmal, mit anderen Worten, etwas ungeduldiger als beim letzten Mal.
*Teil 9 der Serie „Von der Session zum System“ – hier geht es [zum Auftakt](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/).*
Das ist die Session-Amnesie als Alltagserfahrung. Nicht als theoretisches Problem von Kontextfenstern und Token-Budgets, sondern als das leise Ärgernis, dass ich mit einem Werkzeug arbeite, das jeden Morgen zum ersten Mal von mir hört. Die Anbieter arbeiten daran. Stand August 2026 gibt es dafür unterschiedliche Speichermechanismen: Anthropics Memory Tool erlaubt Agenten, Informationen außerhalb des unmittelbaren Kontextfensters dateibasiert abzulegen und später wieder zu laden; Claude Code stellt Projektanweisungen über hierarchische CLAUDE.md-Dateien und persönliche Notizen über Auto Memory bereit, beides über Sessions hinweg. Persönliches Auto Memory setzt dabei bei der einzelnen Person an; gemeinsam gepflegte CLAUDE.md-Dateien wären davon zu unterscheiden. Die Variante des Problems, die mich wirklich beschäftigt, löst keine dieser Funktionen von allein.
Denn die Team-Variante ist schlimmer. Mittwoch erzählt mir ein Kollege, er habe „seiner“ Session unser Fehlermodell erklärt. Ich frage nach, wie. Er hat es anders erklärt als ich. Nicht falsch – anders. Andere Begriffe, andere Beispiele, eine Nuance, die ich weglassen würde, eine, die mir fehlt. Ein dritter Kollege hat es gar nicht erklärt, weil er nicht wusste, dass es da etwas zu erklären gibt; seine Session hat try/catch-Kaskaden gebaut, und der Pull Request sah entsprechend aus. Vier Leute, vier private Erklärungen derselben Konvention, vier leicht verschiedene Ergebnisse. Das ist exakt das Varianzproblem, das ich in [„Mein Erfolg lässt sich nicht kopieren“](https://www.mikebild.dev/de/blog/mein-erfolg-laesst-sich-nicht-kopieren/) beschrieben habe – nur dass es hier nicht um Arbeitsweisen geht, sondern um Wissen. Jeder von uns füttert seine Sessions mit einer eigenen, mündlichen Überlieferung dessen, was das Team eigentlich gemeinsam wissen sollte. Persönliches Auto Memory ändert daran nichts: Es merkt sich meine Version der Erklärung, nicht unsere. Versionierte, gemeinsam gepflegte CLAUDE.md-Dateien wären der Ort für eine geteilte Version – aber nur, wenn das Team sie bewusst kuratiert.
Die Kernfrage dieser Folge ist also: Wie wird aus Session-Wissen Team-Wissen – und irgendwann Unternehmenswissen? Wie kommt das, was in einer guten Session entsteht, in die nächste Session eines anderen Menschen?
## Zwei Sorten von Wissen
Um darüber vernünftig zu reden, hilft mir eine Unterscheidung, die ich lange nur implizit mit mir herumgetragen habe: kuratiertes Wissen und emergentes Wissen.
Kuratiertes Wissen ist bewusst destilliert. Jemand hat sich hingesetzt, eine Erfahrung oder eine Entscheidung in Worte gefasst, jemand anderes hat es gegengelesen, und das Ergebnis steht an einem Ort, an dem es gefunden wird. Architektur-Entscheidungen in ADRs, Konventionen in einer CLAUDE.md oder AGENTS.md, ein Runbook für den Deployment-Sonderfall, der alle sechs Monate zuschlägt. Kuratiertes Wissen ist teuer – es kostet die Zeit eines Menschen, der es aufschreibt, und die eines zweiten, der es prüft. Dafür ist es adressierbar: Ich kann darauf zeigen, es verlinken, es einer Session mitgeben.
Emergentes Wissen entsteht nebenbei. In der Session vom Dienstag ist ein halbes Dutzend kleiner Erkenntnisse angefallen: dass unser Test-Setup eine Eigenheit beim Mocken des Message-Brokers hat, dass eine bestimmte Bibliothek in Version 4 ein anderes Default-Verhalten hat als in unserer Doku steht, dass mein Prompt-Zuschnitt für Refactorings besser funktioniert, wenn ich das Zielbild vor die Einschränkungen stelle. Nichts davon habe ich aufgeschrieben. Die Session endete, und mit ihr verdampfte alles, was nicht in Code oder Commit-Message gerann. Emergentes Wissen ist billig in der Entstehung – und für spätere Sessions nicht verlässlich verfügbar, sofern es nicht gespeichert wurde.
Das Gefälle zwischen beiden ist das eigentliche Problem. Teams produzieren in KI-Sessions heute mehr emergentes Wissen als je zuvor – jede Session ist ja ein kleines Labor, in dem jemand ausprobiert, formuliert, scheitert, nachjustiert. Und fast nichts davon überlebt. Was überlebt, ist der Code. Aber der Code enthält nur das Ergebnis, nicht die Begründung, nicht den verworfenen Irrweg, nicht die Formulierung, die den Knoten gelöst hat.
## Wissen wie Code behandeln
Das destillierte Arbeitswissen eines Teams verdient dieselbe Behandlung wie sein Code. Versioniert. Reviewt. Mit Ownership. Und mit einem Lebenszyklus, der auch das Sterben vorsieht. Darauf läuft diese Folge hinaus.
Das klingt erst einmal nach einer Banalität – Docs as Code bezeichnet die Behandlung von Dokumentation mit denselben versionierten Arbeitsweisen wie Quellcode, einschließlich Review und automatisierter Prüfungen. Aber im KI-Kontext bekommt jede dieser vier Eigenschaften eine neue Schärfe:
- Versioniert, weil das Wissen jetzt maschinell konsumiert wird. Wenn eine Instruktionsdatei sich ändert, kann sich das Verhalten der Sessions ändern, die sie laden. Solche Änderungen wirken auf das Verhalten des Systems – und Verhaltensänderungen gehören in die Historie, mit Diff und Datum und der Möglichkeit, zurückzugehen.
- Reviewt, weil eine falsche Konvention jetzt neben menschlichen Lesern auch mehrere Sessions in die Irre führt. Ein Mensch, der einen schlechten Wiki-Artikel liest, merkt oft, dass etwas nicht stimmt. Eine Session kann den Fehler nicht erkennen und die falsche Konvention anwenden, wie ich es in [„Sauberes Grounding II: Antworten erden“](https://www.mikebild.dev/de/blog/sauberes-grounding-antworten-erden/) beschrieben habe: Was im Kontext steht, wird zur Realität der Session, ob es stimmt oder nicht.
- Mit Ownership, weil herrenloses Wissen niemand pflegt. Jede Konventionsdatei, jedes Runbook braucht einen Menschen, der sich zuständig fühlt. Das ist keine Bürokratie – es ist die schlichte Antwort auf die Frage „Wen frage ich, ob das noch gilt?“.
- Mit Lebenszyklus, weil veraltetes Wissen schlimmer ist als keins. Das ist der Punkt, den ich am häufigsten unterschätzt sehe. Eine Session ohne passende Quelle kann raten oder nachfragen; eine Session mit veraltetem Grounding rät mit Quellenangabe. Sie zitiert die Konvention von 2024, die wir im Herbst gekippt haben, und klingt dabei so belegt, dass niemand nachprüft.
Der letzte Punkt verdient einen eigenen Absatz, weil er kontraintuitiv ist. Wir sind darauf trainiert, Dokumentation als „besser als nichts“ zu betrachten. Im KI-Kontext stimmt das nicht mehr. Falsches, altes, halbgares Wissen im Grounding einer Session ist aktiv schädlich, weil es die Ratlosigkeit des Modells in falsche Sicherheit verwandelt. Ein leeres Verzeichnis zwingt mich, nachzudenken, was die Session wissen muss. Ein volles, nie ausgemistetes Verzeichnis gaukelt mir vor, das sei erledigt. Deshalb gehört zum Lebenszyklus auch die regelmäßige Kontrolle gegen die Quellen: Gilt die Konvention noch? Beschreibt das Runbook noch das System, das läuft?
## Der Kreislauf
Wenn man die Sortierung ernst nimmt – emergentes Wissen entsteht ständig, kuratiertes Wissen wirkt – dann ergibt sich fast zwangsläufig ein Kreislauf. Aus diesen Beobachtungen leite ich vier Stationen ab.
Erstens: aus echten Läufen lernen. Nicht aus Meinungen, nicht aus Blogposts, sondern aus dem, was in den eigenen Sessions tatsächlich passiert ist. Welche Erklärung hat funktioniert? An welcher Stelle taucht dieselbe Rückfrage wiederholt auf? Welcher Fehler kommt in mehreren Pull Requests unabhängig voneinander vor? Das Rohmaterial liegt herum – man muss es nur als Rohmaterial erkennen.
Zweitens: ein Mensch kuratiert und gibt frei. Das ist die entscheidende Station, und sie ist bewusst nicht automatisiert. Destillieren heißt auswählen, verdichten, wegwerfen. Aus zehn Beobachtungen wird ein Absatz; aus einem Absatz wird vielleicht eine Zeile in der Konventionsdatei; acht der zehn Beobachtungen werden verworfen, weil sie Einzelfälle waren. Diese Entscheidung muss das Team treffen, weil nur es festlegen kann, was künftig verbindlich gilt: was bei uns Regel ist, was eine Ausnahme war und was ab morgen gelten soll. Und die Freigabe – ein zweites Paar Augen, ein echtes Review – macht aus einer privaten Notiz eine geteilte Verbindlichkeit.
Drittens: das Destillat fließt ins Grounding der nächsten Session. Es steht in der Datei, die jede Session liest, oder in der Wissensquelle, die beim Arbeiten herangezogen wird. Ab diesem Moment muss nicht mehr jeder Kollege „seiner“ Session das Fehlermodell mündlich und verschieden erklären – die Erklärung ist dieselbe, für alle, geprüft.
Viertens: die nächste Arbeit kann besser werden. Nicht dramatisch, nicht auf einen Schlag. Ob der Kreislauf wirkt, lässt sich an konkreten Fragen prüfen: Kommt die Rückfrage, die sich zuletzt wiederholt hat, seltener? Taucht der wiederkehrende Fehler in neuen Pull Requests noch auf? Und die nächsten Läufe produzieren neues Rohmaterial – idealerweise auf einem etwas höheren Niveau.
```mermaid
flowchart LR
A["Echte Läufe und Erfahrungen"] --> B["Beobachten und Rohmaterial sammeln"]
B --> C["Mensch kuratiert, Review gibt frei"]
C --> D["Destillat im Grounding der nächsten Session"]
D --> A
```
Das ist kein Framework und keine Zeremonie. Als Einstieg reicht ein regelmäßiger, kurzer Durchgang, in dem das Team bespricht, was hängen geblieben ist, plus die Disziplin, Änderungen an den Wissensdateien wie Code-Änderungen zu behandeln: Branch, Review, Merge. Wie viel Aufwand angemessen ist, hängt von Team, Umfang und Risiko ab.
## Nicht das Modell wird schlauer
Die Pointe dieses Kreislaufs ist mir erst mit der Zeit klar geworden, und sie hat meinen Blick auf die ganze Modell-Debatte verändert: In diesem Kreislauf wird nicht das Modell schlauer. Die Organisation lernt: Menschen wählen Erkenntnisse aus, begründen sie und machen sie für andere wiederverwendbar. Die ausgewählten Erkenntnisse schlagen sich als versionierte Änderungen des kuratierten Wissens nieder – nicht darin, dass ein Modell mehr Kontext behält.
Am Ende des Quartals hat das Modell von unseren Sessions nichts automatisch als Teamwissen behalten. Die angebotene Version kann sich in dieser Zeit durchaus geändert haben – unser Fehlermodell kennt sie deshalb noch lange nicht. Verbessert hat sich die Schicht darum herum: unser kuratiertes Wissen, unsere Erklärungen, die Qualität dessen, was wir jeder Session mitgeben. Und – das ist der entscheidende Unterschied – diese Schicht gehört uns. Wir können sie lesen, prüfen, korrigieren, zurückrollen. Wir können sie steuern. Welche Modellversion ein Anbieter ausliefert und wie sie sich verhält, können wir weit weniger beeinflussen.
Wer die Lernfähigkeit seiner KI-Arbeit im Modell verortet, hat deshalb ein Steuerungsproblem: Er wartet auf Fortschritt, den er nicht beeinflussen kann. Wer sie in der Kuratierung verortet, hat ein Arbeitsproblem – anstrengender, aber lösbar. Ich halte das für die nüchternste Antwort auf die Frage, wo ein Team investieren sollte: in den Teil, den es besitzt.
## Die Anti-Pattern
Was ich an Versuchen gesehen habe, Session-Wissen festzuhalten, ist überwiegend gescheitert. Und zwar auf drei wiedererkennbare Arten.
Die Prompt-Sammlung im Wiki. Irgendwer legt eine Seite an: „Unsere besten Prompts“. Drei Wochen lang wird eingezahlt, dann nie wieder. Nach einem halben Jahr enthält die Seite veraltete Prompts ohne Einsatzkontext: für Modelle, die keiner mehr benutzt, für Probleme, die keiner mehr hat, ohne Angabe, wann sie funktionieren und wann nicht. Niemand traut sich zu löschen, niemand mag pflegen. Der Fehler steckt schon in der Form: Ein Prompt ohne die Situation, für die er destilliert wurde, ist kein Wissen, sondern ein Souvenir.
Die Instruktionsdateien-Halde. Das habe ich in „Vergebliche Versuche: Skills, AGENTS.md und die Grenze der Empfehlung“ schon von einer anderen Seite beleuchtet: Konventionsdateien, in die jeder mal etwas hineinschreibt und aus denen nie etwas herausfällt. Nach einem Jahr sind es zweitausend Zeilen, in denen sich Regeln widersprechen, weil die von März die von Oktober nicht kennt. Die Sessions lesen alles und gewichten irgendwie – das Ergebnis ist Lotterie. Eine Wissensdatei ohne Löschdisziplin ist keine Wissensdatei, sondern ein Sedimentbecken.
Das Einmal-Aufgeschriebene. Die dritte Variante ist die leiseste: Ein motivierter Kollege schreibt in einer guten Woche alles auf – gründlich, strukturiert, wirklich brauchbar. Dann wird es nie wieder angefasst. Kein Ownership, kein Review-Rhythmus, kein Anlass, es zu aktualisieren. Zwölf Monate später können Teile davon veraltet sein, und weil niemand weiß, welche, traut niemand mehr dem Rest. Der einmalige Kraftakt ist der natürliche Feind des Kreislaufs: Er fühlt sich wie eine Lösung an und verhindert genau die Routine, die eine wäre.
Allen drei Mustern fehlt dasselbe: der Rückweg von der echten Arbeit ins Wissen. Sie behandeln Aufschreiben als Event statt als Kreislauf.
## Die Chance, die Arbeit kostet
Und trotzdem – oder gerade deshalb – halte ich diesen Moment für eine ungewöhnliche Gelegenheit. Organisationen reden seit Jahrzehnten davon, implizites Wissen zu explizieren. Wissensmanagement-Initiativen, Wikis, Communities of Practice: Meine These ist, dass ein fehlender unmittelbarer Abnehmer zum Versanden vieler dieser Initiativen beigetragen hat. Wer sein Wissen aufschrieb, schrieb für ein abstraktes „später“ und ein hypothetisches „jemand“. Die Rückkopplung fehlte; das Aufschreiben blieb ein Opfer ohne sichtbaren Ertrag.
Das ändert sich gerade. KI-Sessions bilden einen zusätzlichen unmittelbaren Abnehmer für explizites Wissen. Wer heute eine Konvention sauber destilliert, kann es in der nächsten Session prüfen: Verhält sich die KI anders? Hält der Pull Request die Konvention ein? Bleibt die bekannte Rückfrage aus? Die Rückkopplungsschleife, die in diesen Fällen fehlte, kann sich in solchen Arbeitsabläufen deutlich verkürzen. KI schafft damit einen unmittelbaren Anreiz, implizites Wissen zu explizieren – und die nächste Session liefert früh Hinweise darauf, ob das Aufgeschriebene trägt.
Ich will die Kritik daran nicht unterschlagen. Kuratieren kostet die Zeit genau der Leute, die am wenigsten davon haben. Es besteht die reale Gefahr, dass der Kreislauf ausufert und jede Zeile Konvention ein eigenes Freigabegremium durchlaufen muss. Und nicht jedes Wissen will eingefroren werden – manches ist absichtlich im Fluss, und wer es zu früh destilliert, zementiert einen Zwischenstand. Die Antwort darauf ist Maß, nicht Verzicht: klein anfangen, nur destillieren, was sich wiederholt hat, und das Löschen genauso ernst nehmen wie das Schreiben.
Was mich am Ende dieser Folge umtreibt, ist eine Frage, die eine Ebene tiefer liegt. Angenommen, der Kreislauf steht: Das Team kuratiert, das Wissen überlebt die Session, die Organisation lernt. Dann liegt da ein wachsender Bestand aus destillierten Konventionen, Fachbegriffen, Entscheidungen – und ich gebe ihn Session für Session einem generischen Assistenten in die Hand, der von meiner Fachdomäne nichts weiß und jedes Mal alles aus dem Kontext rekonstruiert. Irgendwann stellt sich die Frage, wem ich dieses Wissen eigentlich anvertraue: Reicht der generische Agent mit gutem Grounding – oder braucht die Fachdomäne ein Gegenüber, das für sie gebaut ist? Wo genau der generische Agent endet, ist die Frage der nächsten Folge.
## Weiterführende Quellen
- [AGENTS.md – das offene Format für Agenten-Instruktionen](https://agents.md/)
- [Anthropic: Memory Tool – Wissen über Sessions hinweg](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool)
- [Claude Code: How Claude remembers your project](https://code.claude.com/docs/en/memory)
- [Ikujiro Nonaka: The Knowledge-Creating Company (Harvard Business Review)](https://hbr.org/2007/07/the-knowledge-creating-company)
- [Write the Docs: Docs as Code](https://www.writethedocs.org/guide/docs-as-code/)
---
# Sauberes Grounding II: Antworten erden
URL: https://www.mikebild.dev/de/blog/sauberes-grounding-antworten-erden/
Datum: 2026-06-03
Vor ein paar Wochen saß ich mit einem Kollegen vor einem halbfertigen Integrationsstück. Die KI sollte einen Client für eine interne API schreiben, und sie tat, was sie immer tut: Sie schlug `customerId` vor. Das Feld heißt bei uns `customer_ref` – aus historischen Gründen, die niemand mehr verteidigt, aber jeder kennt. Wir hatten das dem Assistenten in dieser Woche schon zweimal erklärt. Diesmal habe ich etwas anderes gemacht: Ich habe ihm nicht widersprochen, sondern die OpenAPI-Beschreibung der API in den Kontext gegeben. Der nächste Vorschlag stimmte. Nicht ungefähr, sondern exakt – inklusive der etwas eigenwilligen Paginierung, die sich kein Modell der Welt hätte ausdenken können, weil sie schlicht eine Entscheidung von uns war. Gleiches Modell, gleicher Tag, gleiche Aufgabe. Der Unterschied: Es musste nicht mehr raten.
*Teil 8 der Serie „Von der Session zum System“ – hier geht es [zum Auftakt](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/).*
In der [letzten Folge](https://www.mikebild.dev/de/blog/sauberes-grounding-warum-ki-raet/) habe ich beschrieben, warum die KI so überzeugend rät: Ein Sprachmodell verweist mit Symbolen auf Symbole, nicht auf meine Systeme. Es kennt tausend APIs, die so ähnlich aussehen wie meine – und genau deshalb erfindet es plausibel. Das war die Diagnose. Diese Folge ist die konstruktive Seite: Wie gebe ich der KI meine Realität mit? Ich nenne das für mich sauberes Grounding – Antworten erden, statt sie in der Schwebe zu lassen. Und wie so oft ist der Kern weniger ein Werkzeug als eine Sortierung: Welches Wissen gibt es überhaupt, wo kommt es her, und wann gehört es in den Kontext?
## Mein Arbeitsmodell: drei Wissensschichten
Wenn ich mir anschaue, was meinen Antworten in der Praxis Boden gibt, lande ich immer wieder bei drei Schichten. Das ist meine Sortierung für diese Arbeit, keine allgemeine Taxonomie von Wissen. Die Schichten unterscheiden sich nicht allein im Inhalt, sondern in ihrem Charakter – und das ist der eigentliche Punkt.
```mermaid
flowchart TB
subgraph Schichten["Drei Wissensschichten"]
K["Konventionen wie wir arbeiten präskriptiv, kuratiert"]
D["Dokumente Runbooks, Specs, Entscheidungen deskriptiv, alternd"]
S["Schnittstellenbeschreibungen OpenAPI, GraphQL-Introspection, Schemas maschinell prüfbar"]
end
K --> E["Erdung beim Bauen und Vorbereiten"]
D --> E
S --> E
E --> A["Geprüftes Arbeitsergebnis Dokument, Plan, Code, konfigurierter Ablauf"]
```
Die erste Schicht sind unsere **Konventionen und Arbeitsweisen**. Das ist präskriptives Wissen: nicht „so ist die Welt“, sondern „so machen wir das hier“. Error Handling gehört an den Aufrufer, Migrationen laufen nie automatisch, Commit-Botschaften erklären das Warum, Reviews prüfen zuerst die Schnittstelle. Nichts davon steht in einer API-Beschreibung, und nichts davon kann ein Modell erraten – es sind Entscheidungen, keine Fakten. In Folge 6 habe ich erzählt, wie ich versucht habe, genau dieses Wissen in Instruktionsdateien wie AGENTS.md oder CLAUDE.md zu packen – und wo Empfehlungen an ihre Grenzen kommen. Aufgeben war daraus nicht die Lehre. Diese Schicht muss klein, dicht und kuratiert sein: Eine kurze Liste von Regeln, hinter denen das Team steht, lässt sich befolgen und im Review einfordern. Eine lange Sammlung von Hinweisen konkurriert mit sich selbst um Aufmerksamkeit.
Die zweite Schicht sind unsere **Dokumente**: Runbooks, Spezifikationen, Architekturentscheidungen, Betriebsnotizen. Das ist deskriptives Wissen – es beschreibt, was bei uns gilt und warum es so gekommen ist. Eine festgehaltene Architekturentscheidung kann verhindern, dass die KI mit ihrem Vorschlag drei Jahre alte Systemgrenzen übergeht. Ein Runbook erklärt, was bei einem bestimmten Alarm wirklich zu tun ist, statt was generisch sinnvoll klingt. Aber ich habe gelernt, dieser Schicht mit einer gewissen Skepsis zu begegnen: Dokumente altern. Sie beschreiben den Zustand von damals, nicht von heute. Ein Runbook, das seit zwei Jahren niemand angefasst hat, kann die KI genauso in die Irre führen wie ihr eigenes Raten – nur klingt die Antwort dann noch überzeugender, weil sie sich auf „unsere Doku“ beruft.
Die dritte Schicht sind **echte API-Beschreibungen** – und sie ist meine liebste, weil sie einen Charakter hat, den die anderen beiden nicht haben: Werkzeuge können ihre Struktur lesen, auch wenn Schema und Laufzeitverhalten auseinanderlaufen können. Eine OpenAPI-Beschreibung, ein per [Introspection](https://graphql.org/learn/introspection/) abgefragtes GraphQL-Schema, ein JSON-Schema, ein Datenbankschema – das ist nicht die Erinnerung eines Kollegen an das System, sondern eine maschinenlesbare Struktur- oder API-Beschreibung. Introspection zeigt das angebotene Schema dieser Umgebung zu diesem Zeitpunkt: Wenn das Feld `customer_ref` heißt, steht es dort. Das beweist weder korrekte Resolver noch die Übereinstimmung mit anderen Deployments oder mit datenabhängigen Antworten. Je nach Artefakt kann ich daraus Feldnamen, Typen oder Endpoints ablesen, statt sie aus Konventionen oder Dokumenten zu erraten.
Die drei Schichten beantworten unterschiedliche Fragen, und sie ersetzen einander nicht:
- Konventionen sagen, **wie** etwas gebaut werden soll – Stil, Schnitt, Verantwortlichkeiten.
- Dokumente sagen, **warum** die Dinge so sind, wie sie sind – Kontext und Geschichte.
- Die jeweilige API-Beschreibung nennt Felder, Typen oder Endpoints. Ob die Implementierung diesem Stand entspricht und funktioniert, muss separat geprüft werden.
Wer nur die dritte Schicht liefert, bekommt Code, der zum beschriebenen Vertrag passt, aber nicht zwingend zur Laufzeit funktioniert. Wer nur die erste liefert, bekommt stilistisch sauberen Code gegen eine erfundene API. Erst zusammen erden sie eine Antwort.
## Nachschlagen statt Raten
Das Prinzip hinter allen drei Schichten ist dasselbe, und es ist so unspektakulär, dass man es leicht überliest: **nachschlagen statt raten**. Am leichtesten versteht man es an einer Analogie, die jeder aus dem Editor kennt: IntelliSense.
Wenn ich in meinem Editor `customer.` tippe, rät der Editor nicht, welche Felder ein Kunde vermutlich hat. Er schlägt nach. Ein typbasierter Editor leitet Vorschläge aus der verfügbaren Typdefinition ab, nicht aus statistischer Ähnlichkeit. Genau diese Ableitung fehlt einem Sprachmodell, wenn wir es ohne Erdung arbeiten lassen.
Ein Agent mit passenden Werkzeugen und Leserechten kann nachschlagen. Er kann eine OpenAPI-Datei lesen, ein GraphQL-Schema per Introspection abfragen, eine Typdefinition im Repository aufschlagen. Das [Model Context Protocol](https://modelcontextprotocol.io/) stellt dafür Tools und Kontextquellen über einen Protokollvertrag bereit. Und ein solcher Agent kann noch einen Schritt weitergehen, der über IntelliSense hinausreicht: Er kann Endpoints **probieren**. Ein lesender Aufruf gegen die echte API, die tatsächliche Antwortstruktur anschauen, und der nächste Vorschlag basiert auf beobachteten Daten statt auf Erfindung. Aus „dieses Feld gibt es wahrscheinlich“ wird „dieses Feld habe ich gesehen – in dieser Antwort, mit diesen Rechten, in dieser Umgebung und zu diesem Zeitpunkt“. Das ist ein kategorialer Unterschied, kein gradueller, auch wenn eine einzelne Antwort nicht das Verhalten für andere Daten, Rechte, Umgebungen und Zeitpunkte belegt.
Erkundende Lesezugriffe müssen autorisiert sein; ihre fachliche Freiheit von Side Effects muss vorher geklärt werden. Solche Aufrufe sind für die Recherche wertvoll. Schreibende Aufrufe „zum Ausprobieren“ sind ein eigenes Thema mit eigenen Sicherungen – dazu komme ich in dieser Serie noch. Für das Erden von Antworten reicht die lesende Seite fast immer aus.
## Grounding wiederholbarer Abläufe gehört ans Bauen
Das zweite Prinzip hat länger gebraucht, bis es bei mir angekommen ist, und es ist das mit den größten Konsequenzen: **Wann** wird geerdet? Überall dort, wo ein wiederholbarer Ablauf ein vorab prüfbares Artefakt hat, gehört die Erdung ans Bauen und Vorbereiten – nicht in den kritischen Pfad der Ausführung. Entsteht die Frage dagegen erst zur Laufzeit, muss auch die Erdung dort stattfinden.
Die Grafik oben zeigt diesen Fall für ein vorab prüfbares Artefakt.
An dieser Stelle muss ich RAG einordnen, weil es das erste Wort ist, das im Raum steht, sobald jemand „eigenes Wissen“ und „KI“ im selben Satz sagt. Retrieval-Augmented Generation – 2020 von [Lewis und Kollegen](https://arxiv.org/abs/2005.11401) beschrieben – bedeutet: Zum Zeitpunkt der Anfrage werden passende Textstücke aus einem Korpus gesucht und dem Modell mitgegeben. Das ist genau richtig, wenn die Frage erst zur Laufzeit entsteht und die Antwort aus einem Dokumentbestand kommen muss – ein Assistent, der Fragen zum Handbuch beantwortet, eine Suche über interne Notizen, Support-Fälle. Solche Fälle entsprechen dem im RAG-Papier beschriebenen Muster aus Retrieval und Generierung.
Schief wird es, wenn RAG zum Reflex für alles wird. Denn Retrieval zur Laufzeit hat zwei Eigenschaften, die im Tagesgeschäft wehtun: zusätzliche Latenz und mögliche Ergebnisänderungen bei verändertem Index, Ranking oder Suchverfahren. Jede Ausführung sucht neu, und was gefunden wird, hängt an Einbettungen, Rankings, am Zustand des Index – derselbe Ablauf kann heute andere Textstücke sehen als gestern und sich deshalb anders verhalten. Für eine explorative Frage ist das verschmerzbar. Bei einem Ablauf, der jede Nacht läuft und auf dessen Ergebnis sich Leute verlassen, können wechselnde Treffer zu nicht reproduzierbaren Ergebnissen führen.
Deshalb ziehe ich für solche wiederholbaren Abläufe die Erdung nach vorn. Das Wissen – die Konventionen, die Dokumente, die API-Beschreibungen – fließt ein, während etwas **entsteht**: ein Dokument, ein Plan, ein Stück Code, ein konfigurierter Ablauf. Dieses Arbeitsergebnis wird geprüft, von mir oder von einem Kollegen, und ab dann steht es fest. Die spätere Ausführung würfelt nicht neu, sie führt aus, was geprüft wurde. Der Unterschied ist derselbe wie zwischen einem Programm, das bei jedem Start seine Abhängigkeiten aus dem Netz rät, und einem Build mit festgeschriebenen Versionen: In den flüchtigen, kreativen Moment gehört die ganze Unsicherheit – in das, was danach jede Nacht wieder abläuft, gehört sie nicht.
Das ist keine Absage an RAG, sondern eine Zuständigkeitsklärung. Suche über Dokumente zur Laufzeit, wo die Frage zur Laufzeit entsteht. Erdung beim Bauen, wo das Ergebnis ein Artefakt ist, das Bestand haben soll. In meiner Arbeit ist der zweite Fall der häufigere – diskutiert wird er trotzdem mit dem Vokabular des ersten.
## Kontext-Ökonomie: was zuletzt fliegt
Das dritte Prinzip klingt banal und entscheidet in der Praxis erstaunlich viel: Der Kontext ist knapp. Ja, die Fenster sind groß geworden. Aber wer länger mit Agenten-Sessions arbeitet, weiß, dass „groß“ nicht „unerschöpflich“ heißt – lange Sitzungen, gelesene Dateien, Tool-Ausgaben und Zwischenstände füllen jedes Fenster, und irgendwann wird getrimmt, zusammengefasst, weggelassen. Anthropic hat das unter dem Begriff Context Engineering auf den Punkt gebracht: Kontext ist eine endliche Ressource, relevante Informationen werden gezielt gefunden und nur bei Bedarf geladen. Ein großer, ungefilterter Kontext ist kein Qualitätsmerkmal – die für die Aufgabe maßgebliche Quelle gehört zum Zeitpunkt der Bearbeitung hinein.
Für mein Grounding folgt daraus eine Priorisierungsregel: Wenn unter Druck etwas aus dem Kontext fliegen muss, entferne ich zuerst Material, das sich gezielt erneut nachschlagen lässt. Ein langes Runbook bleibt nur mit den gerade relevanten Absätzen im Kontext. Kleine, aufgabenrelevante Konventionen halte ich länger fest, weil ihr Verlust schwerer zu bemerken ist. Bei einer anderen Aufgabe kann diese Reihenfolge anders aussehen; entscheidend sind Relevanz und Wiederbeschaffungskosten, nicht die Bezeichnung der Schicht.
Deshalb halte ich Konventionsdokumente klein und auf die Aufgabe zugeschnitten. Ein ausuferndes Dokument konkurriert mit Quellen und Tool-Ausgaben um Platz. Kuratieren heißt hier, bewusst zu entscheiden, was für den nächsten Schritt im Kontext bleiben muss.
## Was Grounding nicht leistet
Zur Ehrlichkeit gehört die Gegenrechnung, und ich will sie nicht ans Ende quetschen, als wäre sie eine Fußnote. Grounding beseitigt das Raten nicht. Beim nächsten Vorschlag traten mit der geladenen OpenAPI-Beschreibung keine erfundenen Feldnamen oder Strukturen auf. Aber ein Sprachmodell bleibt ein Sprachmodell: Es kann eine korrekte Spezifikation im Kontext haben und trotzdem einen Schluss daraus ziehen, der nicht trägt. Es kann zwei Dokumente zusammenlesen, die sich widersprechen, und den Widerspruch elegant überbrücken, statt ihn zu melden. Und es kann an einem gealterten Runbook geerdet sein – dann ist die Antwort sauber begründet und trotzdem falsch, nur schwerer als falsch zu erkennen.
Prüfen bleibt deshalb Pflicht. Das geerdete Arbeitsergebnis ist ein besserer Kandidat, kein fertiges Urteil. Was sich für mich geändert hat, ist die Art der Prüfung: Ich suche seltener nach frei erfundenen Feldern und häufiger nach falschen Schlüssen aus richtigen Quellen. Das ist ein besseres Problem – dieselbe Sorte Problem, die ich auch bei einem menschlichen Kollegen hätte, der sich gewissenhaft eingelesen hat. Aber es ist ein Problem, und Grounding ersetzt weder Konsistenzprüfung noch Tests – ohne solche Prüfungen können falsche Schlüsse unentdeckt bleiben.
Eine Frage lässt mich seither nicht los. Alles, was ich hier beschrieben habe, erdet eine Session: Die Konventionen, die Dokumente, die Schnittstellen fließen in einen Arbeitszusammenhang ein, und am Ende steht ein geprüftes Ergebnis. Aber die Session endet. Das Fenster schließt sich, der Kontext ist weg – und mit ihm alles, was die KI in diesen zwei Stunden über unser System, unsere Eigenheiten, unsere Korrekturen gelernt hat. Morgen erkläre ich `customer_ref` zum dritten Mal, oder ich habe einen Weg gefunden, dass Wissen die Session überlebt. Wie das aussehen kann – ohne veraltete, unauffindbare oder unbelegte Einträge anzusammeln – davon handelt die nächste Folge.
## Weiterführende Quellen
- [Effective context engineering for AI agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) – Anthropics Engineering-Beitrag zu Kontext als endlicher Ressource
- [Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks](https://arxiv.org/abs/2005.11401) – das RAG-Originalpapier von Lewis et al. (2020)
- [GraphQL Introspection](https://graphql.org/learn/introspection/) – wie ein GraphQL-Schema über sich selbst Auskunft gibt
- [OpenAPI Specification](https://spec.openapis.org/oas/latest.html) – der Standard für maschinenlesbare HTTP-API-Beschreibungen
- [Model Context Protocol](https://modelcontextprotocol.io/) – offener Standard, um KI-Werkzeugen echte Datenquellen und Systeme zugänglich zu machen
---
# KI im Enterprise-Umfeld: Schnellere Entwicklung braucht andere Prozesse
URL: https://www.mikebild.dev/de/blog/ki-im-konzern-schnellere-entwicklung-andere-prozesse/
Datum: 2026-05-19
Wenn die Implementierung statt fünf Tagen nur noch zwei dauert, die Änderung danach aber zwölf Tage auf Reviews, Freigaben und ein gemeinsames Testfenster wartet, ist das Produkt kaum früher beim Nutzer. Die lokale Arbeit wurde schneller. Der Gesamtprozess nicht.
Genau diese Verschiebung macht KI in großen Unternehmen sichtbar. Ein Entwickler kann Code, Tests und eine erste Dokumentation in einem Bruchteil der bisherigen Zeit vorbereiten. In Forschung und Entwicklung (R&D) lassen sich Hypothesen schneller prüfen und Prototypen früher zeigen. Gleichzeitig bleiben Abhängigkeiten zwischen Teams, widersprüchliche Dokumentation und gewachsene Freigaberunden unverändert. Der Engpass rückt aus der Implementierung in die Organisation.
Das ist kein Argument gegen große Unternehmen. Ihre Formalitäten sind selten aus reiner Freude an Bürokratie entstanden. Regulierung, Produkthaftung, wechselnde Mitarbeiter, verteilte Systeme und jahrzehntelang betriebene Software brauchen Nachvollziehbarkeit. Problematisch wird es, wenn niemand mehr unterscheiden kann, welche Formalität ein echtes Risiko beherrscht und welche nur eine frühere Unsicherheit verwaltet.
## KI verstärkt den vorhandenen Arbeitsfluss
Die Zahlen zur Produktivität passen nur auf den ersten Blick nicht zusammen. Drei Feldexperimente bei Microsoft, Accenture und einem weiteren Fortune-100-Unternehmen mit insgesamt 4.867 Entwicklern ergaben für Nutzer eines Coding-Assistenten rund 26 Prozent mehr erledigte Aufgaben; die Wirkung unterschied sich nach Erfahrung und Kontext. Eine randomisierte METR-Studie mit erfahrenen Open-Source-Entwicklern kam dagegen für frühe 2025er-Werkzeuge auf 19 Prozent längere Bearbeitungszeiten. Im Februar 2026 berichtete METR von Hinweisen auf bessere Ergebnisse mit neueren agentischen Werkzeugen, hielt die Daten wegen Auswahleffekten aber selbst für zu unsicher, um die Größe des Nutzens zu beziffern.
Die Befunde widersprechen sich weniger, als es scheint. Aufgabe, Codebasis, Erfahrung, Werkzeug und Abnahmekriterium verändern das Ergebnis. Der [DORA-Report 2025](https://dora.dev/research/2025/dora-report/) fasst den organisatorischen Teil treffend zusammen: KI wirkt als Verstärker. Gute Feedbackschleifen, gepflegte interne Daten und kleine Änderungen profitieren. Unklare Zuständigkeiten und schwerfällige Abläufe werden ebenfalls verstärkt.
In dieselbe Richtung weist ein Befragungsergebnis aus dem [Atlassian State of Developer Experience Report 2025](https://www.atlassian.com/teams/software-development/state-of-developer-experience-2025): Entwickler berichteten dort von Zeitersparnis durch KI und zugleich von wöchentlichen Zeitverlusten durch organisatorische Reibung. Solche Selbstauskünfte sind keine Stoppuhr. Als Diagnose sind sie trotzdem nützlich: Schnellerer Code beseitigt keine Wartezeit.
## Der Ticketbaum ist nicht das Produkt
In einem großen Unternehmen kann aus einer Produktidee zunächst eine Initiative werden, darunter ein Epic, mehrere Features, Stories und Subtasks. Die Fachbeschreibung liegt in Confluence, eine Architekturentscheidung in einem Kommentar, die Abnahmebedingung in einem Ticket und die tatsächliche Regel im Code. Jede Ebene ist für sich nachvollziehbar. Zusammen entstehen mehrere Wahrheiten.
Daraus entsteht häufig ein halb agiles, halb wasserfallartiges Vorgehen. Das Team arbeitet in Sprints, muss den Inhalt aber Monate vorher für Budget, Abhängigkeiten und Gremien festlegen. Rückfragen landen als Ticketkommentare, weil das gesprochene Wort nicht als belastbar gilt. Also wird mehr geschrieben, ohne dass die Dokumentation dadurch konsistenter wird. Bei der Integration mehrerer Systeme wächst die Zahl der Abstimmungen schneller als die Zahl der fachlichen Entscheidungen.
KI sollte diesen Apparat nicht automatisch befüllen. Sonst entstehen nur mehr Epics, längere Zusammenfassungen und noch überzeugender klingende Kommentare. Der bessere Ansatz beginnt mit einer einzigen, kleinen Beschreibung der Absicht. Alles Weitere wird daraus abgeleitet und bleibt mit der Änderung versioniert.
```yaml
change:
id: customer-address-v2
outcome: reduce failed deliveries
constraints:
- preserve existing API clients
- keep customer consent auditable
owners:
product: customer-experience
technical: customer-platform
evidence:
- contract-tests
- migration-report
- rollback-plan
risk: medium
```
Das ist kein neues Pflichtformular. Es ist ein Beispiel für ein kleines, versioniertes Änderungsartefakt, über das man sinnvoll streiten kann. Mit lesendem Zugriff auf einen indexierten Code- und Entscheidungsbestand darf ein Agent daraus betroffene Repositories, frühere Entscheidungen, Verträge und Tests zusammensuchen. Er darf einen Plan, Akzeptanzbeispiele und Dokumentationsänderungen vorschlagen. Outcome, Einschränkungen, Risiko und Eigentümer bestimmt weiterhin das Team.
Der Unterschied zum Ticketbaum liegt in der Richtung: Menschen pflegen nicht fünf Darstellungen derselben Änderung. Die unterschiedlichen Sichten werden aus wenigen versionierten Quellen erzeugt. Das Ticket verweist auf das Artefakt, der Pull Request zeigt den Diff, und die Dokumentation verweist auf die Entscheidung. Eine Zusammenfassung für das Management darf anders aussehen als die technische Sicht, aber beide müssen auf denselben Stand zurückführbar sein.
## Integration braucht Verträge statt mehr Abstimmung
Komplexe Integration wird durch KI nicht automatisch einfach. Ein Agent kann einen unbekannten Service schnell lesen und trotzdem eine fachliche Annahme übersehen, die nur das betreibende Team kennt. Gerade deshalb sollte die Zusammenarbeit weniger von Prosa und stärker von überprüfbaren Verträgen abhängen.
Beim Beispiel der geänderten Kundenadresse könnte das relevante Event als Schema vorliegen:
```json
{
"$id": "CustomerAddressChanged.v2",
"type": "object",
"required": ["customerId", "address", "consentId"],
"properties": {
"customerId": { "type": "string" },
"address": { "$ref": "Address.v2.json" },
"consentId": { "type": "string" }
}
}
```
Die KI kann im Code nach Produzenten und Konsumenten suchen, einen Kompatibilitätsbericht erstellen, Contract Tests ergänzen und Testdaten vorbereiten. Der Kompatibilitätsbericht muss für jede Aussage Repository, Revision und Fundstelle ausweisen – etwa dafür, dass das CRM `consentId` bereits liefert, der Versandservice das Feld ignoriert und ein alter Export mit `Address.v1` arbeitet. So lässt sich die Recherche prüfen, bevor daraus eine Entscheidung entsteht.
Entscheiden muss sie nicht. Ob eine alte Adresse noch verarbeitet werden darf, ist eine fachliche Frage. Ob beide Versionen parallel laufen oder ein Adapter nötig ist, ist eine Architekturentscheidung. Der Agent sammelt Evidenz; die beteiligten Teams verantworten den Vertrag. Genau dafür sind [ADRs](https://www.mikebild.dev/de/blog/adr-entscheidungen-die-man-versteht/) und ausführbare Spezifikationen wertvoll: Sie halten nicht jedes Gespräch fest, sondern das Ergebnis und seine Gründe.
## Dokumentation wird abgeleitet, nicht abgeschafft
Confluence bleibt für Erklärungen, Entry Points und Übersichten nützlich. Es sollte nur nicht länger die dritte manuell gepflegte Kopie dessen sein, was Ticket und Code ebenfalls beschreiben. Eine Seite braucht einen benannten Eigentümer, einen überprüfbaren Bezug zu Vertrag, ADR oder Repository und ein sichtbares Aktualisierungsdatum. Fehlt diese Verbindung, darf ein Agent die Seite als möglicherweise veraltet markieren, aber nicht stillschweigend zur Wahrheit erklären.
KI kann aus einer freigegebenen Änderung verschiedene Sichten erzeugen: Release Notes für Nutzer, einen technischen Integrationshinweis und eine kurze Zusammenfassung für das Portfolio. Der jeweilige Text bleibt überprüfbar, weil er auf dieselben Artefakte verweist. Menschen müssen dann nicht jeden Satz dreimal schreiben. Sie prüfen, ob die abgeleitete Sicht für ihre Leser stimmt. Die Dokumentation wird dadurch konsistenter und die Pflicht zugleich kleiner: Festgehalten werden Entscheidung, Vertrag und Betriebsfolge – nicht jede Zwischenstufe der Diskussion.
```mermaid
flowchart LR
Idea[Produktidee] --> Ticket[Ticket-Hierarchie]
Ticket --> Docs[Separate Dokumentation]
Docs --> Meetings[Abstimmungsrunden]
Meetings --> Build[Große Umsetzung]
Build --> Test[Gemeinsames Testfenster]
Test --> Approval[Externe Freigabe]
Intent[Versionierte Absicht] --> SmallChange[Kleine Änderung]
SmallChange --> Evidence[Tests, Vertrag und Diff]
Evidence --> Review[Peer Review]
Review --> Release[Release]
Release --> Feedback[Nutzer- und Betriebssignal]
Feedback --> Intent
```
## Agil wird man durch die Kosten einer Änderung
Agilität ist kein bestimmtes Board und keine Zahl von Meetings. Das ursprüngliche Agile Manifesto stellt funktionierende Software über umfassende Dokumentation und die Reaktion auf Veränderung über das Befolgen eines Plans. Beide Aussagen verlangen keine Sorglosigkeit. Sie verlangen, dass neue Information den Arbeitsstand tatsächlich verändern kann.
Ob KI Recherche, Prototyping oder Testentwurf in einem konkreten Wertstrom verkürzt, muss dort gemessen werden. Wenn das gelingt, sinken die Kosten kleiner Experimente. R&D kann dann stärker mit Hypothesen arbeiten: Was wollen wir lernen, welches kleinste Experiment liefert Evidenz, und welches Ergebnis würde unsere Richtung ändern? Produktentwicklung kann denselben Rhythmus nutzen.
Die Voraussetzung sind kleine Batches. Mehr parallel erzeugter Code verschlechtert den Fluss, wenn die Review-Kapazität gleich bleibt. Die Folge wäre eine neue Form von Lagerbestand – halbfertige Pull Requests statt halbfertiger Tickets. Wie bei [Developer Productivity](https://www.mikebild.dev/de/blog/developer-productivity-verkuerzte-zyklen/) zählt deshalb nicht die Tippgeschwindigkeit, sondern die Zeit bis zu belastbarem Feedback. [DORA-Metrics](https://www.mikebild.dev/de/blog/dora-metriken-was-zyklen-verkuerzt/) helfen beim Diagnostizieren; sie dürfen nicht zum Ziel für einzelne Mitarbeiter werden.
## Governance ohne pauschale Queue
Kontrolle bleibt nötig, aber nicht jede Änderung verdient denselben Weg. Eine Textkorrektur, eine rückwärtskompatible API-Erweiterung und ein neues Berechtigungsmodell haben verschiedene Schadenspotenziale. Gute Governance macht diesen Unterschied ausführbar. Das NIST AI Risk Management Framework verfolgt denselben Gedanken auf der Ebene der KI-Systeme selbst: Es strukturiert Risikomanagement über Governance, Messung und laufende Steuerung statt über eine einzelne pauschale Freigabe.
```yaml
approval_policy:
- risk: low
requires: [tests, policy-checks, peer-review]
decision: peer-approved
- risk: medium
requires: [tests, contract-checks, owner-review, rollback-plan]
decision: peer-approved
- risk: high
requires: [security-review, compliance-review, business-owner, audit-record]
decision: manually-approved
```
Auch diese YAML-Datei ist nur eine Skizze, keine fertige Policy-Sprache. Automatisierte Kontrollen erzeugen bei jeder Änderung dieselbe Evidenz. Menschen prüfen dort, wo Kontext, Haftung oder schwer rückbaubare Wirkung hinzukommen. DORA empfiehlt, schwere externe Change Approvals durch Peer Review, kontinuierliche Tests, Monitoring und gezielte Zusatzprüfung riskanter Änderungen zu ersetzen. Das ist weniger Bürokratie und zugleich präzisere Kontrolle.
```mermaid
flowchart TD
Change[Änderung mit Evidenz] --> Risk{Risikoklasse}
Risk -->|niedrig| Guardrails[Automatische Guardrails]
Guardrails --> Peer[Peer Review]
Peer --> Release[Release]
Risk -->|mittel| Owner[Fachlicher und technischer Owner]
Owner --> Release
Risk -->|hoch| Specialist[Security, Compliance und Business]
Specialist --> Approval{Freigabe}
Approval -->|ja| Release
Approval -->|nein| Rework[Überarbeiten oder verwerfen]
```
Der EU AI Act macht eine zweite Unterscheidung wichtig. Artikel 4 der [Verordnung (EU) 2024/1689](https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX%3A32024R1689) zur KI-Kompetenz gilt seit dem 2. Februar 2025: Anbieter und Betreiber müssen Maßnahmen treffen, damit Menschen, die in ihrem Auftrag mit KI-Systemen arbeiten, über ein ausreichendes Maß an KI-Kompetenz verfügen. Anhang III Nr. 4 der Verordnung erfasst – abhängig vom bestimmungsgemäßen Verwendungszweck – unter anderem Systeme, die Beschäftigte bewerten oder überwachen oder Aufgaben anhand persönlichen Verhaltens oder persönlicher Merkmale zuweisen. Ein Produktivitätsranking aus Prozessdaten fällt nicht automatisch darunter. Wird es jedoch für Personalentscheidungen, Leistungsbewertung oder Aufgabenzuweisung genutzt, liegt es in einem rechtlich besonders sensiblen Bereich. Governance soll die Arbeit absichern, nicht Menschen unter Generalverdacht stellen.
## Die Organisation muss dem Arbeitsfluss folgen
Ein neuer Assistent allein ändert kein Organigramm. Auf Dauer passt aber eine Organisation mit vielen Übergaben schlecht zu einer Arbeitsweise, die in kurzen Schleifen lernen soll. Für Wertströme mit häufigen teamübergreifenden Änderungen werden drei Strukturen wichtiger:
- langlebige, funktionsübergreifende Produktteams, die eine Wirkung von der Idee bis zum Betrieb verantworten und kleine Änderungen selbst freigeben können
- eine interne Plattform, die sicheren Zugriff auf Code, Dokumentation, Testumgebungen und freigegebene KI-Modelle als Standardweg anbietet
- Governance-, Security- und Architekturgruppen, die Regeln, Referenzlösungen und Ausnahmen gestalten, statt jede normale Änderung einzeln durchzuwinken
Das entspricht dem Muster, das ich schon bei [einfacherem Entwurf und weniger Prozess](https://www.mikebild.dev/de/blog/einfach-schlagen-elegant-statt-prozess/) beschrieben habe: Erst die Änderung klein und ihre Erwartungen explizit machen, dann den Prozessschritt entfernen, der dadurch überflüssig wird. Eine lokal gemessene Zeitersparnis ersetzt diese Architekturarbeit nicht.
Für die beteiligten Rollen verschiebt sich der Schwerpunkt:
| Rolle | Neuer Schwerpunkt |
| --- | --- |
| Entwickler | Aufgaben schneiden, Kontext bereitstellen, generierte Änderungen prüfen, Tests und Betriebssignale entwerfen |
| Architekten | Systemverträge, automatisierte Architekturregeln, Rückbaubarkeit und sichere Standardwege gestalten |
| Product Owner | Outcomes, Akzeptanzbeispiele und Nutzerfeedback schärfen, statt den Ticketbestand zu verwalten |
| Projektmanagement | Abhängigkeiten, Risiken, Wartezeiten und Work in Progress verringern, statt Tätigkeiten im Detail vorzuplanen |
Keine dieser Rollen verschwindet. Im Gegenteil: Je billiger die Erzeugung von Vorschlägen wird, desto wertvoller werden Auswahl, Urteil und Verantwortung. Das [Ergebnis eines einzelnen KI-Power-Users lässt sich nicht einfach auf ein Enterprise übertragen](https://www.mikebild.dev/de/blog/mein-erfolg-laesst-sich-nicht-kopieren/). Teams brauchen gemeinsame Prüfkriterien, Lernzeit und einen Arbeitsfluss, der Unterschiede sichtbar macht.
## Klein anfangen und den Gesamtzyklus messen
Ein unternehmensweites Transformationsprogramm wäre ein widersprüchlicher Anfang. Besser ist ein einzelner Wertstrom mit einer wiederkehrenden Änderung, deren Risiko bekannt ist. Dort lässt sich der heutige Weg vom Wunsch bis zum Betrieb aufzeichnen: Wie lange wird gearbeitet, wie lange gewartet, wie oft wird dieselbe Information übertragen, und an welcher Stelle entsteht Nacharbeit?
Für einen ersten Versuch reichen wenige Schritte:
- ein versioniertes Änderungsartefakt und die führenden Quellen festlegen
- der KI nur lesenden Zugriff geben und ihren Kontext nachvollziehbar protokollieren
- Tests, Contract Checks und Dokumentations-Diffs automatisch als Evidenz erzeugen
- zunächst ausschließlich kleine, reversible Änderungen durch den neuen Pfad schicken
- Lead Time, Wartezeit, Zahl der Übergaben, Nacharbeit, Change Fail Rate und Zeit bis zum Nutzerfeedback vergleichen
Nicht messen würde ich erzeugte Codezeilen, geschlossene Tickets oder individuelle Prompt-Aktivität. Solche Zahlen belohnen Volumen. Messen würde ich den Bestand halbfertiger Arbeit, den Anteil einer vorab festgelegten Dokumentstichprobe, der einem benannten Vertrag, ADR oder Repository-Stand widerspricht, und die Zeit vom Öffnen einer Review-Anfrage bis zur ersten Freigabe oder konkreten Änderungsanforderung. Der Anteil der Releases, die über den kontrollierten Pfad laufen, misst die Prozessabdeckung und nicht die Wirkung.
## Fazit
Die schwerfälligen Abläufe großer Unternehmen sind kein Naturgesetz, aber auch nicht bloß Dummheit aus der Vergangenheit. Sie bewahren Zuständigkeit, Wissen und Kontrolle dort, wo technische Mittel lange nicht ausgereicht haben. KI verändert diese Rechnung, weil sie Kontext schneller zusammentragen, Evidenz vorbereiten und wiederkehrende Prüfungen unterstützen kann.
Der Gewinn entsteht erst, wenn die Organisation die frei werdende Zeit nicht mit mehr Output füllt. Dann werden Änderungen kleiner, Verträge ersetzen einen Teil der Abstimmung und versionierte Artefakte vermeiden widersprüchliche Kopien. Freigaben richten sich nach dem Risiko statt nach einer pauschalen Queue. Menschen behalten die Entscheidungen, bei denen Fachlichkeit, Haftung und Folgen zählen.
So kann KI Entwicklung und R&D tatsächlich agiler machen: nicht indem sie den alten Prozess schneller ausfüllt, sondern indem sie hilft, seine Umwege überflüssig zu machen.
## Weiterführende Quellen
- [DORA – State of AI-assisted Software Development 2025](https://dora.dev/research/2025/dora-report/)
- [DORA – Capability Catalog](https://dora.dev/capabilities/)
- [DORA – Streamlining Change Approval](https://dora.dev/capabilities/streamlining-change-approval/)
- [DORA – Working in Small Batches](https://dora.dev/capabilities/working-in-small-batches/)
- [DORA – Repository](https://github.com/dora-team/dora.dev)
- [Microsoft Research – The Effects of Generative AI on High-Skilled Work](https://www.microsoft.com/en-us/research/publication/the-effects-of-generative-ai-on-high-skilled-work-evidence-from-three-field-experiments-with-software-developers/)
- [METR – Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/)
- [METR – We Are Changing Our Developer Productivity Experiment Design](https://metr.org/blog/2026-02-24-uplift-update/)
- [Atlassian – State of Developer Experience Report 2025](https://www.atlassian.com/teams/software-development/state-of-developer-experience-2025)
- [Manifesto for Agile Software Development](https://agilemanifesto.org/)
- [NIST – AI Risk Management Framework](https://airc.nist.gov/airmf-resources/airmf/5-sec-core/)
- [Europäische Kommission – AI Literacy: Questions & Answers](https://digital-strategy.ec.europa.eu/en/faqs/ai-literacy-questions-answers)
- [Verordnung (EU) 2024/1689 – Artificial Intelligence Act](https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX%3A32024R1689)
---
# Sauberes Grounding I: Warum die KI so überzeugend rät
URL: https://www.mikebild.dev/de/blog/sauberes-grounding-warum-ki-raet/
Datum: 2026-05-06
Vor ein paar Wochen saß ich in einem Review über generiertem Code. Der Assistent hatte eine Retry-Logik für unseren internen HTTP-Client vorgeschlagen – einen Client, den es nur bei uns gibt, eine dünne TypeScript-Schicht über `fetch` mit ein paar hauseigenen Konventionen. Der Vorschlag: `client.withRetry({ backoff: "exponential", maxAttempts: 3 })`. Sauber benannt, im Stil unserer Codebasis, mit einem Kommentar, warum exponentielles Backoff hier die richtige Wahl sei. Dazu eine kurze Erklärung im Chat, wie sich die Methode zu unserem Timeout-Handling verhält.
Die Methode existiert nicht. Sie hat nie existiert. Unser Client konfiguriert Retries an einer ganz anderen Stelle, beim Erzeugen der Instanz, nicht am Aufruf. Aber das Erschreckende war nicht der Fehler. Fehler mache ich auch. Das Erschreckende war die Qualität der Erfindung: Der Name passte perfekt zu unseren Konventionen, die Signatur sah aus wie von uns, die Begründung war fachlich einwandfrei. Wäre die Methode von einem Menschen vorgeschlagen worden, hätte ich gesagt: Der kennt unseren Code richtig gut. Nur dass der Vorschlag komplett geraten war – und mit derselben Souveränität vorgetragen wurde wie die zwanzig korrekten Vorschläge davor.
*Teil 7 der Serie „Von der Session zum System“ – hier geht es [zum Auftakt](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/).*
Wer ernsthaft mit Copilot, Claude Code oder Cursor arbeitet, kann so etwas erleben. Ich habe solche Fehler anfangs wie einen Bug betrachtet, der mit der nächsten Modellgeneration verschwinden müsste. Heute verlasse ich mich nicht darauf. Bessere Modelle können Halluzinationen reduzieren, beseitigen sie aber nicht zuverlässig – und seit mir das klar geworden ist, arbeite ich anders mit diesen Systemen.
## Das Modell kennt seine Wissensgrenze nicht zuverlässig
Um zu verstehen, warum die Erfindung so überzeugend klang, musste ich mir klarmachen, was ein Sprachmodell eigentlich tut: Es setzt Text fort. Aus Milliarden von Beispielen hat es gelernt, welche Fortsetzung nach einem gegebenen Anfang wahrscheinlich ist. Das ist keine abwertende Vereinfachung, sondern der Mechanismus – und er ist erstaunlich mächtig, wie ich [in Folge 2 dieser Serie](https://www.mikebild.dev/de/blog/gut-genug-modelle/) beschrieben habe. Aber er hat eine Eigenschaft, die man nicht wegdiskutieren kann: Wahre und falsche Aussagen entstehen beide als wahrscheinliche Fortsetzungen; eine Wahrheitsprüfung folgt aus diesem Mechanismus nicht automatisch.
Ein menschlicher Entwickler hat – bei aller Fehlbarkeit – ein Gefühl dafür, ob er etwas weiß oder vermutet. Wenn ich einen Kollegen nach einer Methode unserer internen Bibliothek frage, antwortet er entweder „die heißt so“ oder „ich müsste nachschauen“. Dieses Nachschauen-Müssen ist Metakognition: Wissen über das eigene Wissen, ein Gespür für die eigene Unsicherheit. Genau diese Instanz fehlt dem Modell. Es hat keinen inneren Zustand, der zwischen „das stand tausendfach im Trainingskorpus“ und „das klingt so, wie es klingen müsste“ unterscheidet.
Deshalb ist die Souveränität, die uns so irritiert, keine Anmaßung, sondern ein Artefakt. Der Ton eines Textes ist Teil der Fortsetzung. Technische Dokumentation, Stack-Overflow-Antworten, Code-Kommentare – das Material, aus dem das Modell gelernt hat, ist überwiegend im Ton der Gewissheit geschrieben. Niemand dokumentiert eine API mit „ich glaube, diese Methode gibt es“. Also klingt auch die erfundene Methode nach Dokumentation. Der überzeugte Ton ist kein Signal für Korrektheit. Er war es nie.
Zwei Arbeiten stützen Teile dieser Erklärung. Ziwei Xu und Kollegen haben 2024 formal argumentiert, dass Halluzinationen für große Sprachmodelle nicht vollständig eliminierbar sind. Und OpenAI beschreibt in einer eigenen Veröffentlichung – Stand August 2026 online abrufbar – einen zweiten Mechanismus: Trainings- und Evaluationsanreize können Modelle zum Raten statt zum Eingestehen von Unsicherheit bewegen. Ein Modell, das bei Unsicherheit „weiß ich nicht“ sagt, kann in Benchmarks, die richtige Antworten belohnen, Enthaltungen aber nicht angemessen berücksichtigen, schlechter abschneiden als eines, das selbstbewusst rät – so wie ein Multiple-Choice-Test Studenten beibringt, bei Unwissen auf gut Glück anzukreuzen, statt das Feld leer zu lassen.
## Symbole, die auf Symbole verweisen
Es gibt noch eine tiefere Ebene, und sie ist älter als die aktuellen Modelle. 1990 – lange vor heutigen großen Sprachmodellen – hat der Kognitionswissenschaftler Stevan Harnad das *Symbol Grounding Problem* formuliert. Seine Frage: Wie kommt Bedeutung in ein System, das nur Symbole nach formalen Regeln manipuliert? Sein Bild: Man versuche, Chinesisch ausschließlich aus einem Chinesisch-Chinesisch-Wörterbuch zu lernen. Jedes Zeichen wird durch andere Zeichen erklärt, diese wiederum durch weitere Zeichen – man dreht sich im Kreis, ohne je bei der Sache selbst anzukommen. Symbole verweisen auf Symbole, nirgends berührt das System die Welt.
Ich zögere normalerweise, Paper aus der Kognitionswissenschaft in Alltagsdebatten zu ziehen, weil dabei oft mehr Nebel als Klarheit entsteht. Aber hier passt die Analogie unangenehm gut. Ein Sprachmodell kennt Text über die Welt, nicht die Welt. Es hat gelesen, was Menschen über HTTP-Clients, über Retries, über exponentielles Backoff geschrieben haben – und daraus statistische Zusammenhänge zwischen Token gelernt. Die Antwort in meiner Eingangsszene lieferte jedenfalls keinen Hinweis auf eine Prüfung an der Sache selbst: kein Compiler, der den Aufruf ablehnt, kein Test, der rot wird, keine Produktion, die um drei Uhr nachts alarmiert. Wo ich als Entwickler meine Begriffe an Erfahrung geeicht habe, hat das Modell seine Begriffe an anderen Begriffen geeicht. Das Wörterbuch erklärt sich selbst, und es erklärt sich flüssig.
Man muss Harnads Problem nicht in voller philosophischer Schärfe übernehmen, um den praktischen Kern zu sehen: Ein System, dessen gesamtes „Wissen“ aus Textstatistik besteht, kann eine plausible Erfindung nicht von einer Tatsache unterscheiden, weil beide aus demselben Stoff sind. `withRetry` war für das Modell genauso real wie jede Methode, die es wirklich gibt – ein wahrscheinliches Symbol unter anderen Symbolen.
## Warum größere Modelle das Problem mildern, aber nicht lösen
Der Einwand liegt nahe: Die Modelle sind doch besser geworden. In meiner Arbeit erwische ich aktuelle Modelle im öffentlichen, gut dokumentierten Wissen jedenfalls nur noch selten bei freien Erfindungen.
Aber „seltener“ heißt nur „weniger oft“, nicht „grundsätzlich anders“. Der Mechanismus bleibt derselbe: Ein größeres Modell hat feinere statistische Zusammenhänge gelernt – es rät seltener, weil es mehr gesehen hat, nicht weil es aufgehört hätte zu raten. An der Stelle, wo sein Material endet, produziert es weiterhin die wahrscheinlichste Fortsetzung, im selben souveränen Ton. Die Grenzlinie zwischen Wissen und Vermutung verschiebt sich nach außen, aber sie verschwindet nicht, und das Modell zeigt sie mir nach wie vor nicht an. Genau das macht die restlichen Fälle so tückisch: Je seltener der Fehler, desto weniger rechne ich mit ihm – und desto ungeprüfter geht der Vorschlag durch.
## Ohne interne Quellen bleiben organisationsspezifische Fakten Vermutung
Und damit zu dem Punkt, der mich in meiner täglichen Arbeit am meisten beschäftigt. Alles bisher Gesagte gilt für öffentliches Wissen – React, PostgreSQL, die AWS-APIs. Dort erlebe ich selten, dass das Modell rät – das öffentliche Material ist riesig. In dem Moment aber, in dem ich die Tür zu einer konkreten Organisation aufmache, kippt das Verhältnis. Denn was dort zählt, ist dem Modell ohne bereitgestellte interne Quellen nicht verlässlich zugänglich:
- die internen Bibliotheken und Services mit ihren tatsächlichen Signaturen und Eigenheiten
- die hauseigenen Konventionen – wie Fehler behandelt werden, wie Module geschnitten sind, was ein Deployment durchlaufen muss
- die Begriffe der Fachdomäne, die im Unternehmen etwas Präzises bedeuten und außerhalb etwas anderes oder gar nichts
Wie weit das geht, hat mir der Fall aus der Eingangsszene gezeigt. Das Modell hat unseren HTTP-Client nie gesehen, also hat es ihn erfunden – und zwar so, wie ein solcher Client typischerweise aussieht. Deshalb war der Vorschlag so gut: Er war die Idealform eines internen HTTP-Clients, destilliert aus öffentlichen Mustern. Nur eben nicht unserer. Ohne interne Quelle waren die tatsächlichen Signaturen für das Modell nicht verlässlich ableitbar; die Erfindung lag nahe und sah dem echten Wissen zum Verwechseln ähnlich, weil das Modell so gut darin ist, den Stil einer Codebasis fortzusetzen.
Das erklärt im Nachhinein auch, warum meine Versuche mit Instruktionsdateien so ernüchternd verliefen – ich habe das in der letzten Folge ausführlich erzählt. Damals dachte ich noch, das Problem sei die Verbindlichkeit: Die KI hält sich nicht an unsere Regeln, also müssen die Regeln klarer, strenger, prominenter formuliert werden. Aber selbst wenn eine AGENTS.md perfekt befolgt würde – sie beantwortet die falsche Frage. Eine Instruktion sagt dem System, wie es sich verhalten soll. Sie kann ihm nicht geben, was es tatsächlich nicht hat: die Fakten. „Erfinde keine Methoden“ ist eine hilflose Anweisung an ein System, das nicht merkt, wann es erfindet. Dem Modell fehlt nicht der Wille, es fehlt das Material. Ich habe an der Motivation eines Systems gearbeitet, das kein Motivationsproblem hat, sondern ein Wissensproblem.
## Grounding: interne Fakten im Arbeitskontext bereitstellen
Für diese Antwort auf das Wissensproblem verwende ich hier den Begriff Grounding – das Erden von Antworten in überprüfbaren Fakten. Die Idee ist im Kern einfach. Wenn das Modell meine Realität nicht aus dem Training kennen kann, dann muss ich sie ihm zum Zeitpunkt der Arbeit mitgeben: die echte Signatur statt der wahrscheinlichen, das tatsächliche Schema statt des typischen, unsere Konvention statt der branchenüblichen. Nicht als Verhaltensregel, sondern als Material. Das Modell soll nachschlagen können statt raten zu müssen – ungefähr so, wie mich eine gute IDE mit Typinformationen davon abhält, Methodennamen aus dem Gedächtnis zu tippen.
Hier verwende ich Grounding für die Bereitstellung konkreten Quellenmaterials im Arbeitskontext und unterscheide es damit von bloßen Instruktionen, die Verhaltensregeln formulieren. Grounding ist kein Produkt und kein Feature, das man einschaltet. Es ist zunächst eine Einsicht über die Arbeitsteilung: Das Modell liefert Sprachverständnis, Mustererkennung, Syntheseleistung – die Fakten über meine Welt muss meine Welt selbst liefern. Und es ist, ehrlich gesagt, auch keine vollständige Lösung. Ein geerdetes Modell kann die mitgegebenen Fakten immer noch falsch verknüpfen, und wer schon einmal versucht hat, „einfach alle Dokumente“ in den Kontext zu kippen, weiß, dass man sich damit neue Probleme einhandelt. Der Unterschied ist ein anderer: Bei einem geerdeten System streite ich über die Qualität meiner Quellen. Ohne Quellen prüfe ich freie Ergänzungen aus allgemeinen Mustern.
Damit steht die Konsequenz dieser Folge fest, auch wenn sie niemandem Arbeit erspart: Bessere Modelle und strengere Anweisungen beseitigen überzeugende Falschantworten nicht zuverlässig. Grounding stellt dort konkretes Quellenmaterial bereit, wo das System sonst aus allgemeinen Mustern ergänzen müsste. Womit die eigentliche Arbeit beginnt – denn „interne Fakten mitgeben“ ist schnell gesagt. Welche Fakten eigentlich, in welcher Form, an welcher Stelle des Arbeitsflusses? Das ist keine rhetorische Frage, sondern die nächste Folge.
## Weiterführende Quellen
- [Stevan Harnad: The Symbol Grounding Problem (Physica D, 1990)](https://doi.org/10.1016/0167-2789(90)90087-6) – der Originalbeitrag mit dem Wörterbuch-Argument
- [Ziwei Xu et al.: Hallucination is Inevitable – An Innate Limitation of Large Language Models (2024)](https://arxiv.org/abs/2401.11817) – die formale Argumentation, dass Halluzination für diese Modellklasse nicht eliminierbar ist
- [OpenAI: Why Language Models Hallucinate](https://openai.com/index/why-language-models-hallucinate/) – warum Trainings- und Evaluationsanreize das Raten belohnen können (abgerufen im August 2026)
- [Lilian Weng: Extrinsic Hallucinations in LLMs (2024)](https://lilianweng.github.io/posts/2024-07-07-hallucination/) – ausführlicher Überblick über Ursachen, Messung und Gegenmaßnahmen
---
# Mein Erfolg lässt sich nicht kopieren
URL: https://www.mikebild.dev/de/blog/mein-erfolg-laesst-sich-nicht-kopieren/
Datum: 2026-03-04
Im Februar fragte mich ein Kollege – erfahrener Entwickler, gutes Urteilsvermögen, kein Anfänger – ob er mein Setup haben kann. Er hatte über Wochen zugesehen, wie ich mit Claude Code arbeite, und wollte dasselbe: dieselben Werkzeuge, dieselbe Konfiguration, dieselben Ergebnisse. Ich habe ihm alles gegeben. Die komplette Werkzeugkette. Meine Instruktionsdateien, gewachsen über Monate. Meine Prompt-Sammlung für wiederkehrende Aufgaben, meine Checklisten für Reviews, sogar meine Notizen dazu, welche Aufgaben ich delegiere und welche nicht. Es gab keinen geheimen Rest. Er hatte wirklich alles, was ich habe.
*Teil 5 der Serie „Von der Session zum System“ – hier geht es [zum Auftakt](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/).*
Zwei Wochen später saßen wir beim Kaffee, und er war ernüchtert. Nicht frustriert im Sinne von „das Werkzeug taugt nichts“ – er hatte durchaus brauchbare Momente erlebt. Aber das, was er bei mir gesehen hatte, diese Selbstverständlichkeit, mit der Aufgaben rausgehen und geprüfte Ergebnisse zurückkommen, stellte sich bei ihm nicht ein. Bei ihm lief die KI dreimal in die falsche Richtung, baute Dinge, die er nicht wollte, und er verbrachte mehr Zeit mit Aufräumen als vorher mit Selberschreiben. Sein Satz ist mir geblieben: „Ich habe dein Setup. Warum habe ich nicht deine Ergebnisse?“
Die Frage hat mich länger beschäftigt als jedes Tool-Problem der letzten Monate. Denn die naheliegenden Antworten stimmen alle nicht. Es lag nicht am Modell – wir nutzten dasselbe. Nicht an der Konfiguration – sie war identisch, Datei für Datei. Nicht an mangelnder Erfahrung als Entwickler – er ist mindestens so gut wie ich. Was ihm fehlte, stand in keiner der Dateien, die ich ihm gegeben hatte. Und genau das ist der Punkt, an dem diese Serie den Sprung machen muss: vom Ich zum Team. Bisher habe ich beschrieben, warum der Harness mehr ausmacht als das Modell und [was mir an meiner eigenen Arbeitsweise Unbehagen bereitet](https://www.mikebild.dev/de/blog/was-ich-kritisch-sehe/). Beides war die Perspektive eines Einzelnen. Sobald ein zweiter Mensch ins Spiel kommt, taucht ein Problem auf, das ich vorher nur geahnt hatte: Varianz. Und zwar gleich dreifach.
## Erste Ebene: dieselbe Aufgabe, zwei Sessions, zwei Ergebnisse
Die erste Ebene hat noch gar nichts mit meinem Kollegen zu tun. Ich kann sie allein an meinem eigenen Rechner vorführen.
Ich gebe derselben KI dieselbe Aufgabe zweimal – unter weitgehend gleichen sichtbaren Bedingungen: gleicher Prompt, gleiches Repository, gleiche Instruktionsdateien. Session eins entscheidet sich, erst die Tests zu lesen, findet dort ein bestehendes Muster und erweitert es sauber. Session zwei springt direkt in den Produktionscode, hält eine Hilfsfunktion für unbenutzt, räumt sie „bei der Gelegenheit“ mit weg und liefert eine Lösung, die zwar läuft, aber anders geschnitten ist als alles Umliegende. Beide Sessions haben denselben Auftrag bekommen. Beide berichten selbstbewusst, sie seien fertig. Die Ergebnisse unterscheiden sich in Struktur, Stil und Nebenwirkungen.
In meinen Durchläufen unterschieden sich schon frühe Entscheidungen – etwa welche Datei zuerst gelesen wurde oder welches Muster als Vorbild diente. Danach liefen auch die weiteren Schritte auseinander.
Für mich allein ist das handhabbar. Ich habe gelernt, Ergebnisse zu prüfen statt Wege vorzuschreiben, und in Folge 3 habe ich beschrieben, wie viel davon der Harness abfängt: Tools, Feedback-Schleifen, Prüfschritte. Aber schon hier zeigt sich der Fehler, „Best Practices“ mit reproduzierbaren Ergebnissen zu verwechseln: Derselbe Erfolgsfall lässt sich nicht exakt wiederholen. Wenn ich meinem Kollegen zeige, wie großartig eine Session gestern lief, zeige ich ihm einen einzelnen Durchlauf – auch bei mir würde der nächste anders aussehen.
## Zweite Ebene: das Wissen, das in keiner Datei steht
Die zweite Ebene ist die, an der mein Kollege tatsächlich gescheitert ist. Und sie ist unangenehmer, weil sie sich als Werkzeugfrage tarnt, aber eine Erfahrungsfrage ist.
Als wir seine ernüchternden zwei Wochen durchgesprochen haben, fiel mir auf: Er hat dieselben Dinge getan wie ich – nur an anderen Stellen. Er hat delegiert, aber die falschen Aufgaben. Er hat geprüft, aber das Falsche angeschaut. Er hat abgebrochen, aber zu spät. Drei Beispiele aus unserem Gespräch:
- Er gab der KI eine Aufgabe, die ich nie im Ganzen delegieren würde – eine Änderung quer durch drei Module mit unklarer Fachlogik – und wunderte sich über das Chaos. Ich hätte sie vorher in drei prüfbare Häppchen geschnitten. Dieser Zuschnitt steht in keinem meiner Prompts, ich mache ihn im Kopf, bevor ich überhaupt tippe.
- Er las die Erklärungen der KI und fand sie überzeugend. Ich lese die Erklärungen kaum noch – ich schaue auf das Diff, die Tests und die Stellen, an denen erfahrungsgemäß unerwünschte Nebenwirkungen auftreten. Wo man hinschaut, ist Urteilskraft, keine Konfiguration.
- Er ließ eine Session dreimal nachbessern, ehe er aufgab. Ich breche nach dem ersten gescheiterten Nachbesserungsversuch ab und formuliere die Aufgabe neu, denn ich habe gelernt: Wenn die Richtung einmal falsch ist, wird Nachsteuern teurer als Neustarten. Auch das steht nirgends – diese Abbruchregel stammt aus wiederholten Fehlversuchen.
Aufgabenzuschnitt, Prüfblick, Abbruchinstinkt – das ist implizites Wissen im klassischen Sinn. Man erwirbt es durch Reibung, nicht durch Lektüre. Meine Instruktionsdateien sind das Sediment dieses Wissens, aber sie sind nicht das Wissen selbst. Sie sagen der KI, was sie tun soll. Sie sagen meinem Kollegen nicht, was *er* tun soll, während die KI arbeitet.
Die [METR-Studie vom Sommer 2025](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/) hat einen verwandten Effekt messbar gemacht: Bei erfahrenen Open-Source-Entwicklern dauerten Aufgaben mit frühen 2025er-KI-Werkzeugen im Mittel 19 Prozent *länger* – obwohl die Teilnehmenden einen Zeitgewinn erwarteten. Man kann über die Übertragbarkeit der Studie streiten, die Bedingungen waren speziell. Aber der belegte Befund passt zu dem, was ich bei meinem Kollegen gesehen habe: Erwarteter Zeitgewinn und gemessene Bearbeitungszeit können auseinanderliegen.
## Dritte Ebene: es gibt keinen identischen Durchlauf
Die dritte Ebene wird gern übersehen, weil sie so banal klingt: Mein Kollege arbeitet an anderen Aufgaben als ich.
Nicht grundsätzlich anders – gleiche Firma, verwandte Systeme, ähnlicher Stack. Aber seine konkrete Aufgabe an einem konkreten Dienstag ist nie meine konkrete Aufgabe. Sein Modul hat eine andere Geschichte, andere Altlasten, andere ungeschriebene Konventionen. Seine Bugs sitzen an anderen Stellen. Selbst wenn er meine Urteilskraft hätte und die Session-Lotterie zu seinen Gunsten ausginge: Er könnte meinen Erfolg trotzdem nicht reproduzieren, weil es den Versuchsaufbau „gleiche Aufgabe“ in echter Arbeit schlicht nicht gibt.
Das unterscheidet KI-Werkzeuge fundamental von fast allem, was wir vorher im Team eingeführt haben. Formatter und CI-Pipelines zielen unter gleicher Version, Konfiguration und Umgebung auf reproduzierbare Ausführung; eine Framework-API stellt denselben Vertrag bereit. Bei diesen Werkzeugen gilt: Einer findet die gute Konfiguration, alle übernehmen sie, alle haben den Nutzen. Genau dieses Muster haben wir alle im Kopf, wenn wir „Setup teilen“ sagen – und genau dieses Muster greift hier nicht. Der Nutzen einer KI-Session entsteht aus dem Zusammenspiel von Aufgabe, Kontext, Person und Zufall. Drei dieser vier Faktoren sind bei jedem Teammitglied andere.
## Was Organisationen daraus regelmäßig falsch schließen
Auf Organisationsebene können diese Unterschiede zu falschen Produktivitätsannahmen führen. Denn aus der Einzelbeobachtung „bei Mike funktioniert das“ liegen drei Fehlschlüsse nahe.
Der erste Fehlschluss: Lizenz gekauft heißt Team produktiv. Ein Konzern beschafft für alle Entwickler Zugänge, verbucht das als „KI-Adoption“ und erwartet den Produktivitätssprung, den die Power-User im Pilotprojekt gezeigt haben. Aber die Power-User waren ja gerade deshalb schnell, weil sie über Monate implizites Wissen aufgebaut haben. Die Lizenz kauft das Werkzeug, nicht die zweite Ebene. Der [DORA-Report 2025](https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report) bringt es auf eine Formel, die ich seither ständig zitiere: KI verstärkt, was da ist. Teams mit guten Feedback-Schleifen und sauberer Architektur werden besser, Teams mit schwachen Prozessen bekommen ihre Schwächen verstärkt zurück.
Der zweite Fehlschluss: Prompt-Bibliothek teilen ist ein Rollout. Das war mein eigener Irrtum mit dem Kollegen, nur in klein. Prompts und Instruktionsdateien sind Sediment – nützlich, aber tot ohne die Praxis, aus der sie entstanden sind. Eine geteilte Prompt-Sammlung ohne geteilte Urteilskraft produziert Leute, die überzeugende Erklärungen lesen statt Diffs zu prüfen. Die [Stack-Overflow-Umfrage 2025](https://survey.stackoverflow.co/2025/ai/) zeigt die Folgen im Großen: KI-Werkzeuge werden breit genutzt, aber das Vertrauen bleibt begrenzt, und eine häufig genannte Frustration ist Code, der „fast richtig“ ist. Fast richtig zu erkennen ist exakt die Fähigkeit, die sich nicht allein per Datei verteilen lässt.
Der dritte Fehlschluss: Was beim Piloten klappt, skaliert linear. Tut es nicht, wegen aller drei Varianz-Ebenen gleichzeitig. Ein Pilot kann motivierte Power-User enthalten (Personen-Varianz), ausgewählte, gut schneidbare Aufgaben (Aufgaben-Varianz) und selektiv berichtete Erfolgsgeschichten – missratene Sessions können in der Management-Präsentation fehlen (Session-Varianz). Wer daraus eine Hochrechnung für 200 Entwickler baut, kann mit einem nicht repräsentativen Durchschnitt rechnen.
Ich formuliere es zugespitzt, weil ich den Satz in [Folge 4](https://www.mikebild.dev/de/blog/was-ich-kritisch-sehe/) schon einmal gebraucht habe und er hier die organisatorische Konsequenz beschreibt: Die Erfolgsgeschichten der Einzelnen sind echt, und sie sind trotzdem kein Bauplan. Werkzeuge, Tests, Konventionen und Abnahmekriterien lassen sich kopieren. Mein konkretes Ergebnis entsteht zusätzlich aus Aufgabe, Kontext, Prüfblick und Sessionverlauf. Diesen Teil überträgt keine Setup-Datei.
## Die Varianz ist auch eine Lernquelle
Das klingt jetzt düsterer, als ich es meine. Denn dieselbe Varianz, die das Kopieren verhindert, ist eine brauchbare Diagnosequelle für ein Team.
Als mein Kollege und ich seine zwei Wochen seziert haben, ist etwas Bemerkenswertes passiert: Ich musste zum ersten Mal aussprechen, *warum* ich Aufgaben so schneide, wie ich sie schneide. Warum ich Erklärungen ignoriere und Diffs lese. Warum ich nach einem gescheiterten Nachbesserungsversuch abbreche. Das war implizites Wissen, das ich selbst nicht als Wissen wahrgenommen hatte – für mich war es einfach „wie man das halt macht“. Erst der Unterschied zwischen seiner Arbeitsweise und meiner hat es sichtbar gemacht. Genau dort, wo zwei Leute dasselbe verschieden machen, liegt das implizite Wissen offen zutage. Man muss nur hinschauen, statt die Differenz als Versagen des Langsameren abzutun.
Meine Schlussfolgerung nach diesem Februar: Wenn Einzelerfahrungen im Team zusammenfließen sollen, sind nicht die Prompts das Wertvolle. Es sind die Unterschiede. Zwei Entwickler, dieselbe Aufgabenklasse, verschiedene Ergebnisse – das ist kein Ärgernis, das ist ein Befund. Jede dieser Differenzen zeigt auf eine unausgesprochene Regel, eine Heuristik, ein Stück Urteilskraft, das bislang nur in einem Kopf existierte.
Mein Kollege arbeitet übrigens weiter mit dem Setup – inzwischen mit eigenen Instruktionsdateien, die sich von meinen zunehmend unterscheiden, und mit deutlich besseren Ergebnissen. Nicht weil er mich jetzt besser kopiert, sondern weil er aufgehört hat, es zu versuchen. Was er von mir übernommen hat, sind nicht die Dateien. Es sind die Fragen, die er sich vor jeder Delegation stellt.
Und damit stehe ich vor der Konsequenz, die sich jedes Team an dieser Stelle vornimmt, meines eingeschlossen: Wenn das entscheidende Wissen implizit ist, dann machen wir es eben explizit. Wir setzen uns hin, sprechen die Regeln aus, die bisher nur in Köpfen existierten, und schreiben sie auf – in genau die Dateien, die die KI bei jeder Session liest. Aufgabenzuschnitt, Prüfregeln, Abbruchkriterien, alles rein. Das muss doch reichen. Warum es das nicht tut – und warum die KI sich an unsere sorgfältig aufgeschriebenen Regeln erstaunlich selektiv hält – davon handelt die nächste Folge.
## Weiterführende Quellen
- [METR: Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/)
- [Google Cloud: Announcing the 2025 DORA Report](https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report)
- [Stack Overflow Developer Survey 2025: AI](https://survey.stackoverflow.co/2025/ai/)
---
# Was ich kritisch sehe
URL: https://www.mikebild.dev/de/blog/was-ich-kritisch-sehe/
Datum: 2026-02-10
An einem Donnerstagabend im Januar habe ich einen Pull Request beinahe durchgewunken, den ich selbst in Auftrag gegeben hatte. Claude Code hatte eine Datenbank-Migration geschrieben, sauber formatiert, mit Kommentaren, mit Rollback-Pfad. Ich habe sie gelesen, genickt, den Mauszeiger schon über dem Merge-Button gehabt – und dann, eher aus Gewohnheit als aus Misstrauen, doch noch die betroffene Tabelle im Staging-System angeschaut. Die Migration hätte funktioniert. Sie hätte nur nebenbei eine Spalte umbenannt, auf die ein Report zugreift, von dem die Session nichts wissen konnte. Kein Drama, schnell gefunden. Aber der Moment davor beschäftigt mich bis heute: Ich hatte nicht geprüft. Ich hatte gelesen, wie man einen gut geschriebenen Text liest – wohlwollend, mit dem Strom.
*Teil 4 der Serie „Von der Session zum System“ – hier geht es [zum Auftakt](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/).*
In der letzten Folge habe ich beschrieben, warum das Delegieren an KI für mich erst mit einem guten Harness funktioniert – mit Tools, Rückkopplung und Leitplanken um das Modell herum. Am Ende stand ein Unbehagen, das mit jeder delegierten Aufgabe lauter geworden ist. Dieses Unbehagen will ich heute ernst nehmen. Nicht als Alarmruf – ich arbeite weiter jeden Tag mit diesen Werkzeugen, gern und produktiv. Sondern als das, was Kritik eigentlich sein sollte: genau hinschauen, bevor man weitermacht. Ich trenne dabei vier Beobachtungen von einer offenen Hypothese.
## Wer nur noch prüft, verlernt das Bauen
Wenn ich Code nur selten selbst schreibe, muss ich inzwischen genauer unterscheiden: Fehlt mir nur eine API-Signatur, oder fehlt mir Übung in der Routine? Wer eine selten genutzte Bibliotheksfunktion braucht, schlägt ihre Signatur nach – das war immer so und ist kein Problem. Das Problem wäre die Richtung der Bewegung: Wenn nicht mehr nur die Ausnahme nachgeschlagen wird, sondern die Routine ganz entfällt, fehlt die Wiederholung, aus der Geläufigkeit entsteht. Ob und wie schnell das bei mir passiert, kann ich nicht messen. Deshalb erledige ich bestimmte Routineaufgaben bewusst ohne KI und achte darauf, wo mir Übung fehlt.
Die CHI-2025-Studie von Microsoft Research und Carnegie Mellon befragte dazu 319 Wissensarbeiter. Höheres Vertrauen in generative KI hing in den Selbstauskünften mit weniger eingesetztem kritischem Denken zusammen. Das ist ein Zusammenhang in einer Befragung, kein Nachweis dafür, dass Fähigkeiten bereits abgebaut wurden. Meine Sorge geht einen Schritt weiter als das Ergebnis der Studie: Wer Routinearbeit abgibt und nur noch die Ausnahmen behandelt, könnte genau die Übung verlieren, die er für die Ausnahmen braucht.
Für mich ist das ein schleichendes Risiko, das ich aktiv managen kann. Mehr treibt mich um, wie die Rechnung für Berufsanfänger aussieht. Ich habe mein Handwerk gelernt, indem ich oft genug auf die Nase gefallen bin: Speicherlecks selbst gejagt, Race Conditions selbst gebaut und selbst verstanden. Wer in der Lernphase überwiegend generierten Code prüft, bekommt möglicherweise weniger Gelegenheit, diese Substanz aufzubauen – das ist eine Vermutung, keine Messung, und die zitierte Befragung sagt dazu nichts. Konkret würde dann die Erfahrung fehlen, die gutes Prüfen erst möglich macht: einschätzen zu können, ob ein Timeout, eine Sperre oder eine Error Handling zum eigenen System passt, weil man solche Entscheidungen selbst getroffen und ihre Folgen getragen hat.
## Plausibel ist nicht richtig
Die Szene vom Anfang hat einen Namen: Automation Bias. Eine systematische Übersicht von Goddard, Roudsari und Wyatt beschreibt ihn als Neigung, automatisierten Empfehlungen zu folgen und widersprechende Hinweise zu übersehen – die Forschung dazu ist älter als die aktuellen Sprachmodelle. Bei meiner Migration verstärkten die saubere Formatierung, die Kommentare und der mitgelieferte Rollback-Pfad genau diesen Vertrauenseindruck: Ich hätte beinahe freigegeben, was ich nicht geprüft hatte.
Ob Review und Vier-Augen-Prinzip gegen solche plausiblen Ausgaben systematisch schlechter greifen als gegen erkennbar schlampigen Code, kann ich nicht belegen.
Passend dazu haben Perry und Kollegen in einer kontrollierten Studie gezeigt, dass Teilnehmende mit KI-Assistent häufiger unsicheren Code schrieben und zugleich überzeugter waren, sicheren geschrieben zu haben. Die Studie untersucht keine Code-Reviews. Für meine Review-Praxis ist die Kombination deshalb ein Warnsignal, kein Wirksamkeitsbeleg.
## „Das hat die KI so gemacht“ ist keine Antwort
Im Review reicht mir „Das hat mir die KI so vorgeschlagen“ nicht als Begründung. Der Satz erklärt die Herkunft, aber nicht die Entscheidung. Warum ist der Timeout hier auf dreißig Sekunden gesetzt? Warum ist das für unser System richtig? Wenn darauf keine Antwort folgt, ist die Entscheidung im Review nicht begründet – denn die Session, die den Wert gewählt hat, ist längst beendet und hat ihre Gründe, falls es welche gab, mitgenommen.
In einem Review gibt es keine dritte Partei. Es gibt den Menschen, der den Code einbringt, und den Menschen, der ihn freigibt – beide mit Namen, beide ansprechbar, beide morgen noch da. Was das Werkzeug vorgeschlagen hat, ist so relevant wie die Frage, in welchem Editor der Code getippt wurde. Wer einen Pull Request stellt, sagt damit: Ich stehe dafür ein. Wenn diese Zusage sich auflöst, weil „die KI“ als diffuser Mitautor im Raum steht, verliert das Review seinen Kern. Dann prüfen zwei Menschen etwas, für das sich keiner zuständig fühlt.
## Schulden, die keiner aufgenommen hat
Technische Schulden können aus bewussten Abkürzungen entstehen: Wir bauen jetzt die schnelle Lösung und räumen später auf. Man kannte die bewusst eingegangenen Abkürzungen und ihre Folgen. Daneben sehe ich eine mögliche zweite Variante: Code, der funktioniert, alle Tests besteht – und den niemand im Team wirklich versteht. Nicht, weil er unverständlich wäre, sondern weil ihn nie jemand verstehen musste. Er wurde generiert, er lief, er wurde gemerged.
Wenn ein Team einen generierten Mechanismus beim Einbau nur im Groben nachvollzieht, kann es bei der nächsten Änderung nötig sein, Annahmen und Entscheidungsgründe zu rekonstruieren, bevor der Mechanismus sicher geändert werden kann. Dann kann technische Schuld entstanden sein, ohne dass sie jemand bewusst aufgenommen hätte – kein Vermerk, keine Entscheidung, kein „später räumen wir auf“. Solche Schulden können unbemerkt entstehen, weil keine bewusste Abkürzung dokumentiert wurde. Ein System, das zu größeren Teilen aus solchem Code besteht, ist nicht kaputt. Es ist etwas Schlimmeres: unverstanden bei voller Funktion.
## Wenn alle dasselbe Modell fragen, können Entwürfe ähnlicher werden
Die letzte Sorge ist eine offene Hypothese. Ein Gedankenexperiment macht sie greifbar: Vier Gruppen bekommen dieselbe offen gehaltene Entwurfsaufgabe, und alle vier stellen ihre erste Frage demselben Modell. Wie unterschiedlich fallen die Ergebnisse aus? Wenn alle mit einer sehr ähnlichen Erstantwort starten, kann diese Antwort den weiteren Entwurf prägen. Der Effekt ist nicht gemessen und hängt unter anderem von Prompt, Kontext, Sampling und Modell ab. Die erwähnte Microsoft-Studie untersucht ihn nicht.
Man kann mit den Achseln zucken und sagen: Konvergenz auf bewährte Muster ist doch gut. Teilweise stimmt das – ich bin der Letzte, der eine ausgefallene Lösung schon deshalb gut findet, weil sie ausgefallen ist. Aber Architektur-Vielfalt ist kein Selbstzweck, sondern ein Suchverfahren. Unterschiedliche Entwürfe machen alternative Annahmen und Zielkonflikte sichtbar. Meine Sorge lautet deshalb: Wenn viele Entwurfsentscheidungen durch denselben Filter laufen, verengt sich der Raum der ernsthaft geprüften Alternativen. Messen kann ich das nicht.
## Kritik heißt nicht Ablehnung
An dieser Stelle könnte der Text kippen – in Kulturpessimismus, in „früher haben wir noch richtig programmiert“. Das wäre bequem und falsch. Keiner dieser Punkte ist ein Argument gegen die Werkzeuge. Jeder einzelne ist ein Argument gegen einen bestimmten Umgang mit ihnen: den passiven. Kompetenz verfällt nicht, weil KI existiert, sondern weil ich aufhöre zu üben. Automation Bias schlägt zu, weil ich Plausibilität mit Korrektheit verwechsle. Verantwortung diffundiert, weil ich sie diffundieren lasse. Das ist der Haken an der Sache: Die Antwort liegt nicht im nächsten Modell-Release. Sie liegt bei mir.
Ich habe für mich ein paar Regeln aufgestellt. Keine Weisheiten, eher Hausregeln:
- Regelmäßig bewusst ohne KI arbeiten. Kein Verzichtsritual, eher ein Lauf ohne Uhr: bestimmte Aufgaben – ein Algorithmus, ein Datenmodell, ein kniffliger Bugfix – von Hand, um zu spüren, wo es hakt. Wo es hakt, prüfe ich, ob mir Übung fehlt oder nur eine selten genutzte API nicht präsent ist.
- Verstehens-Pflicht vor dem Merge. Nichts geht in den Hauptzweig, was ich nicht einem Kollegen an der Tafel erklären könnte – Zeile für Zeile bei kritischen Stellen. Kritische Stellen sind zum Beispiel möglicher Datenverlust, Rechteprüfungen, Concurrency und öffentliche APIs. „Im Groben nachvollzogen“ zählt nicht.
- Erst das eigene Urteil, dann das Modell. Bei Entwurfsfragen schreibe ich meine Position in drei Sätzen auf, bevor ich frage. Sie muss nicht die bessere sein; sie ist ein Anker gegen die plausible Erstantwort – Abweichungen werden dann zu echter Information.
- Herkunft benennen, Verantwortung behalten. Wenn Code generiert wurde, sage ich das im Review offen – und übernehme ihn trotzdem so, als hätte ich ihn getippt.
Nichts davon ist originell. Die zusätzliche Prüfung kostet mich Zeit, macht die Freigabe aber nachvollziehbarer. Und ich merke: Sie kostet Kraft. Im Alltag ist es einfacher, sie auszulassen.
Genau da endet allerdings die Reichweite dieses Textes. Alles, was ich hier beschrieben habe, sind Maßnahmen eines Einzelnen – meine Regeln, meine Disziplin, meine Hausregeln. Das trägt genau so weit, wie meine Selbstkontrolle reicht, und an schlechten Tagen reicht sie erstaunlich wenig weit. Ein Team kann sich nicht auf die private Disziplin seiner Mitglieder verlassen; zehn Leute mit zehn verschiedenen Hausregeln ergeben noch keine gemeinsame Arbeitsweise. Was mit diesen Beobachtungen passiert, wenn nicht einer so arbeitet, sondern ein ganzes Team – mit unterschiedlicher Erfahrung, unterschiedlicher Sorgfalt und Termindruck obendrauf – das ist die Frage, die ich mir für die nächste Folge vorgenommen habe.
## Weiterführende Quellen
- [The Impact of Generative AI on Critical Thinking (Microsoft Research / Carnegie Mellon, CHI 2025)](https://www.microsoft.com/en-us/research/publication/the-impact-of-generative-ai-on-critical-thinking-self-reported-reductions-in-cognitive-effort-and-confidence-effects-from-a-survey-of-knowledge-workers/)
- [Kate Goddard, Abdul Roudsari, Jeremy C. Wyatt: Automation bias – a systematic review of frequency, effect mediators, and mitigators (JAMIA, 2012)](https://academic.oup.com/jamia/article/19/1/121/732254)
- [Neil Perry, Megha Srivastava, Deepak Kumar, Dan Boneh: Do Users Write More Insecure Code with AI Assistants? (arXiv, 2022)](https://arxiv.org/abs/2211.03622)
---
# Gut genug: das Modell ist selten der Engpass
URL: https://www.mikebild.dev/de/blog/gut-genug-modelle/
Datum: 2025-12-09
*Teil 2 der Serie „Von der Session zum System“ – hier geht es [zum Auftakt](https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/).*
Ende November, ein Architektur-Review mit einem Team, das ich begleite, zweiter Tag, erste Kaffeepause. Ein Entwickler kommt mit der Tasse in der Hand zu mir und stellt die Frage, die seit zwei Jahren in jedem Teamgespräch und jedem Flurgespräch auf Konferenzen fällt: „Welches Modell nehmt ihr denn?“ Diesmal mit besonderem Nachdruck, denn der November 2025 war verrückt: GPT-5.1 am 12., Grok 4.1 am 17., Gemini 3 am 18., Claude Opus 4.5 am 24. Vier Flaggschiff-Ankündigungen in zwölf Tagen, dazu die üblichen Benchmark-Screenshots, die durch die Timelines wandern. Sein Team, erzählt er, diskutiert seit Wochen, ob man wechseln müsse.
Ich habe diese Frage früher ernsthaft beantwortet, mit Modellnamen und Begründung. Jede dieser Antworten war nach sechs Wochen veraltet. Inzwischen antworte ich anders: „Das ist die zweite Frage. Lass uns über die erste reden.“
## Die Konvergenz, über die niemand gern spricht
Nüchtern und ohne Anbieter-Loyalität betrachtet: Bei dem großen Block an Alltagsaufgaben, für den ich KI einsetze, lagen die großen Modelle Ende 2025 in meinen eigenen Versuchen nah genug beieinander. Code lesen und erklären, ein Refactoring vorschlagen, Tests entwerfen, ein Konzeptpapier gegenlesen, eine API-Dokumentation zusammenfassen, einen Migrationspfad skizzieren – das bekam ich mit GPT-5, Claude Sonnet 4.5 und Gemini in brauchbarer Qualität hin. Nicht gleich gut in jedem einzelnen Lauf, aber gut genug, dass die Modellwahl selten meine erste Baustelle war.
Natürlich sind sie nicht identisch. Jedes Modell hat einen eigenen Ton, eigene Vorlieben, eigene Schwächen, und bei einzelnen Aufgaben können die Unterschiede groß sein. Öffentliche Benchmarks helfen mir nur begrenzt, weil sie weder meinen Kontext noch meine Prüfkriterien abbilden und sich mit neuen Versionen schnell verschieben. Für eine Architekturentscheidung brauche ich deshalb Messungen an den eigenen Aufgaben statt eine allgemeine Rangliste.
Das erzähle ich in solchen Runden ungern als Erster, weil es die Diskussion abkühlt, auf die sich alle gefreut haben. Der Modellvergleich ist unterhaltsam, er fühlt sich nach Ingenieursarbeit an, und er hat den Charme, dass man dabei nichts an der eigenen Arbeitsweise ändern muss. Aber er beantwortet die falsche Frage.
## Das Rauschen im Alltag ist größer als der Unterschied zwischen Modellen
Wenn bei mir eine Session mit Claude oder ChatGPT schiefgeht, dann liegt das fast nie am Modell. Es liegt daran, dass ich die Aufgabe unklar gestellt habe. Dass das Modell den Kontext nicht kannte, der für die Lösung entscheidend war – die Architekturentscheidung von vor zwei Jahren, die ungeschriebene Konvention im Team, den Grund, warum dieser eine Service anders aufgebaut ist als alle anderen. Oder daran, dass ich das Ergebnis nicht geprüft habe und der Fehler erst im Review auffiel.
Ein Beispiel aus einem Teamgespräch in einem großen Konzern, anonymisiert wie immer: Zwei Kollegen, dasselbe Modell, dieselbe Aufgabe – ein Stück Legacy-Code verstehen und einen Umbau vorschlagen. Der eine bekam einen brauchbaren, konkreten Plan. Der andere bekam generischen Lehrbuch-Text. Der Unterschied war nicht das Modell, nicht einmal der Prompt im engeren Sinne. Der eine hatte dem Modell die relevanten Dateien, die Testfälle und die Randbedingungen mitgegeben. Der andere hatte eine Frage in ein leeres Fenster getippt.
In meinen eigenen Sessions schwankt das Ergebnis durch Aufgabenzuschnitt, Kontext und Prüfung oft stärker als durch den Wechsel zwischen den betrachteten Spitzenmodellen. Das ist keine allgemeine Messung des Marktes, sondern eine Beobachtung aus dieser Arbeit. Für mich folgt daraus: Bevor ich das Modell wechsle, prüfe ich zuerst, ob Aufgabe, Kontext und Abnahmekriterium sauber genug sind.
## Wer auf das beste Modell wettet, wettet auf eine Commodity
Damit zur These, die ich für die wichtigste dieses Beitrags halte: Wer seine Arbeitsweise oder gar sein Produkt auf „das beste Modell“ baut, wettet auf eine Commodity, die er nicht besitzt.
Die Modelle gehören einer Handvoll Anbieter. Ich miete Zugriff über einen API-Schlüssel oder ein Abo, genau wie mein Wettbewerber, genau wie jedes andere Team. Ich kann nicht steuern, wann eine Version abgekündigt wird, wann sich das Verhalten nach einem Update leise verschiebt, wann der Preis fällt oder das nächste Modell die Rangliste umwirft. Der November hat das vorgeführt: Wer im Oktober seine Wahl auf einen Benchmark-Vorsprung gestützt hat, sah diesen Vorsprung innerhalb von zwei Wochen dreimal den Besitzer wechseln.
Was ich dagegen besitzen kann, ist die Schicht um das Modell herum. Das ist keine Plattform und kein Produkt, sondern schlicht alles, was ich selbst in der Hand habe, bevor und nachdem das Modell rechnet:
- der Zuschnitt der Aufgaben, also die Fähigkeit, Arbeit so zu zerlegen, dass ein Stück davon delegierbar wird
- der Kontext, den eine Session am Anfang bekommt, statt dass das Modell meine Realität erraten muss
- das Wissen des Teams in abrufbarer Form, von Konventionen bis zu den Gründen hinter alten Entscheidungen
- der Prozess, der regelt, wann die KI arbeitet, wann ein Mensch prüft und was in den Main-Branch darf
- die Prüfung selbst, also verlässliche Wege festzustellen, ob ein Ergebnis stimmt, bevor es etwas bewirkt
Diese Schicht ist das Gegenteil einer Commodity. Sie ist spezifisch für mein Team, meine Codebasis, meine Domäne. Niemand kann sie mir durch ein Release wegnehmen, und der Wettbewerber kann sie nicht einfach mitmieten. Vor allem aber: Sie überlebt Modellwechsel. Eine Stunde, die ich in bessere Aufgabenbeschreibungen, in eine gepflegte CLAUDE.md oder AGENTS.md, in Review-Kriterien investiere, zahlt sich auch mit dem übernächsten Modell noch aus. Eine Stunde Benchmark-Studium ist beim nächsten Release entwertet.
Es gibt einen angenehmen Side Effect, den ich aus der Architektur-Arbeit kenne: Wer die Schicht besitzt, für den sinken die Wechselkosten. Wenn Aufgabenzuschnitt, Kontext und Prüfung sauber stehen, ist das Modell dahinter austauschbar wie eine Abhängigkeit hinter einer klaren Schnittstelle. Dann kann ich sogar gelassen wechseln, wenn es einen echten Grund gibt – weil mein eigentliches Kapital nicht am Modellnamen hängt.
## Wo die Modellwahl doch zählt
Ehrlichkeit gehört dazu, sonst wird aus der These ein Dogma. Es gibt Situationen, in denen die Modellwahl eine echte, messbare Rolle spielt. Drei begegnen mir regelmäßig.
Erstens die Spezialfälle. Wer mit exotischen Sprachen oder Nischen-Frameworks arbeitet, stark multimodale Aufgaben hat oder aus Datenschutzgründen on-premises bleiben muss, landet schnell bei kleineren offenen Modellen – und dort sind die Qualitätsunterschiede real und die Abwägungen andere. „Gut genug“ gilt für die großen Frontier-Modelle bei Alltagsaufgaben, nicht für jede Modellklasse bei jeder Aufgabe.
Zweitens Kosten und Latenz. Sobald Modelle nicht mehr interaktiv, sondern in Volumen laufen – Klassifikation in einer Pipeline, Autovervollständigung im Editor, Verarbeitung tausender Dokumente –, werden Preis pro Token und Antwortzeit zu harten Kriterien. Da liegen zwischen den Modellen Faktoren, nicht Prozentpunkte, und es lohnt sich zu messen.
Drittens lange, agentische Aufgaben. Hier trennen sich die Modelle Ende 2025 tatsächlich noch spürbar: wie lange sie an einer mehrstufigen Aufgabe fokussiert bleiben, wie zuverlässig sie Tools bedienen, wie sie mit eigenen Fehlern umgehen. Nicht zufällig wurden Claude Sonnet 4.5 im September und Opus 4.5 im November genau über diese Fähigkeit beworben. Wer ganze Arbeitspakete delegiert statt einzelner Fragen, darf bei der Modellwahl wählerisch sein.
Aber – und das ist mir wichtiger als die drei Ausnahmen selbst – all das ist die zweite Frage. Sie lässt sich erst dann seriös beantworten, wenn die erste beantwortet ist. Ohne klaren Aufgabenzuschnitt und ohne verlässliche Prüfung kann ich Modelle nämlich gar nicht vergleichen; ich vergleiche dann nur Bauchgefühle an unterschiedlichen Tagen. Erst wenn die Schicht steht, wird die Modellwahl zu dem, was sie sein sollte: eine Optimierung mit Messwerten, ungefähr so aufregend wie die Wahl eines Datenbank-Index. Und wie dort gilt: gelegentlich neu bewerten, Versionen bewusst festhalten, Verhaltensänderungen nach Updates ernst nehmen. „Gut genug“ heißt weder „alle gleich“ noch „für immer“ – es heißt nur: nicht der Engpass.
## Die erste Frage
Zurück in die Kaffeepause. Bleibt bei dem Modell, das ihr habt, habe ich ihm gesagt, und steckt die Diskussionsenergie eures Teams in die Fragen davor und danach. Woran erkennt ihr, dass ein Ergebnis stimmt? Was müsste eine Session über euer System wissen, um nicht zu raten? Welche eurer Aufgaben sind überhaupt so geschnitten, dass man sie abgeben kann? Wer diese drei Fragen gut beantwortet, holt aus jedem der aktuellen Modelle mehr heraus als der Nachbar mit dem Benchmark-Sieger und leerem Kontextfenster.
Er war sichtlich unzufrieden – die Antwort ist weniger spektakulär als ein Modellvergleich, und sie macht Arbeit. Aber sie hat eine Konsequenz, die mich seither beschäftigt und die den Rest dieser Serie trägt: Wenn das Modell selten der Engpass ist, dann macht irgendetwas anderes den Unterschied zwischen der Session, die liefert, und der, die Zeit verbrennt. Bei mir läuft es jedes Mal auf die Umgebung hinaus, in der das Modell arbeitet – wie viel sie ihm zeigt, was sie ihm erlaubt und wogegen sie seine Ergebnisse hält. Genau dort geht es in der nächsten Folge weiter.
## Weiterführende Quellen
- [Anthropic: Introducing Claude Opus 4.5](https://www.anthropic.com/news/claude-opus-4-5)
- [Google: Gemini 3 – das bislang leistungsfähigste Modell von Google](https://blog.google/products/gemini/gemini-3/)
- [Simon Willison: Claude Sonnet 4.5 is probably the best coding model in the world (at least for now)](https://simonwillison.net/2025/Sep/29/claude-sonnet-4-5/)
- [Anthropic Engineering: Effective context engineering for AI agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)
---
# Vom Werkzeug zur Arbeitsweise
URL: https://www.mikebild.dev/de/blog/von-der-session-zum-system-auftakt/
Datum: 2025-11-18
*Auftakt der Serie „Von der Session zum System“.*
Vor einiger Zeit saß ich in Berlin mit [Sebastian Korfmann](https://skorfmann.com/) zusammen. Sebastian kenne ich als Software-Engineer aus dem Cloud- und Infrastruktur-Umfeld – jemand, der Werkzeuge nicht nach Marketing-Folien beurteilt, sondern danach, ob sie ihm im Alltag Arbeit abnehmen. Er erzählte von seinen Erfahrungen mit KI-Werkzeugen: was er damit baut, wie sich seine Arbeit verändert hat, wo es hakt. Ich habe interessiert zugehört – und dabei gemerkt, dass ich selbst erstaunlich wenig beisteuern konnte.
Das muss ich erklären. Ich arbeite seit über dreißig Jahren an Software, einen großen Teil davon an verteilten Systemen – Node, TypeScript, GraphQL, Cloud-Architekturen – und habe über viele Jahre Training für Softwareentwickler und Architekten gegeben. Was mich an dieser Arbeit am meisten reizt: digitale Produkte zu bauen, und zwar ganzheitlich. Die Fachdomäne wirklich verstehen, Richtungsentscheidungen treffen, gestalten – es geht mir schon lange nicht mehr nur um Programmierung und Architektur. Mit den Jahren haben sich auch meine Schwerpunkte verschoben: weg davon, jedes feine Detail selbst in der Hand zu haben, hin zu Struktur, Konsistenz, Prozessen, Produktivität, Methoden und Konzepten. Mit KI hatte ich bis dahin trotzdem noch nie gearbeitet. Keine einzige Session, kein Copilot. Nicht aus Ablehnung – grundsätzliche Skepsis gegenüber neuer Technik ist nicht meine Art. Es hatte sich schlicht nie ergeben. Der Rummel seit dem ChatGPT-Start Ende 2022 war zwar nicht zu überhören – Schlagzeilen, Konferenz-Keynotes, Kollegen, die davon erzählten –, aber was ich hörte und las, klang für mich nach beeindruckenden Demos, und meine Tage waren voll. Wenn überhaupt, war ich ein bisschen zurückhaltend – so, wie man eben zurückhaltend ist bei Dingen, die man noch nicht selbst ausprobiert hat.
Dazu kam noch etwas anderes, und darüber rede ich nicht so gern, weil es nichts mit Technik zu tun hat, sondern mit mir. Ich war müde geworden. Nicht am Beruf, sondern an einer bestimmten Sorte Vorhaben: eigene, größere Projekte, digitale Produkte, die ich lange im Kopf hatte. Ich kenne die Komplexität solcher Vorhaben gut genug, um zu wissen: Viele dieser Themen kann ich allein nicht in der Qualität umsetzen, die ich selbst erwarte. Die Ideen waren da, teils detailliert ausgearbeitet, in Notizen und halb angefangenen Repositories. Was fehlte, war die Kraft für die schiere Menge an Umsetzungsarbeit – neben Anstellung und allem anderen. Wer einmal versucht hat, ein komplettes Produkt allein zu bauen, kennt das Verhältnis: Auf eine Stunde, in der man wirklich gestaltet – eine Richtungsentscheidung, ein Konzept, ein Stück Fachlichkeit –, kommen zwanzig Stunden Fleißarbeit. Boilerplate, Konfiguration, Formulare, Error Handling, Deployment, Dokumentation, dazu das ganze Organisatorische drumherum. Irgendwann habe ich aufgehört, neue Schubladen aufzumachen, weil die alten schon voll waren.
In dieser Verfassung traf ich also Sebastian. Was mich an dem Gespräch gepackt hat, war seine Art zu erzählen: keine Superlative, keine „das verändert alles“-Rhetorik, sondern die nüchterne Art, in der man einem Kollegen von einem Werkzeug berichtet, das sich im Alltag bewährt hat. Diese Tonlage kannte ich, und sie machte mich neugierig. Also habe ich mir vorgenommen, das Ganze endlich selbst auszuprobieren. Nicht zehn Minuten, sondern ein paar Tage, an echten Aufgaben.
## Die ersten Tage
Ich habe mit Claude und ChatGPT angefangen, im Browser, an Aufgaben aus meinem tatsächlichen Alltag: ein Architekturkonzept gegenlesen, eine API-Migration skizzieren, einen Datenimport schreiben, den ich sonst vor mir hergeschoben hätte. Kurz darauf kamen Claude Code und Codex dazu – also die Werkzeuge, die nicht nur antworten, sondern im Terminal direkt am Repository arbeiten: Dateien lesen, ändern, Tests laufen lassen. Anthropic hatte Ende September Claude Sonnet 4.5 veröffentlicht, OpenAI etwa zeitgleich sein Codex-Update; ich bin, ohne es zu planen, in einem ziemlich guten Moment eingestiegen.
Und dann passierte etwas, womit ich nicht gerechnet hatte: Ich war binnen Tagen sehr angetan. Nicht milde interessiert – angetan. Drei Dinge haben mich erwischt:
- Die Geschwindigkeit. Aufgaben, für die ich einen halben Tag angesetzt hätte, waren in einer Stunde in einem Zustand, den ich ernsthaft reviewen konnte.
- Die Produktivität über den ganzen Tag. Nicht ein einzelner beeindruckender Moment, sondern die Summe: Es blieb abends messbar mehr fertig liegen als vorher.
- Die Qualität. Das hatte ich am wenigsten erwartet. Der erzeugte Code war nicht fehlerfrei, aber deutlich besser, als ich es nach allem, was ich über generierten Code gehört und gelesen hatte, erwartet hätte – strukturiert, mit sinnvoller Error Handling, oft mit Tests.
Aus den paar Tagen Probe wurden Wochen täglicher Arbeit. Inzwischen arbeite ich jeden Tag mit diesen Werkzeugen und steige immer tiefer ein – gerade erst hat Anthropic mit den Skills eine Möglichkeit nachgelegt, Claude wiederverwendbare Arbeitsanweisungen mitzugeben, und ich merke, dass ich anfange, solche Ankündigungen zu lesen wie früher Release-Notes von Node.
Ein paar Wochen sind keine Erfahrung. Das ist mir bewusst, und genau deshalb schreibe ich das hier auf. Wer so schnell zum täglichen Nutzer wird, sollte der eigenen Begeisterung erst einmal misstrauen – frische Begeisterung ist ein schlechter Zeuge. Also versuche ich, genau hinzuschauen und zu notieren, was ich tatsächlich beobachte – mit dem einzigen Prüfstein, den ich habe: über dreißig Jahre Handwerk, an denen ich jedes Ergebnis messen kann.
## Beobachtung eins: Erzeugen wird billig, Prüfen wird der Engpass
Die erste Verschiebung habe ich schon nach wenigen Tagen bemerkt, und sie ist fundamentaler, als sie klingt. Der teure Teil meiner Arbeit war immer das Erzeugen: Code schreiben, Dokumente formulieren, Konzepte ausarbeiten. Das Prüfen – Reviews, Gegenlesen, Abnahme – war der kleinere Posten. Dieses Verhältnis kippt gerade. Erzeugen ist plötzlich billig; in einer Stunde entsteht mehr Text und Code, als ich früher an einem Tag geschafft hätte. Was nicht billiger geworden ist: beurteilen, ob das Erzeugte stimmt. Meine Arbeit verlagert sich sichtbar vom Schreiben zum Lesen, vom Produzieren zum Begutachten.
Im Gespräch mit einem Kollegen habe ich dafür eine Formulierung gefunden, die hängen geblieben ist: Das Werkzeug ist weniger Assistent, mehr Sekretär. Ein Assistent, wie ihn die Produktnamen versprechen, ergänzt hier eine Zeile und schlägt dort ein Wort vor – die Arbeit bleibt meine. Ein Sekretär im alten Sinn nimmt ganze Vorgänge entgegen: Ich diktiere die Absicht, er fertigt das Schriftstück, und ich zeichne ab. Das klingt bequemer, ist aber eine andere Verantwortung. Beim Assistenten prüfe ich Vorschläge im Vorbeigehen; beim Sekretär muss ich das fertige Stück wirklich lesen, denn meine Unterschrift steht darunter. Wer abzeichnet, ohne zu lesen, hat nicht delegiert, sondern kapituliert. Ich ahne, dass in dieser Verschiebung der eigentliche Umbau meiner Arbeitsweise steckt – nicht im Werkzeug selbst.
## Beobachtung zwei: Die Schubladen gehen wieder auf
Die zweite Beobachtung ist persönlicher, und sie hat mich mehr überrascht als jede Benchmark. Die Müdigkeit, von der ich oben geschrieben habe, ist nicht weg – aber sie hat ihren Grund verloren. Die Produktideen, die liegen geblieben sind, weil die Umsetzung für einen Einzelnen zu groß war, sind plötzlich wieder in Reichweite. Nicht, weil die KI das Produkt baut. Sondern weil sie genau den Teil übernimmt, der mich zermürbt hat: die zwanzig Stunden Fleißarbeit rund um die eine Stunde, die wirklich Nachdenken verlangt. Das Formular-Grundgerüst, die Testabdeckung, der Import-Adapter, das Deployment-Skript – all das entsteht jetzt so schnell, dass ich – wie sagt man so schön – das Eisen schmieden kann, solange es heiß ist.
Vielleicht hat mich das Ganze auch deshalb so schnell für sich eingenommen: Meine Schwerpunkte hatten sich über die Jahre ohnehin genau dorthin verschoben, wo diese Werkzeuge nichts wegnehmen – Struktur, Konsistenz, Konzepte, die Fachdomäne, die Richtungsentscheidungen. Die Detailarbeit dagegen und die wiederkehrenden Aufgaben, auch die organisatorischen, gehen mir jetzt wieder leichter von der Hand. Nicht alle. Aber genug, dass es wieder Spaß macht.
Ich habe in den letzten Wochen abends wieder an eigenen Sachen gebaut, freiwillig und mit einer Freude, die ich eine Weile nicht hatte. Das ist die Stelle, an der ich vorsichtig formulieren muss, weil sie sich so leicht zur Heilsbotschaft aufblasen lässt. Also nüchtern: KI ist für mich gerade vor allem ein Hebel für den Einzelnen mit Erfahrung. Die Betonung liegt auf beidem. Der Hebel wirkt, weil ich nach dreißig Jahren weiß, was ich bauen will, wie es geschnitten sein muss und woran ich erkenne, dass ein Ergebnis taugt. Ob derselbe Hebel auch für jemanden wirkt, der diese Urteilsfähigkeit noch nicht hat, weiß ich schlicht nicht – ich habe da einen Verdacht, aber Verdacht ist kein Wissen, und für diese Serie will ich beides sauber auseinanderhalten.
## Beobachtung drei: Der Ton stimmt immer
Die dritte Beobachtung halte ich nur kurz fest, denn ich verstehe sie noch nicht gut genug, um mehr daraus zu machen. Mir fällt auf, *wie* diese Systeme antworten. Im Berufsleben gibt es dafür ein augenzwinkerndes Kürzel: SABTA – sicheres Auftreten bei totaler Ahnungslosigkeit. Die Psychologie kennt das Muster als Dunning-Kruger-Effekt: Am selbstbewusstesten tritt oft auf, wer am wenigsten weiß. Genau so wirken diese Systeme auf mich – die richtige Auskunft und die falsche kommen im selben ruhigen, kompetenten Ton. In einem Code-Review verrät sich ein unsicherer Kollege durch Formulierungen – „ich glaube“, „müsste eigentlich“. Hier gibt es dieses Signal nicht. Zweimal in den vergangenen Wochen hätte ich beinahe eine Behauptung übernommen, die sich bei der Prüfung als frei erfunden herausstellte – eine API-Signatur, die es nie gab, souverän vorgetragen. Beide Male hat mich nur die Gewohnheit gerettet, Dinge nachzuschlagen. Dieses sichere Auftreten verdient ein grundsätzliches Misstrauen, und ich will verstehen, woher es kommt – strukturell, nicht anekdotisch. Das hebe ich mir für später in dieser Serie auf, wenn die Beobachtungen dafür beisammen sind.
## Was diese Serie werden soll
Ich beginne hier eine Serie, weil ich ahne, dass die Geschichte größer ist als mein Schreibtisch. Im Moment beobachte ich mich selbst: einen Einzelnen in der Session, mit direkter Kontrolle über jedes Ergebnis. Aber ich arbeite nicht allein – ich arbeite in und mit Teams, und ein Team ist etwas anderes als die Summe einzelner Sessions. Und über den Teams stehen Unternehmen mit ihren Prozessen, ihrem Wissen, ihrer Verantwortung. Diesen Bogen will ich in den kommenden Folgen Schritt für Schritt durchgehen: vom Ich über das Wir zum System. Nicht als Theorie, sondern entlang dessen, was ich tatsächlich erlebe und ausprobiere – inklusive der Sackgassen, von denen es absehbar einige geben wird.
Die nächste Frage drängt sich dabei schon auf. Im Team, mittags unter Kollegen, zuletzt auf einem Konferenzflur: Das Gespräch landet nach wenigen Minuten an derselben Stelle. Welches Modell ist das beste? Claude oder GPT, welche Version, welche Benchmark. Ich habe diese Diskussion selbst geführt und dabei ein Unbehagen entwickelt, das ich erst allmählich einordnen kann: Nach diesen ersten Wochen täglicher Arbeit fällt mir auf, dass die Wahl des Modells meine Ergebnisse weniger verändert hat als so ziemlich alles andere an meiner Arbeitsweise. Alle reden über das beste Modell – aber ist das überhaupt die richtige Frage? Der gehe ich in der nächsten Folge nach.
## Weiterführende Quellen
- [Introducing Claude Sonnet 4.5](https://www.anthropic.com/news/claude-sonnet-4-5) – Anthropics Ankündigung des Modells, mit dem ich eingestiegen bin (September 2025)
- [Claude Sonnet 4.5 is probably the „best coding model in the world“](https://simonwillison.net/2025/Sep/29/claude-sonnet-4-5/) – Simon Willisons nüchterne Ersteinschätzung
- [Introducing upgrades to Codex](https://openai.com/index/introducing-upgrades-to-codex/) – OpenAIs Codex-Update mit GPT-5-Codex (September 2025)
- [Equipping agents for the real world with Agent Skills](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills) – Anthropics Engineering-Beitrag zu Skills (Oktober 2025)
---
# React-Überblick: Von JSX zur Komponentenarchitektur
URL: https://www.mikebild.dev/de/blog/react-ueberblick-von-jsx-zur-architektur/
Datum: 2024-12-30
# React-Überblick: Von JSX zur Komponentenarchitektur
React nimmt einem das Rendern ab, nicht die Architektur. Die Bibliothek berechnet aus einem State eine Oberfläche und schreibt die Unterschiede ins DOM – aber wo dieser State liegt, wie lange er lebt und wer ihn ändern darf, entscheidet sie an keiner Stelle. Genau dort, an dieser unscheinbaren Grenze, entstehen die Probleme, die sich später mit keinem Hook und keiner Bibliothek mehr wegräumen lassen.
Dieser Beitrag geht React deshalb einmal am Stück durch – vom ersten Stück JSX bis zu der Stelle, an der aus einzelnen Komponenten ein System wird. Es ist bewusst ein Überblick. Zu den meisten Stationen, die ich hier nur kurz betrete, folgen später eigene Beiträge, die tiefer graben. Heute geht es darum, den großen Bogen im Kopf zu haben, bevor man sich in ein Detail verliert.
Ich stütze mich dabei auf zwei Repositories, die ich gerade zusammenführe: `introduction-react` für die Grundlagen und `advanced-react` für die fortgeschrittenen Muster. Beide sind kein Foliensatz in Textform, sondern lauffähiger Code, an dem wir gemeinsam üben. Der Stand, den ich hier beschreibe, ist React 19 – die stabile Version von Ende 2024, mit allem, was seither zum Alltag geworden ist.
## Das mentale Modell: die Oberfläche ist eine Funktion des States
Bevor eine einzige Zeile JSX Sinn ergibt, muss ein Gedanke sitzen. React dreht die Art um, wie man über eine Oberfläche nachdenkt. Statt Schritt für Schritt zu beschreiben, wie sich das DOM verändern soll – hier ein Element einfügen, dort ein Attribut ändern, da einen Knoten entfernen –, beschreibt man nur, wie die Oberfläche für einen gegebenen State aussehen soll. React kümmert sich um den Weg dorthin.
Man kann das in eine einzige Zeile fassen, die den ganzen Rest trägt: Die Oberfläche ist eine Funktion des States. Ändert sich der State, ruft React die Funktion erneut auf, vergleicht das Ergebnis mit dem vorherigen und schreibt nur die tatsächlichen Unterschiede ins echte DOM. Dieser Abgleich läuft über eine interne, leichtgewichtige Repräsentation des Baums, oft Virtual DOM genannt. Der Name ist weniger wichtig als die Konsequenz: Man beschreibt das Ziel, nicht den Weg. Wie dieser Abgleich Schritt für Schritt abläuft, zeige ich ausführlich im Beitrag [Wie React den Baum rendert und aktualisiert](https://www.mikebild.dev/de/blog/wie-react-den-baum-rendert-und-aktualisiert/).
```mermaid
flowchart LR
State["Zustand (state)"] --> Render["Komponente rendert"]
Render --> View["beschriebene Oberfläche"]
View --> DOM["React gleicht ab und schreibt ins DOM"]
User["Nutzerinteraktion"] --> Event["Event / setState"]
Event --> State
```
Der zweite tragende Gedanke ist der unidirektionale Datenfluss. Daten fließen von oben nach unten, von der Elternkomponente zum Kind, über Props. Events fließen in die andere Richtung, als Callbacks nach oben. Es gibt keine geheimnisvolle Zweiwegbindung, bei der ein Eingabefeld und eine Variable magisch synchron bleiben. Das wirkt am Anfang umständlicher als in älteren Frameworks, aber es ist der Grund, warum sich React-Anwendungen auch nach zwei Jahren noch erklären lassen: Man kann für jede Stelle der Oberfläche sagen, woher ihre Daten kommen und wer sie ändern darf.
## JSX und Komponenten: die kleinste Einheit ist eine Funktion
JSX sieht aus wie HTML im JavaScript, ist aber nur eine bequeme Schreibweise für Funktionsaufrufe. Ein `