Ich glaube, im September 2026 sind wir uns einig: Modelle wie Sonnet oder Grok 4.6 schreiben ziemlich ordentlichen Code. Gibt man ihnen dazu noch Coding-Guidelines, Architekturvorgaben und Tests mit, lässt sich kaum noch sagen, ob ein Mensch oder eine Maschine ihn geschrieben hat.

Und wenn wir noch einen Schritt weitergehen, ein paar Agenten fürs Testen und Dokumentieren dazunehmen und das Ganze Harness nennen, musst du dir keine Gedanken mehr darüber machen, ob das Ergebnis technisch wasserdicht ist.

Fast so, als hättest du ein Team eingestellt, das die Arbeit für dich erledigt … wie ein Manager eben. Aber was machst du dann eigentlich?

Tja, was macht ein Manager den ganzen Tag? Im besten Fall rennt er nicht seinem Team hinterher und kontrolliert jeden Handgriff.

Ein guter Manager hat stattdessen gelernt, dass es gar nicht darum geht, Menschen zu managen. Es geht darum, ein Umfeld zu schaffen (und zu pflegen), in dem Menschen ihre beste Arbeit machen.

Genau das ist auch deine Aufgabe im Zeitalter der Agenten.

… aber sollte ich den Code nicht trotzdem prüfen?

Treiben wir die Metapher mal richtig auf die Spitze: Du hast gerade als CTO bei einem E-Commerce-Unternehmen angefangen und steckst mitten in deiner ersten Woche.

Du triffst dich mit den Entwicklern auf einen ersten Kaffee, und nach allem, was sie erzählen, steht das Produkt im Großen und Ganzen gut da.

Trotzdem willst du wissen, wie es wirklich aussieht. Also schaust du dir selbst etwas Code an.

Aber nicht alles, nur ausgewählte Teile. Mit Template-Code hältst du dich kaum auf. Du schaust dir die zentrale Geschäftslogik an – den Teil des Codes, mit dem das Geld verdient wird und der für Regulierung und Datenschutz eine Rolle spielen kann.

Solange sich daran nichts ändert, musst du ihn dir nicht noch einmal ansehen.

Das heißt nicht, dass du deinem Team misstraust. Du willst einfach wissen, woran du bist.

Und was du siehst, stärkt dein Vertrauen – oder eben nicht.

Genauso arbeitest du mit Agenten.

Du verlässt dich nicht blind auf den Code, den sie schreiben. Du schaust ihn dir zuerst an und sorgst dafür, dass ihr beide – du UND der Agent – dasselbe Verständnis davon habt, was „gut“ bedeutet.

Mit der Zeit schaust du weniger hin und vertraust mehr.

Aber auch dann nicht blind. Denn inzwischen hast du die Systeme verbessert und Mechanismen eingebaut, die dafür sorgen, dass die Codequalität hoch bleibt.

Und dann?

Die Anforderungen an dein Agenten-Team verändern sich mit der Zeit:

  • Ein neues Feature steht an, für das du deinem Agenten neue Tricks beibringen musst.
  • Du führst neue Abhängigkeiten oder Architekturänderungen ein, die die Agenten berücksichtigen müssen.
  • Plötzlich gibt es auch eine mobile App, die in den Arbeitsablauf deiner Agenten eingebunden und mitgeprüft werden muss.
  • Du entdeckst eine neue Fähigkeit der KI, die du in deinem Arbeitsablauf nutzen willst.
  • -Du merkst, dass ein Agent immer wieder denselben Fehler macht und damit in Produktion für Ärger sorgt.

Also passt du dich an und entwickelst die Fähigkeiten deiner Agenten weiter.

Das kann heißen: Skills definieren und aktualisieren, Arbeitsabläufe reparieren, den Kontext verbessern – etwa indem du deinen Agenten zusätzlich zu den Jira-Tickets Zugriff auf Figma gibst – und vieles mehr.

Kurz: Du arbeitest am System, statt deine Agenten zu micromanagen.