Im Juni 2026 veröffentlichte Forbes einen Artikel mit der Frage, ob Vibe Coding bereits tot sei. Der Artikel bezog sich auf Andrej Karpathys Wechsel vom Begriff "Vibe Coding" hin zu "Agentic Engineering". Er beschreibt damit etwas, das viele Softwareteams bereits spüren: Die Art, wie wir Software bauen, hat sich schneller verändert als unsere Sprache dafür.

Vibe Coding war die Phase, in der du beschrieben hast, was du willst, und ein KI-Tool Code generiert hat. Agentic Engineering geht weiter. Du gibst einem KI-Agenten ein Ziel, er schreibt Code, führt Tests aus, liest Fehler, behebt Probleme und berichtet zurück. Die menschliche Rolle verschiebt sich vom Tippen jeder Zeile hin zum Steuern der Arbeit.

Diese Veränderung ist real. Aber es gibt eine gefährliche Interpretation davon.

Die falsche Schlussfolgerung lautet: "Ich muss Software nicht mehr verstehen. Der Agent baut sie für mich."

Die bessere Schlussfolgerung lautet: "Ich werde vielleicht nie wieder Code so schreiben wie früher, aber ich brauche stärkere Grundlagen denn je, weil ich jetzt viel mehr Output prüfen, steuern und verantworten muss, als ich selbst getippt habe."

KI kann dir helfen, schneller zu bauen. Ohne technisches Verständnis kann sie dir aber auch helfen, schneller ein Kartenhaus zu bauen.

Was ist Agentic Engineering?

Agentic Engineering ist Softwareentwicklung, bei der KI-Agenten mehrstufige Engineering-Aufgaben mit einem gewissen Grad an Autonomie ausführen. Statt nach einem einzelnen Code-Snippet zu fragen, gibst du einem Agenten eine Aufgabe: Codebase untersuchen, Plan vorschlagen, Änderungen implementieren, Tests ausführen, Fehler beheben und zusammenfassen, was geändert wurde.

Der Unterschied zur klassischen Entwicklung ist nicht nur Geschwindigkeit. Es ist die Form der Arbeit.

Klassische Entwicklung sah oft so aus:

Anforderung verstehen.
Lösung entwerfen.
Code schreiben.
Code testen.
Code debuggen.
Code deployen.

Agentic Engineering sieht eher so aus:

Ziel klar definieren.
Dem Agenten Kontext und Einschränkungen geben.
Den Plan des Agenten prüfen.
Den Agenten implementieren lassen.
Den Diff inspizieren.
Tests ausführen oder verifizieren.
Den Agenten Risiken erklären lassen.
Entscheiden, ob das Ergebnis sicher ausgeliefert werden kann.

Das ist immer noch Engineering. Es geht nur weniger darum, jedes Zeichen manuell zu produzieren, und mehr um Urteilskraft, Zerlegung, Review, Architektur und Verantwortung.

Du wirst Code nicht mehr wie früher schreiben

Für aktuelle Entwickler kann sich das unangenehm anfühlen. Ein grosser Teil unserer Identität war damit verbunden, Code zu schreiben. Wir haben Syntax, Frameworks, Editoren, Shortcuts und Debugging-Gewohnheiten gelernt. Wir wurden gut darin, vage Ideen in funktionierende Systeme zu verwandeln, indem wir gleichzeitig getippt und gedacht haben.

KI verändert diesen Workflow.

Du wirst weiterhin Code schreiben, aber dein Wert wird weniger davon abhängen, ob du am schnellsten Boilerplate produzieren kannst. Agenten sind bereits gut darin, Komponenten zu scaffolden, Tests zu generieren, API-Aufrufe zu verdrahten, Migrationen vorzubereiten, repetitive Muster zu refactoren und unbekannten Code zu erklären.

Der Wert des Entwicklers verschiebt sich nach oben.

Die wichtigen Fragen werden:

Ist das das richtige Problem?
Ist die Anforderung präzise genug?
Passt die Architektur zur Zukunft des Produkts?
Hat der Agent bestehendes Verhalten erhalten?
Sind die Tests sinnvoll oder nur Fassade?
Gibt es Sicherheits-, Datenschutz- oder Datenintegritätsrisiken?
Wird ein anderer Entwickler das in sechs Monaten verstehen?
Ist diese Lösung einfach genug?

Anders gesagt: KI reduziert die Kosten, Code zu produzieren. Sie reduziert nicht die Notwendigkeit von Engineering-Urteilskraft.

Das Kartenhaus-Problem

KI-generierte Software sieht auf den ersten Blick oft beeindruckend aus. Die App läuft. Die Seite rendert. Die API antwortet. Die Demo funktioniert.

Das ist nicht dasselbe wie ein solides System.

Ein Kartenhaus kann für einen Moment stehen. Es kann sogar elegant aussehen. Aber jede neue Karte erhöht das Risiko, weil das Fundament nie dafür entworfen wurde, Gewicht zu tragen.

In Software passiert das, wenn Menschen KI-Agenten nutzen, ohne genug Verständnis zu haben, um den Output zu prüfen. Die erste Version fühlt sich magisch an. Das zweite Feature funktioniert auch noch. Beim fünften Feature versteht niemand mehr, warum State doppelt vorhanden ist, warum das Datenmodell ungeschickt ist, warum Authentifizierung Edge Cases hat oder warum eine kleine Änderung drei nicht zusammenhängende Screens kaputt macht.

Typische Symptome sind:

Code, der nur den Happy Path abdeckt.
Tests, die Implementierungsdetails prüfen, aber echtes Verhalten verpassen.
Datenbankschemas, die zukünftige Anforderungen nicht tragen können.
Sicherheitsregeln, die als Kommentare existieren, aber nicht im Code erzwungen werden.
Businesslogik, die in Frontend, Backend und Skripten dupliziert ist.
Fehlerbehandlung, die Fehler versteckt, statt sie sichtbar zu machen.
Dependencies, die hinzugefügt wurden, weil der Agent sie kannte, nicht weil das Projekt sie brauchte.
Eine Codebase, die schnell wächst, aber jede Woche schwieriger zu ändern wird.

Das liegt nicht daran, dass KI nutzlos ist. Es liegt daran, dass KI mächtig genug ist, Menschen Komplexität erzeugen zu lassen, bevor sie die Kosten dieser Komplexität verstehen.

Grundlagen werden wichtiger, nicht unwichtiger

Je leistungsfähiger KI-Agenten werden, desto wichtiger werden die Grundlagen.

Das klingt kontraintuitiv. Wenn der Agent den Code schreibt, warum sollte ein Entwickler dann die Basics verstehen?

Weil jemand wissen muss, ob der Output korrekt ist.

Weil jemand merken muss, wenn der Agent das falsche Problem gelöst hat.

Weil jemand entscheiden muss, ob eine Abkürzung für einen Prototyp akzeptabel oder für Produktion gefährlich ist.

Weil jemand verantwortlich ist, wenn echte Nutzer, echtes Geld oder echte Daten involviert sind.

Die wichtigsten Grundlagen im KI-Zeitalter sind nicht nur Syntax. Es sind die Konzepte, mit denen du über Software nachdenken kannst.

Die Grundlagen, die Entwickler weiterhin brauchen

Programmierlogik

Du musst Bedingungen, Schleifen, Funktionen, Komposition, State, Side Effects und Fehler verstehen. Wenn du der Logik nicht folgen kannst, kannst du die Logik des Agenten nicht prüfen.

Datenmodellierung

Die meiste Software ist eine Benutzeroberfläche über Daten. Wenn dein Datenmodell falsch ist, wird alles darüber mühsam. KI kann Modelle schnell generieren, aber du musst beurteilen können, ob Beziehungen, Constraints und Namen sinnvoll sind.

HTTP und APIs

Moderne Produkte bestehen aus Systemen, die miteinander sprechen. Entwickler und Gründer müssen Requests, Responses, Statuscodes, Authentifizierung, Rate Limits, Webhooks und Fehlerfälle verstehen.

Datenbanken

Du musst kein Datenbankadministrator sein, um Produkte zu bauen. Aber du solltest Tabellen, Indizes, Migrationen, Transaktionen, Constraints und den Grund verstehen, warum "füge einfach ein Feld hinzu" manchmal nicht einfach ist.

Testing

KI-Agenten können Tests schreiben. Sie können auch Tests schreiben, die sehr wenig beweisen. Du musst den Unterschied zwischen Verhalten testen und Implementierung testen verstehen. Eine Testsuite sollte Vertrauen schaffen, nicht falsche Sicherheit.

Debugging

Debugging bedeutet nicht nur, Fehler zu beheben. Es bedeutet, Hypothesen zu bilden, Hinweise zu untersuchen, Unsicherheit zu reduzieren und zu lernen, wie sich das System tatsächlich verhält. KI kann helfen, aber Debugging bleibt eine Denkfähigkeit.

Sicherheit und Datenschutz-Grundlagen

KI kann versehentlich Daten offenlegen, Autorisierungsprüfungen überspringen, Nutzereingaben vertrauen oder unsichere Defaults erzeugen. Wenn du für echte Nutzer baust, brauchst du genug Sicherheitsverständnis, um offensichtliche Risiken zu erkennen.

Git und Zusammenarbeit

Agentic Workflows produzieren schneller mehr Änderungen. Das macht Versionskontrolle wichtiger. Du musst Diffs, Commits, Branches, Pull Requests, Rollbacks und saubere Code-Review-Gewohnheiten verstehen.

Architektur und Tradeoffs

Architektur bedeutet nicht, Boxen zu zeichnen. Es bedeutet zu entscheiden, wo Komplexität leben soll. KI kann Muster vorschlagen, aber sie kennt deine Geschäftsprioritäten nicht, wenn du sie nicht erklärst, und sie versteht nicht immer die langfristigen Kosten einer Entscheidung.

Für aktuelle Entwickler: Dein Job verändert sich, er verschwindet nicht

Wenn du bereits Entwickler bist, ist die beste Reaktion weder Verleugnung noch Panik.

Konkurriere nicht mit KI beim Tippen von repetitivem Code. Du wirst verlieren, und das ist in Ordnung. Konkurriere dort, wo menschliche Engineering-Urteilskraft zählt.

Dein Vorteil ist die Fähigkeit, Kontext zu verstehen:

Was der Nutzer wirklich braucht.
Was das Unternehmen langfristig warten kann.
Was das System bereits tut.
Was nicht kaputtgehen darf.
Was vereinfacht werden kann.
Welche Risiken akzeptabel sind.

Die stärksten Entwickler werden Agenten intensiv nutzen, aber ihre Urteilskraft nicht auslagern. Sie werden besser darin, Spezifikationen zu schreiben, Arbeit in sichere Aufgaben zu zerlegen, generierten Code zu reviewen, Teststrategien zu entwerfen und Tradeoffs nicht-technischen Menschen zu erklären.

Die schwache Version von KI-unterstützter Entwicklung lautet: "Generiere mir das."

Die starke Version lautet: "Hier ist der Kontext, hier sind die Einschränkungen, hier sind die Akzeptanzkriterien, hier sind die Tests, die du nicht brechen darfst, hier ist der Stil der Codebase, und hier ist, was du erklären sollst, bevor ich es freigebe."

Das ist Agentic Engineering als professionelle Praxis.

Für Menschen, die Entwicklung lernen: KI senkt die Einstiegshürde, nicht den Standard

Wenn du heute Entwickler werden willst, betrittst du das Feld in einem seltsamen, aber spannenden Moment.

Einerseits gibt dir KI Hebelwirkung, die frühere Generationen nicht hatten. Du kannst Fragen stellen, Beispiele anfordern, Übungen generieren, Erklärungen bekommen, Fehler debuggen und unbekannte Konzepte schneller erkunden als je zuvor.

Andererseits kann KI dich auch dazu verleiten, genau das Lernen zu überspringen, das dich berufsfähig machen würde.

Wenn du generierten Code kopierst, ohne ihn zu verstehen, lernst du nicht Entwicklung. Du lernst Abhängigkeit. Sobald etwas auf eine Weise kaputtgeht, die der Agent nicht sofort beheben kann, steckst du fest.

Das Ziel ist nicht, jedes Syntaxdetail auswendig zu lernen. Das Ziel ist, ein mentales Modell davon aufzubauen, wie Software funktioniert.

Nutze KI als Tutor:

Lass dir Code Zeile für Zeile erklären.
Frage, warum eine Lösung funktioniert.
Frage nach einer einfacheren Version.
Frage nach Edge Cases.
Lass dich abfragen.
Lass dir eine falsche Lösung zeigen und erklären, warum sie falsch ist.
Baue dieselbe Sache selbst nach, ohne zu kopieren.

Wenn du lernst, ist die beste Frage oft nicht: "Kann KI das für mich bauen?" Sondern: "Kann KI mir helfen, das so tief zu verstehen, dass ich es sicher verändern kann?"

Für Gründer: KI-Agenten sind Hebelwirkung, kein Ersatz für technisches Grundverständnis

Für Gründer ist Agentic Engineering wirklich mächtig. Du kannst Ideen schneller validieren. Du kannst Landingpages, interne Dashboards, Prototypen, Automatisierungsskripte und frühe MVPs mit kleinerem Budget bauen. Du kannst mehr Annahmen testen, bevor du ein komplettes Team einstellst.

Das ist gut.

Aber Gründer sollten mit dem Wort "shippen" vorsichtig sein. Einen Prototypen auszuliefern ist nicht dasselbe wie ein zuverlässiges Produkt auszuliefern. An zehn freundliche Tester auszuliefern ist nicht dasselbe wie an zahlende Kunden auszuliefern. Eine Demo auszuliefern ist nicht dasselbe wie Software mit Sicherheit, Uptime, Analytics, Backups und Support zu betreiben.

KI-Agenten können Gründern helfen, schnell voranzukommen. Aber Gründer brauchen trotzdem genug technisches Verständnis, um bessere Fragen zu stellen:

Welche Daten speichern wir?
Wer kann darauf zugreifen?
Was passiert, wenn das fehlschlägt?
Woran merken wir, dass es fehlgeschlagen ist?
Können wir das später ändern, ohne neu anzufangen?
Was muss getestet werden, bevor Nutzer davon abhängen?
Was ist Prototyp-Code und was ist Produktionscode?

Du musst kein Senior Engineer werden, um KI-Agenten gut zu nutzen. Aber wenn du ein Unternehmen auf Software baust, musst du genug verstehen, um dein Unternehmen nicht auf fragilen Annahmen aufzubauen.

Ein praktischer Agentic-Engineering-Workflow

Hier ist ein einfacher Workflow, der für Entwickler, Lernende und Gründer funktioniert.

1. Starte mit einer kurzen Spezifikation

Schreibe auf, was das Feature tun soll, für wen es ist und woran Erfolg gemessen wird. Ergänze auch, was es nicht tun soll. Ein vager Prompt erzeugt vage Software.

2. Frage nach einem Plan, bevor Code geschrieben wird

Lass den Agenten bei wichtigen Aufgaben nicht direkt in die Implementierung springen. Bitte ihn, zuerst die Codebase zu untersuchen und einen Plan vorzuschlagen. Prüfe diesen Plan so, wie du den Ansatz eines Junior-Entwicklers prüfen würdest.

3. Mache die Aufgabe kleiner

Agenten arbeiten besser, wenn die Arbeit klar begrenzt ist. Statt "baue die ganze App" frag nach einem vertikalen Slice: Model, Endpoint, UI, Test und Dokumentation für ein Verhalten.

4. Definiere Akzeptanzkriterien

Sag dem Agenten, wie du die Arbeit beurteilen wirst. Gute Akzeptanzkriterien reduzieren Mehrdeutigkeit und machen Review einfacher.

5. Führe Tests aus und inspiziere den Diff

Vertraue nie nur der Zusammenfassung. Lies die geänderten Dateien. Prüfe, ob die Implementierung zum Plan passt. Führe die relevanten Tests aus. Wenn es keine Tests gibt, frage warum.

6. Frage nach Risiken

Bitte den Agenten nach der Implementierung, Risiken, Edge Cases und Annahmen aufzulisten. Das zeigt oft versteckte Probleme.

7. Behalte menschliche Verantwortung

Der Agent kann Code generieren. Er kann die Konsequenzen nicht tragen. Wenn du ihn mergst, deployst oder verkaufst, liegt die Verantwortung bei dir.

Eine einfache Checkliste vor dem Shipping von KI-generiertem Code

Bevor du etwas auslieferst, das ein KI-Agent mitgebaut hat, frage:

Verstehe ich, was geändert wurde?
Habe ich den Diff inspiziert?
Sind die Tests erfolgreich gelaufen?
Sind die Tests sinnvoll?
Werden Nutzereingaben validiert?
Ist Autorisierung korrekt umgesetzt?
Sind Fehler sichtbar und wiederherstellbar?
Sind sensible Daten geschützt?
Passt die Lösung zur bestehenden Codebase?
Können wir das warten, wenn die ursprüngliche Agenten-Konversation verschwindet?

Wenn die Antwort auf mehrere dieser Fragen "Ich weiss es nicht" lautet, bist du noch nicht bereit zu shippen. Du bist bereit, mehr zu lernen, den Scope zu reduzieren oder erfahrenes Review einzuholen.

Der Entwickler der Zukunft ist nicht nur ein Coder

Das Zeitalter der KI macht Entwickler nicht irrelevant. Es verändert, was das Wort Entwickler bedeutet.

Früher war ein Entwickler jemand, der Anforderungen in Code verwandeln konnte. Zunehmend ist ein Entwickler jemand, der unklare Ziele in zuverlässige Systeme verwandeln kann, mit allen verfügbaren Werkzeugen, einschliesslich KI-Agenten.

Dafür braucht es technische Fähigkeiten. Es braucht auch Produktdenken, Kommunikation, Urteilskraft, Geschmack, Skepsis und Verantwortung.

Menschen, die nur Code tippen können, werden es schwerer haben. Menschen, die Software verstehen, werden wertvoller, weil sie KI nutzen können, ohne sich von ihr täuschen zu lassen.

Agentic Engineering ist nicht das Ende davon, Programmieren zu lernen. Es ist das Ende der Vorstellung, dass Code allein der Job ist.

Wenn dich Themen wie KI-unterstützte Entwicklung, Product Engineering, agentische Workflows und die Zukunft von Softwareteams interessieren, abonniere den Pyango Newsletter. Dort teilen wir neue Essays, Experimente und praktische Learnings.

Und wenn du Entwickler in diesem neuen KI-nativen Zeitalter werden möchtest, schau dir TomorrowDev an: https://tomorrowdev.ch

Entwickler sein im Zeitalter von KI: Agentic Engineering, Grundlagen und das Ende von "nur Code schreiben"

Ressourcen

Neueste Blogbeiträge