Von Norman Schütt
Gründer von Devergency | 15 Jahre Software Engineering
📞 Kontakt & Zusammenarbeit
Lass uns gerne kurz kennenlernen, oder schaue auf meinen Kanälen vorbei.
Kontaktmöglichkeiten:
- Meeting:
Cal.comKennenlernen | Norman Schütt | Cal.com

Kennenlernen | Norman Schütt | Cal.com
Kennenlernen
- LinkedIn:
www.linkedin.com
www.linkedin.com
- E-Mail: [email protected]
- Website:
devergency.deKI getriebenes Software Engineering mit Substanz
KI getriebenes Software Engineering mit Substanz
Migrationsprojekte sind jetzt endlich wieder wirtschaftlich. Ich zeige dir, wie du mit KI-gestütztem Refactoring Zeit und Kosten sparst.
- YouTube:
YouTubeDevergencyDevergency
Unf*ck IT | Empowering Development teams to deliver business value faster.
Version 1.1 | Dezember 2025
Basiert auf realen Projekterfahrungen. Ist als Diskussionsgrundlage gedacht, nicht als definitive Anleitung. Feedback, Kritik und Ergänzungen sind explizit erwünscht.
Wer ich bin. Norman Schütt, Gründer von Devergency. Software-Consulting-Firma spezialisiert auf Legacy System Modernization. Mit 15+ Jahren Erfahrung im Software Engineering helfe ich Unternehmen, veraltete Systeme in moderne, wartbare Architekturen zu transformieren. Ich entwickle mittlerweile den Großteil meiner Consulting-Projekte mit AI-Unterstützung und arbeite daran, die dabei entstehenden unbewussten Patterns zu explizieren und teilbar zu machen.
Kontakt: LinkedIn | Devergency.de
Wie das hier entstanden ist. Kein klassisches Fachbuch. Der Versuch, unbewusste Kompetenz bewusst zu machen. Die Patterns und Prinzipien hier entstammen realer Projekterfahrung – erfolgreichen Projekten, die produktionsreif liefen, und gescheiterten Projekten, die wertvolle Lektionen lieferten. Für Developer geschrieben. Von einem Developer. Der noch immer lernt.
Einleitung: Das Problem sitzt vorm Computer
Ich scrolle durch LinkedIn und sehe denselben Post zum dritten Mal diese Woche: “KI-Coding funktioniert nicht.” Darunter die üblichen Kommentare: “Das ist alles Müll”, “Ich brauche ewig zum Fixen”, “Ich habe zwei Stunden Code produziert und eine Woche gebraucht, um den Müll wieder rauszuräumen.”
Gleichzeitig sitze ich hier und entwickle den Großteil meiner Consulting-Projekte mit KI-Unterstützung. Produktionsreife Systeme. Legacy-Modernisierung für industrielle Anlagen. Komplexe Business-Logic. Und es funktioniert. Reibungslos. Sauber. Produktionsreif. Was ist der Unterschied?
Wenn ich auf LinkedIn antworte, schreibe ich meistens: “Git Gud.” Und ich meine das nicht toxisch. Ich meine das ehrlich. Genau wie bei Dark Souls.
“Git Gud” ist der beste und frustrierendste Rat, den man geben kann. Bei Dark Souls gibt’s keinen Cheat Code. Keine 10-Schritte-Anleitung, um Ornstein & Smough zu beaten. Keine Formel für Erfolg. Der einzige ehrliche Rat: Stirb. Lerne. Iteriere. Werd besser. Aber wie? Das kann dir niemand genau sagen. Jeder Spieler findet seinen eigenen Weg. Aber es gibt Patterns. Meta-Prinzipien wie “roll INTO the attack, not away” – das ist kein Cheat Code, aber es fokussiert dein Trial-and-Error. Es beschleunigt dein Lernen. Es gibt dir Leitplanken.
Mit AI-Coding ist es identisch. Ich könnte dir sagen: “Gib bessere Prompts.” Oder “Definiere mehr Kontext.” Aber das ist wie “Drück schneller auf die Tasten” bei Dark Souls. Es hilft nicht wirklich. Weil das eigentliche Problem tiefer liegt. Es ist dein Ansatz. Dein Prozess. Deine fehlenden Patterns.
Hier ist die unbequeme Wahrheit: Das Problem sitzt immer vorm Computer. Wenn KI-Coding bei dir nicht funktioniert, liegt das nicht an der KI. Nicht an Claude. Nicht an den Prompts. Nicht am Tool. Es liegt an dir. An mir. An uns allen, die lernen müssen, wie man mit diesem neuen Paradigma arbeitet.
Das ist keine Kritik an deiner Kompetenz als Entwickler. Ich bin seit 15+ Jahren im Game. Ich habe in Private Equity gearbeitet. Ich modernisiere Legacy-Systeme für Industrieunternehmen. Ich weiß, was guter Code ist. Und trotzdem: Letzte Woche. Privates Projekt, Finance-App. Zwei Stunden Code generiert. Komplett unbrauchbar. Ich musste alles wegwerfen. Was war der Unterschied zwischen dem Manufacturing-Projekt, das produktionsreif lief, und meiner Finance-App, die totaler Müll war? Der Prozess. Oder besser: Das Fehlen davon.
Was ich gelernt habe – und warum es so schwer war, das zu greifen. Ich habe mittlerweile eine Intuition entwickelt. Ein Bauchgefühl. Ich merke sofort, wenn ein Prompt zu vage ist. Wenn der Context fehlt. Wenn die KI gleich Müll produzieren wird. Manchmal stoppe ich nach dem ersten Code-Block und sage: “Nope, das wird nichts.” Und ich habe recht. Das ist unbewusste Kompetenz. Das Problem mit unbewusster Kompetenz: Sie ist nicht teilbar. Ich kann nicht sagen “Mach’s einfach wie ich” – weil ich nicht mal weiß, was ich anders mache. Es hat Monate gedauert, das zu identifizieren. Zu verstehen, welche Patterns ich eigentlich befolge. Welche Leitplanken ich mir selbst gesetzt habe. Und selbst jetzt: Es gibt keine allgemeingültigen Regeln. Keine Checkliste, die für jeden funktioniert.
Ich versuche hier, das Unbewusste bewusst zu machen. Aber lass mich gleich klarstellen, was das nicht ist:
Kein neues Framework. Kein “Spec Driven Development 2.0”. Kein Buzzword, das du auf LinkedIn posten kannst. Keine Methode, die du dogmatisch umsetzen musst. In der AI-Coding Welt gibt es mittlerweile genug davon. Neue Begriffe. Neue Prozesse. Die dann als “die Lösung” verkauft werden. Und am Ende merken alle: Es funktioniert nicht universell. Weil jedes Projekt anders ist. Jeder Entwickler anders arbeitet. Jeder Kontext andere Schwerpunkte braucht.
Was das hier stattdessen ist: Ein Set von Meta-Prinzipien. Patterns, die ich identifiziert habe – durch Erfolge und durch Fehler. Durch produktionsreife Projekte und durch weggeworfenen Müll. Diese Patterns sind keine Regeln. Sie sind Leitplanken. Orientierungspunkte für deinen eigenen Trial-and-Error. Du wirst nicht alle befolgen. Du wirst manche wichtiger finden als andere. Du wirst deine eigenen hinzufügen. Und das ist gut so. Genau wie bei Dark Souls: “Roll INTO the attack” ist ein Pattern. Aber manche Spieler blocken stattdessen. Manche gehen voll auf Offense. Jeder findet seinen Weg. Die Patterns helfen nur dabei, schneller zu lernen.
Es gibt keinen Silver Bullet. Das muss ich gleich am Anfang sagen. Du wirst keine 10-Punkte-Checkliste finden, die dich zum AI-Coding-Experten macht. Keinen Prompt, der immer funktioniert. Keine Formel für Erfolg. Du musst trotzdem die Arbeit machen. Du musst Fehler machen. Du musst sehen, was passiert, wenn du vom Prozess abweichst. Du musst deine eigene Intuition entwickeln. Das dauert. Das ist unbequem. Das ist nicht, was Leute hören wollen. Leute wollen den Shortcut. Den Hack. Die magische Lösung. Es gibt sie nicht.
Aber es gibt Patterns, die helfen. Meta-Prinzipien, die deinen Trial-and-Error fokussieren. Die dich schneller lernen lassen. Nicht weil sie Regeln sind. Sondern weil sie Leitplanken sind. Weil sie dir zeigen, worauf du achten solltest. Wo die typischen Fallen sind. Welche Fragen du dir stellen solltest.
Was ich von dir erwarte. Dass du mitdenkst. Dass du reflektierst. Dass du nicht einfach Copy-Paste machst, sondern adaptierst. Diese 13 Patterns, die ich zeige? Das ist kein Prozess, den du strikt befolgen musst. Das sind Orientierungspunkte. Manche werden für dich kritisch sein. Andere wirst du überspringen. Nach fünf Projekten wirst du deine eigenen Schwerpunkte gefunden haben. Deine eigenen blinden Flecken. Deine eigene Intuition.
Was du erwarten kannst: Transparenz. Ich zeige dir, wo ich herkomme. Welche Fehler ich gemacht habe. Welche Patterns bei mir funktionieren – und wo ich selbst noch kämpfe. Ich zeige dir die Spannung zwischen “Es gibt keine universelle Lösung” und “Aber es gibt Patterns, die helfen”. Ich gebe dir Leitplanken. Keine Regeln.
Der Weg vorwärts. Im nächsten Kapitel erkläre ich die Dark Souls Metapher tiefer. Warum “Git Gud” ehrlich ist. Warum Trial-and-Error unvermeidbar ist. Warum das okay ist. Dann zeige ich dir zwei Projekte: Eins, das funktioniert hat. Eins, das gescheitert ist. Der Unterschied? Nicht Komplexität. Nicht Fähigkeiten. Der Prozess. Dann kommen die 13 Patterns. Die Leitplanken. Die Meta-Prinzipien. Du wirst nicht alle gleichzeitig anwenden. Du wirst zwischen ihnen springen. Iterativ. Explorativ. Genau wie bei Dark Souls.
You died. Git gud. Try again.
Aber bevor wir in die Patterns eintauchen, müssen wir über ein unangenehmes Thema reden: Produktivität. Und warum die Diskussion darüber so frustrierend ist.
Produktivität ist komplex (aber trotzdem real)
Du wirst hier Aussagen lesen wie “10x produktiver” oder “in Wochen statt Monaten”. Und vielleicht denkst du: “Das klingt nach Marketing-Bullshit.” Fair. Lass mich erklären, warum es trotzdem stimmt – und warum beide Seiten der LinkedIn-Debatte das Problem falsch framen.
Warum Software-Produktivität schwer zu messen ist. Die Software-Industrie hat Story Points erfunden, weil exakte Zeitmessung beim Coden nicht funktioniert. Zu viele Variablen: Problemverständnis, Domain Knowledge, Code-Qualität, Mentaler Zustand, Unterbrechungen. Niemand kann zuverlässig sagen “Feature X dauert 7 Stunden und 24 Minuten.” Es kann 3 Stunden werden. Oder 3 Tage. Deshalb nutzen wir relative Komplexität statt Zeit.
AI macht das noch komplexer. Mit AI ändern sich die Prozesse fundamental. Du schreibst anders (mehr Code, mehr Exploration, häufigeres Refactoring). Du planst anders (mehr Architecture, mehr Validation). Du kannst kein Standard-Team nehmen, AI einführen, und dann Velocity vergleichen. Die Arbeitsweise verschiebt sich.
Wo 10x real ist (und wo nicht). Der Gewinn ist real, aber nicht überall gleich:
- 10x bei: Boilerplate (CRUD, Repos, DTOs), Refactoring (Pattern-Anwendungen), Prototyping, Greenfield mit klaren Patterns
- NICHT 10x bei: Komplexer Business Logic (musst du verstehen), Debugging Legacy Code, Requirement Gathering, Architecture Decisions, Projekten ohne Prozess (Finance App: negativer ROI)
Die ehrliche Aussage: Mit den Patterns, die ich dir zeige – massiver Produktivitätsgewinn. Bei bestimmten Tasks wirklich 10x. Bei anderen 2-3x. Im Durchschnitt: deutlich schneller. Ohne die Patterns – negativer ROI. Du produzierst Müll. Du brauchst länger zum Aufräumen als zum manuellen Bauen. Der Unterschied ist nicht die KI. Der Unterschied ist der Prozess.
Was das für dich bedeutet. Erwarte nicht, dass du “10x schneller” bist nach dem Lesen. Erwarte, dass du anders arbeitest. Nach 5 Projekten mit diesen Patterns merkst du den Unterschied. Nicht in Prozenten. Sondern in der Art, wie du Probleme angehst. Eine fundamental andere Art zu arbeiten.
Und genau das ist, was “Git gud” wirklich bedeutet.
You Died
Für die Gamer unter euch: Was ist der beste Tipp, den man Dark Souls Spielern geben kann? “Git gud!” Das klingt nach einem billigen Meme. Nach Gaming-Community-Toxizität. Nach dem, was man postet, wenn man jemanden ärgern will. Aber es ist ehrlich. Und es trifft den Kern auf eine Weise, die kein ausführliches Tutorial jemals könnte.
Bei Dark Souls gibt’s keinen Cheat Code. Keine Strategie, die immer funktioniert. Keine YouTube-Tutorial-Playlist, die dich durch das Spiel trägt. Du kannst hundert Videos schauen, wie andere Leute Ornstein & Smough beaten. Du wirst trotzdem sterben. Weil es nicht darum geht, die richtige Strategie zu kopieren. Es geht darum, deine Strategie zu finden. Die, die zu deinem Playstyle passt. Zu deinen Reflexen. Zu deiner Art zu denken.
Manche Spieler rollen wie verrückt. Dodge, dodge, dodge, ein Hit, raus. Andere blocken. Schild hoch, Geduld, auf die Öffnung warten. Manche gehen voll auf Offense, zwei-Hand das Greatsword, trade Hits, heal später. Andere spielen defensiv, Range, Magie, niemals zu nah. Es gibt keine richtige Strategie – nur die, die für dich funktioniert. Niemand kann dir sagen: “Mach exakt das, dann gewinnst du.” Weil dein Timing anders ist. Dein Muskelgedächtnis anders. Deine Risikobereitschaft anders.
Aber – und das ist das Wichtige – es gibt Patterns, die helfen. Meta-Prinzipien, die dein Lernen beschleunigen. “Roll INTO the attack, not away” – das ist kein Cheat Code. Das garantiert dir nicht den Sieg. Aber es ist ein Pattern. Etwas, das deinen Trial-and-Error fokussiert. Wenn du hundertmal stirbst, aber immer wegrollst und trotzdem getroffen wirst, dann probier mal: Reinrollen. Du wirst immer noch sterben. Aber schneller lernen, warum. “Don’t get greedy with hits” – wieder kein Cheat. Aber ein Prinzip, das dein Überleben wahrscheinlicher macht. Du könntest drei Hits schaffen. Aber zwei sind sicherer. Jedes Mal wenn du gierig wirst und den dritten Hit versuchst, stirbst du. Das Pattern hilft dir, diese Tendenz zu erkennen.
Das ist, was Dark Souls lehrt: Jeder Fehler ist Feedback, kein Versagen. Du stirbst nicht, weil du schlecht bist. Du stirbst, weil du noch nicht gelernt hast, was funktioniert. Das Spiel belohnt Persistenz über Perfektion. Du wirst nie perfekt sein. Aber du wirst besser. Du wirst Patterns erkennen. Im Spiel. In dir selbst. In deinem Approach. Nach fünfzig Toden gegen einen Boss weißt du: “Ah, diese Attacke telegrafiert er mit diesem Windup.” Nach hundert Toden weißt du: “Ich gehe immer zu früh rein.” Nach hundertfünfzig: “Mein Timing ist jetzt gut, aber ich heile zu spät.” Du lernst nicht durch Tutorials. Du lernst durch Iteration.
Mit AI-Coding ist es identisch. Ich kann dir nicht sagen: “Schreib deinen Prompt genau so, dann funktioniert’s.” Weil dein Projekt anders ist. Dein Kontext anders. Deine Arbeitsweise anders. Was bei meinem Manufacturing-Projekt funktioniert hat, funktioniert vielleicht bei deinem nicht – weil du andere Constraints hast, andere Requirements, andere Patterns bevorzugst. Aber ich kann dir Meta-Prinzipien zeigen. Patterns, die deinen Trial-and-Error fokussieren. Die dir helfen, schneller zu lernen. Die dir zeigen, worauf du achten sollst.
“Scout Before You Prompt” – das ist wie “Roll INTO the attack”. Kein Cheat Code. Aber ein Pattern, das hilft. “Code Reflection Test” ist wie “Don’t get greedy”. Ein Prinzip, das dein Überleben (bzw. deine Code-Qualität) wahrscheinlicher macht. Du wirst trotzdem Fehler machen. Du wirst trotzdem Müll produzieren. Du wirst trotzdem Projekte wegwerfen müssen. Das ist der Lernprozess. Genau wie bei Dark Souls musst du einmal gesehen haben, was passiert, wenn du’s falsch machst. Wenn du keinen Scout machst. Wenn du den Code Reflection Test überspringst. Wenn du aus Sunk Cost weitermachst, obwohl alles falsch ist. Du musst das Chaos erleben. Dann verstehst du, warum die Patterns wichtig sind.
Ich könnte dir jetzt eine 50-seitige Anleitung geben: “So machst du AI-Coding richtig.” Du würdest sie lesen. Nicken. Denken “Macht Sinn.” Und dann im ersten echten Projekt alles vergessen. Weil du die Patterns nicht erlebt hast. Weil du nicht gesehen hast, was passiert, wenn du sie missachtest. Genau wie bei Dark Souls: Du kannst hundert Guides lesen. Aber du musst selbst sterben. Selbst lernen. Selbst iterieren. Die Patterns geben dir nur die Leitplanken. Sie zeigen dir, wo du hinschauen sollst. Was wichtig sein könnte. Wo die typischen Fallen sind.
Git gud ist nicht frustrierend gemeint. Es ist ehrlich gemeint. Es heißt: Ich kann dir nicht den Weg geben. Aber ich kann dir zeigen, worauf du achten solltest. Dann musst du die Arbeit machen. Sterben. Lernen. Iterieren. Besser werden. Nach fünf Projekten wirst du deine eigenen Patterns haben. Nach zehn wirst du sie unbewusst anwenden. Nach zwanzig wirst du anderen Entwicklern sagen: “Git gud” – und es ehrlich meinen. Weil du weißt: Es gibt keinen Shortcut. Aber es gibt Patterns, die helfen.
Das ist kein Trost für Leute, die eine einfache Lösung wollen. Aber es ist die Wahrheit. Und die Wahrheit ist: Du kannst das lernen. Es ist lernbar. Es dauert. Es ist unbequem. Aber es funktioniert. Genau wie bei Dark Souls. Du wirst sterben. Viel. Aber irgendwann: You won. Nicht weil du den Cheat Code gefunden hast. Sondern weil du gud geworden bist.
Lass mich dir zeigen, was ich damit meine. Konkret. Mit zwei echten Projekten.
Die zwei Welten
Ich habe zwei Projekte mit KI gebaut. Beide in den letzten Monaten. Beide als Fullstack-Anwendungen. Beide mit ähnlicher Komplexität.
Projekt 1: Manufacturing – Ein produktionsreifes System für eine industrielle Anlage. Komplexe Prozesse. Produktionsspezifikationen. Qualitätssicherung. Bestehendes Projekt, das jemand anders mit Web-based Tools erstellt hatte. Meine Aufgabe: Produktionsreif machen. Refactoring. Stabilisierung. Deployment-Ready. Ergebnis: Nach drei Wochen produktionsreif. Sauberer Code. Funktionierende Tests. System läuft stabil in Produktion.
Projekt 2: Finance App – Ein privates Projekt. Finance-Tracking. Simpel. Kategorien. Transaktionen. Budgets. Monatliche Reports. Ich wollte meine Excel-Tabelle loswerden. Das war alles. Ergebnis: Nach zwei Stunden Code generiert. Komplett unbrauchbar. Alles weggeworfen.
Der Unterschied. Nicht die Komplexität. Das Manufacturing-Projekt war objektiv komplexer. Nicht meine Fähigkeiten. Ich bin in beiden Fällen derselbe Entwickler mit denselben 15 Jahren Erfahrung. Nicht die KI. Dasselbe Tool. Dasselbe Modell. Der Unterschied war der Prozess.
Bei Manufacturing: Ich habe meinen Engineering-Prozess durchgezogen. Strukturiert. Diszipliniert. Bei der Finance-App: Ich habe gedacht “Ach, das ist doch nur ein kleines Projekt. Das muss nicht so formal sein. Ich kann Abkürzungen nehmen.” Spoiler: Konnte ich nicht.
“Je weniger Zeit ich mir für Details und Prozesse nehme, desto weniger ich mich selbst dazu zwinge, mich an diese zu halten – desto mehr Scheiße kommt am Ende dabei raus. Und der Zusammenhang ist nicht linear, der ist exponentiell.”
Das ist die gefährlichste Falle beim AI-Coding: Du denkst, bei kleinen Projekten kannst du Ecken schneiden. Ein bisschen weniger Prozess. Ein bisschen weniger Disziplin. Ein bisschen weniger Planning. Sollte doch funktionieren, oder? Funktioniert nicht. Der Zusammenhang zwischen Prozess-Disziplin und Code-Qualität ist nicht linear. Er ist exponentiell. Ein bisschen weniger Prozess = deutlich mehr Chaos. Viel weniger Prozess = komplettes Disaster.
In den nächsten Kapiteln zeige ich dir die Patterns, die den Unterschied gemacht haben. Die Prinzipien, die bei Manufacturing funktioniert haben – und die bei der Finance-App gefehlt haben.
Patterns, keine Regeln
Okay. Du hast gesehen, dass es funktionieren kann. Du hast gesehen, dass der Prozess den Unterschied macht. Jetzt zeige ich dir die Patterns. Aber zuerst: Diese 13 Patterns sind keine Checkliste. Kein Wasserfall. Keine Reihenfolge, die du strikt befolgen musst. Keine “Wenn du Pattern 5 nicht machst, funktioniert Pattern 7 nicht”-Abhängigkeiten. Du wirst zwischen ihnen springen. Hin und her. Iterativ.
“Code Reflection Test” wendest du nach jedem generierten Block an. “User Story Level” nur beim Task-Schneiden. “Starting Stats Test” einmal am Anfang – oder mitten im Projekt, wenn du merkst, dass das Datenmodell nicht passt. Manchmal brauchst du Pattern 3 und 11 gleichzeitig. Manchmal reicht Pattern 1 völlig. Manchmal merkst du erst durch Pattern 12, dass du zurück zu Pattern 8 musst. Das ist normal.
AI-Coding ist kein linearer Prozess. Es ist iterativ. Explorativ. Trial-and-Error. Die Patterns sind wie die Meta-Prinzipien bei Dark Souls: “Roll INTO the attack” lernst du einmal bewusst. Dann wird es Muskelgedächtnis. Du denkst nicht mehr drüber nach. Du tust es einfach. “Don’t get greedy with hits” ist kein Schritt in einer Checkliste. Es ist eine Haltung. Eine Achtsamkeit. Die du in jedem Kampf anwendest – oder eben nicht, und dann stirbst du. Genau so funktionieren diese Patterns.
Die Reihenfolge. Ich habe die Patterns in einer sinnvollen Reihenfolge für den ersten Durchgang angeordnet: Erst die, die dir helfen zu verstehen, was du baust (Scout, Requirements vs. Engineering). Dann die, die dir helfen zu planen (User Story Level, Sequencing). Dann die, die dir helfen zu validieren (Code Reflection Test, Stop Loss). Aber das ist nur ein Vorschlag. Eine Orientierung für den Anfang. Nach ein paar Projekten wirst du deine eigene Reihenfolge finden. Deine eigenen Schwerpunkte. Deine eigenen blinden Flecken, die bestimmte Patterns wichtiger machen. Das ist der Punkt. Unbewusste Kompetenz entwickelst du nicht durch das Abarbeiten einer Checkliste. Du entwickelst sie durch bewusstes Praktizieren von Patterns, bis sie unbewusst werden.
Wie du diese Patterns nutzt. Erstes Projekt: Geh bewusst durch die Patterns. Checke nach jedem wichtigen Schritt: Welches Pattern ist hier relevant? Befolge ich es? Zweites bis fünftes Projekt: Du merkst, welche Patterns dir schwerfallen. Welche du vergisst. Fokussiere dich auf diese. Ab Projekt sechs: Die Patterns werden unbewusst. Du merkst sofort, wenn ein Prompt zu vage ist (Pattern 9). Du stoppst automatisch, wenn der erste Code-Block nicht passt (Pattern 12). Das ist das Ziel: Unbewusste Kompetenz. Aber der Weg dahin führt über bewusste Kompetenz. Über das explizite Anwenden dieser Patterns, bis sie Teil deines Workflows werden.
Fangen wir an mit Pattern 1.
Pattern 1: Scout Before You Prompt
Die Kernaussage: Schau dir den Code selbst an. Bilde dir eine Meinung. Bevor du die KI fragst.
Du öffnest ein Projekt und siehst, dass etwas nicht stimmt. Aber du weißt nicht genau was. Also fragst du die KI: “Was sind die Probleme in diesem Code?” Die KI analysiert, findet Dinge, macht Vorschläge. Aber du weißt nicht, ob das die richtigen Probleme sind. Du hast kein eigenes Verständnis, keinen Kompass. Du bist blind am Steuer. Die KI navigiert. Du hoffst, dass ihr in die richtige Richtung fahrt. Das funktioniert nicht.
Die KI ist nicht dein Scout. Sie ist dein Sparringspartner. Ein Sparringspartner braucht einen Gegner, der weiß, was er trainieren will. Der eine Strategie hat. Der sagen kann: “Ich habe Probleme mit meiner linken Deckung. Lass uns das üben.”
Wenn du der KI sagst “Analysiere mal irgendwas”, bekommst du irgendwas zurück. Wenn du aber sagst “Ich sehe hier drei strukturelle Probleme: Business Logic im Frontend, keine Abstraktion im Data Access, zu große Files”, dann hast du einen fokussierten Dialog. Du musst wissen, wo’s brennt. Dann kannst du die KI gezielt einsetzen.
Beim Manufacturing-Projekt bin ich strukturiert vorgegangen. Zuerst habe ich das GitHub Repo gezogen und lokal geöffnet. Dann habe ich den Code selbst durchgeschaut – Files geöffnet, Struktur analysiert. Keine KI. Nur ich und der Code. Dabei habe ich mir eine eigene Meinung gebildet. Ich sah Business Logic vermischt mit Frontend Code, keine Abstraktion im Data Access Layer, zu viel Code in einzelnen Files, fehlende Separation of Concerns.
Erst dann habe ich die KI eingesetzt: “Analysiere mir detailliert dieses Projekt. Achte auf Clean Code, achte auf Patterns, achte auf Abstraktion.” Die KI analysierte, und ich sah: Sie hat verstanden, worauf ich schaue. Wir waren aligned. Jetzt konnte der Dialog beginnen.
Bei der Finance-App lief es anders. Kein Scout. Direkt geprompted: “Bau mir eine Finance-App.” Ich hatte keine Ahnung, wie ich das strukturieren würde. Die KI sollte das entscheiden. Das war naiv.
Du verletzt dieses Pattern, wenn du die KI fragst “Was soll ich bauen?” statt “Wie baue ich X am besten?” Wenn du nicht erklären kannst, welche Probleme du im Code siehst. Wenn du die KI bittest, “erstmal zu analysieren”, ohne eigene Hypothesen. Wenn du dich auf die KI verlässt, um zu verstehen, was eigentlich gebaut werden soll.
Bevor du die KI einschaltest, mach Folgendes: Bei bestehendem Code öffne 5-10 Files, schau dir die Struktur an, identifiziere offensichtliche Probleme. Bei einem neuen Projekt recherchiere ähnliche Projekte, studiere wie andere das gelöst haben, überlege welche Patterns üblich sind. Schreib deine Gedanken auf – kurze Notizen, Stichpunkte: “Sehe Problem X. Vermute Y. Will Z erreichen.”
Erst dann sprichst du mit der KI. Mit Kontext. Mit Richtung.
Das ist der Unterschied zwischen “Hey KI, bau mir was” (du bist passiv, die KI führt, du hoffst) und “Ich sehe diese 3 Probleme, hier ist mein Ansatz, was sagst du?” (du führst, die KI supportet, ihr baut gemeinsam).
Scout first. Immer.
Pattern 2: Requirements ≠ Engineering Context
Die Kernaussage: Anforderungen zu erklären reicht nicht. Du musst auf die Engineering-Ebene wechseln und definieren, wie das System strukturiert sein wird.
Du hast eine Finance-App im Kopf und erklärst der KI genau, was du willst: “Ich will Transaktionen tracken mit Kategorien und monatlichen Reports.” Das klingt klar. Ist es nicht. Die KI interpretiert. Kategorien als Enum? Als separate Tabelle? Mit Hierarchien? Mit Tags? Alles valid – aber nicht alles passt zusammen.
Die KI baut Feature A mit Interpretation 1, Feature B mit Interpretation 2, Feature C mit Interpretation 3. Am Ende passt nichts zusammen. Kein kohärentes Gesamtbild.
“Anforderungen reichen nicht, ein gutes Ergebnis mit KI zu produzieren. Du kannst noch so viel Kontext bereitstellen auf einer Anforderungsebene. Aber solange Du nicht in die Engineering-Ebene wechselst, ist die Wahrscheinlichkeit hoch, dass am Ende aus den Anforderungen kein kohärentes Gesamtbild entsteht.”
Menschliche Sprache hat Interpretationsspielraum. Immer. “Transaktionen mit Kategorien” kann auf hundert Arten implementiert werden. Wenn du das nicht festlegst, interpretiert die KI jedes Feature isoliert. Das ist genau, warum wir überhaupt Code schreiben statt zu reden. Code ist deterministisch. Code hat keine Interpretationsspielräume. Wenn ich
Transaction.CategoryId schreibe, ist klar, was gemeint ist. Wenn ich der KI nur in natürlicher Sprache sage, was ich will, produziere ich inkonsistenten Code.KI-Coding ist Software Engineering. Nicht Requirement Engineering.
Schau dir den Unterschied an. Requirements-Ebene: “Ich will Transaktionen tracken mit Kategorien und monatlichen Reports.” Was fehlt? Alles. Engineering-Ebene: “Wir bauen ein Transaction Repository Pattern mit CategoryEnum. Normalisierte DB-Struktur mit drei Tables: Transactions, Categories, MonthlySnapshots. Service Layer für Aggregation-Logic. Frontend konsumiert nur DTOs.”
Siehst du den Unterschied? Das Erste lässt tausend Interpretationsmöglichkeiten offen. Das Zweite definiert die Architektur. Es legt fest, wie das System strukturiert sein wird.
Bei jedem Projekt – und ich meine wirklich jedem, auch dem kleinsten Prototype – musst du definieren: Datenmodell (Was sind die Core Entities? Wie hängen sie zusammen? Welche Relationen?), Layer (Wie trennst du Concerns? Mindestens: Data Access, Business Logic, Presentation), Patterns (Repository? Service Layer? DTOs? State Management? Was nutzt du konsistent?), und Tech Stack (Framework, Libraries, Conventions – nicht “die KI entscheidet”, du entscheidest).
Das dauert 15-30 Minuten. Wirklich. Aber es verhindert exponentielles Chaos.
Du bist auf Requirements-Ebene statt Engineering-Ebene, wenn du sagst “was” du willst, aber nicht “wie” es strukturiert sein soll. Wenn du keine Antwort hast auf “Welches Pattern nutzen wir hier?” Wenn du der KI überlässt, wie Entities zusammenhängen. Wenn du hoffst, dass die KI “schon das Richtige” macht.
Beim Manufacturing-Projekt habe ich nicht gesagt: “Die Business Logic muss raus aus dem Frontend.” Ich habe gesagt: “Wir extrahieren in einen Service Layer, weil Business Logic nicht im Frontend sein sollte. Das macht Testing schwer, macht Wartung komplex, verletzt Single Responsibility. Wir nutzen Service Pattern mit Dependency Injection. Data Access wird in Repository abstrahiert mit klarem Interface.” Engineering-Sprache. Patterns. Begründungen.
Bei der Finance-App habe ich nur Requirements gegeben. “Mach’s besser als Excel.” Die KI hat interpretiert. Falsch. Inkonsistent. Nach zwei Stunden: Haufen Code, der nicht zusammenpasst.
Der Minimal Viable Process für jedes Projekt: 15 Minuten Planning. Datenmodell skizzieren (Entities, Relationen, Properties). Layer festlegen (Data / Business / Presentation – wie trennst du das?). 2-3 Core Patterns wählen (Repository? Service Layer? State Management?). Tech Decisions treffen (Framework, Styling, State – festgelegt, nicht improvisiert). Erst dann: “Bau mir das Repository für Transactions.”
Requirements reichen nicht. Engineering-Ebene. Immer.
Pattern 3: Sokrates, nicht Befehl
Die Kernaussage: Führe einen Dialog. Lenke das Gespräch. Du weißt, wo du hin willst, aber holst die KI ab.
Du gibst der KI eine Anweisung: “Refactor diesen Code nach Clean Code Prinzipien.” Die KI refactored. Du bekommst Code zurück. Aber du weißt nicht, warum die KI diese Entscheidungen getroffen hat. Du verstehst den Code nicht besser als vorher. Du hast nichts gelernt. Schlimmer: Wenn die KI falsch liegt, merkst du es zu spät.
KI-Coding ist kein Vending Machine. Du wirfst keine Münze rein und kriegst Code raus. Es ist ein Dialog. Ein Sparring. Ein Pingpong. Du stellst Fragen. Die KI antwortet. Du bohrst tiefer. Die KI erklärt. Du challengest. Die KI justiert. Das ist sokratischer Dialog.
Nicht: “Mach X.” Sondern: “Was siehst du als Problem hier? Warum? Wie würdest du das lösen? Was sind die Trade-offs? Gibt es Alternativen?” Durch diesen Dialog verstehst du die Entscheidungen, kannst frühzeitig korrigieren, lernst Patterns für das nächste Mal, und baust shared context auf.
Schau dir den Unterschied an. Befehlston: “Refactor diesen Code nach Repository Pattern.” Die KI produziert Code. Du hoffst, dass es passt. Sokratischer Dialog: “Analysiere mir detailliert dieses Projekt. Achte auf Clean Code, Patterns, Abstraktion. Zeig mir, wo die strukturellen Probleme liegen.” Die KI antwortet: “Ich sehe drei Hauptprobleme: Business Logic im Frontend, keine Abstraktion im Data Access, zu große Files.” Du bohrst tiefer: “Lass uns über Problem 1 reden. Warum ist Business Logic im Frontend ein Problem?” Die KI erklärt. Du fragst weiter: “Wie würdest du das lösen?” “Was sind die Trade-offs?” “Gibt es Alternativen?”
Siehst du den Unterschied? Du führst. Die KI folgt. Aber du holst sie ab. Verstehst ihre Perspektive. Triffst informierte Entscheidungen.
Du bist im Befehlston statt im Dialog, wenn du mehr Anweisungen als Fragen stellst. Wenn du die Antworten der KI nicht hinterfragst. Wenn du nicht erklären kannst, warum die KI Entscheidung X getroffen hat. Wenn du Code bekommst, ohne den Thought-Process dahinter zu verstehen.
Beim Manufacturing-Projekt habe ich nicht gesagt: “Extrahiere die Business Logic.” Ich habe gefragt: “Was siehst du als strukturelle Probleme in diesem Code?” Die KI antwortet. Ich bohre tiefer: “Warum ist das ein Problem? Wie würdest du das anders machen?” Wir spielen Pingpong. Diskutieren. Ich challenge. Die KI erklärt. Ich lerne. Am Ende verstehe ich, warum wir Pattern X nutzen – nicht nur, dass wir es nutzen.
Bei der Finance-App habe ich befohlen: “Bau mir die App.” Kein Dialog. Keine Fragen. Keine Diskussion. Die KI hat interpretiert. Falsch. Ich habe es zu spät gemerkt.
Ersetze jeden Befehl durch eine Frage. Statt “Refactor diesen Code” → “Was würdest du an diesem Code verbessern? Warum?” Statt “Bau mir Feature X” → “Wie würdest du Feature X strukturieren? Welche Patterns passen hier?” Statt “Fix diesen Bug” → “Was könnte die Ursache dieses Bugs sein? Wie würdest du das debuggen?”
Führe das Gespräch. Aber führe es als Dialog. Du lernst mehr. Du verstehst mehr. Du merkst Fehler früher.
Sokrates, nicht Befehl. Immer.
Pattern 4: Kontext ist König
Die Kernaussage: Baue explizit einen shared context auf. Durch Diskussion, Alignment Checks und Externalisierung in Docs.
Du diskutierst Requirements mit der KI. Ihr redet über Features, über Architektur, über Patterns. Die KI versteht. Du verstehst. Alles klar. Drei Prompts später: Die KI hat vergessen, was ihr besprochen habt. Oder interpretiert es anders. Der Context ist weg. Du denkst: “Aber wir haben doch darüber gesprochen!” Ja. Aber es ist nicht persistent. Nicht explizit. Nicht referenzierbar.
Kontext ist alles beim AI-Coding. Ohne shared context interpretiert die KI jeden Prompt isoliert. Moderne KI-Modelle wie Claude haben große Context Windows (200K tokens standard, bis zu 1M tokens extended), aber das heißt nicht, dass sie automatisch “erinnern” was wichtig war. Sie haben das gesamte Gespräch im Context – aber keine Priorität, welche Information kritisch ist. Das führt zu inkonsistenten Entscheidungen, widersprüchlichen Implementierungen, Code der nicht zum Rest passt.
Du musst Context aktiv bauen und pflegen. Nicht nur reden. Sondern: Alignment Checks nach jeder wichtigen Diskussion, Externalisierung von wichtigen Entscheidungen in Files, Referenzierung auf diese Docs in späteren Prompts.
Schau dir den Unterschied an. Ohne Context-Building: “Wir nutzen Repository Pattern.” “Okay.” Zehn Prompts später: “Bau mir jetzt den Service für Transactions.” Die KI baut Service ohne Repository Pattern, weil Context weg ist. Mit Context-Building: “Wir nutzen Repository Pattern für Data Access. Service Layer für Business Logic. DTOs für API. Fasse zusammen, was wir gerade definiert haben.” Die KI fasst zusammen. Du liest, siehst: passt. “Schreibe das in eine Datei ARCHITECTURE.md.” Die KI erstellt ARCHITECTURE.md. Zehn Prompts später: “Bau mir jetzt den Service für Transactions. Wie in ARCHITECTURE.md definiert.” Die KI nutzt Repository Pattern, weil explizit referenziert.
Was du externalisieren solltest: ARCHITECTURE.md (Layer-Struktur, Patterns, Separation of Concerns, Data Flow), PATTERNS.md (Implementierungs-Patterns, Code Conventions, Naming), REQUIREMENTS.md (User Stories, Business Rules, Edge Cases), DECISIONS.md (Tech Decisions, warum Framework X, warum Pattern Y, Trade-offs).
Context Window Best Practices: Wichtige Dokumente gehören an den Anfang deines Prompts. Studien zeigen: Response-Qualität kann sich um bis zu 30% verbessern, wenn kritische Informationen am Anfang stehen statt verstreut im Conversation-Verlauf. Nutze Struktur (XML-Tags, klare Sections), damit die KI Context navigieren kann. Referenziere explizit: “Wie in ARCHITECTURE.md definiert…” ist besser als “Wie wir besprochen haben…” Ein großes Context Window heißt nicht, dass alles gleich präsent ist. Du musst Context aktiv strukturieren.
Du hast kein shared context, wenn die KI Entscheidungen trifft, die vorherigen Entscheidungen widersprechen. Wenn du sagst “Aber wir haben doch besprochen…” und die KI weiß es nicht mehr. Wenn jeder neue Prompt sich anfühlt wie ein Reset. Wenn du immer wieder dieselben Dinge erklären musst.
Beim Manufacturing-Projekt: Nach Requirements-Diskussion “Fasse zusammen, was wir gerade definiert haben.” Die KI fasst zusammen. Ich lese. Sehe Missverständnisse. Korrigiere. Wichtige Entscheidungen → in .md Files. ARCHITECTURE.md. PATTERNS.md. Requirements aus Meetings in REQUIREMENTS.md. PDFs mit Spezifikationen integriert, referenziert, Teil des Contexts gemacht. In jedem wichtigen Prompt: “Wie in ARCHITECTURE.md definiert, nutzen wir…” Context war persistent. Referenzierbar. Konsistent.
Bei der Finance-App: Ich habe auf meine Excel-Datei referenziert. “Schau dir das mal an.” Dann bin ich davon ausgegangen, dass das verstanden wurde. Kein Alignment Check. Keine Externalisierung. Keine Referenzierung. Context war flüchtig. Inkonsistent. Weg.
Nach jeder wichtigen Diskussion: Alignment Check (“Fasse zusammen, was wir gerade definiert haben”), Review (lies die Zusammenfassung, korrigiere Missverständnisse), Externalisiere (“Schreibe das in ARCHITECTURE.md / PATTERNS.md”), Referenziere (in späteren Prompts: “Wie in ARCHITECTURE.md definiert…”).
Das dauert 2 Minuten. Aber es verhindert 2 Stunden verschwendete Development-Zeit.
Kontext ist König. Build it. Document it. Reference it.
Pattern 5: The Starting Stats Test
Die Kernaussage: Validiere das Datenmodell zuerst. Bevor eine einzige Zeile Feature-Code geschrieben wird.
Du startest ein neues Projekt, diskutierst Requirements, besprichst Features. Dann sagst du: “Los, bau mir das System.” Die KI entwickelt. Code entsteht. Features werden implementiert. Nach zwei Stunden schaust du in den Code. Das Datenmodell macht keinen Sinn. Relationen sind falsch. Entities fehlen. Properties passen nicht. Aber darauf baut alles auf. Jetzt musst du entweder das gesamte Datenmodell refactoren (Tage Arbeit) oder mit einem schiefen Fundament weiterbauen (exponentielles Chaos).
Bei Dark Souls gibst du am Anfang deine Starting Stats ein. Strength. Dexterity. Intelligence. Endurance. Wenn die falsch sind, kämpfst du den ganzen Run. Du kannst deine Build-Entscheidung später nicht mehr fundamental ändern. Du kannst Skills anpassen, Gear wechseln. Aber deine Starting Stats? Die bleiben. Ein Strength-Build kann nicht plötzlich ein Sorcerer werden.
Das Datenmodell sind deine Starting Stats. Alles andere baut darauf auf: Deine Business Logic basiert auf deinen Entities, deine Service Layer auf deinen Relationen, deine API Endpoints auf deinen Properties, dein Frontend konsumiert DTOs die auf deinen Entities basieren. Wenn das Datenmodell falsch ist, wird Business Logic kompliziert und fehleranfällig, Queries werden ineffizient, Features passen nicht zusammen, jede Erweiterung wird schmerzhaft. Alle anderen Entscheidungen wachsen aus diesem Schema. Es sind deine Starting Stats. Wenn die schief sind, wird der ganze Run schief.
Ohne Starting Stats Test: “Bau mir die Finance-App.” Die KI erstellt irgendein Datenmodell, beginnt zu entwickeln. Du schaust erst nach 2 Stunden ins Schema, merkst: passt nicht. Zu spät. Mit Starting Stats Test: “Basierend auf unseren Requirements: Erstelle mir ein Entity Relationship Diagram für dieses System.” Die KI erstellt ERM. Du validierst jede Entity, jede Relation, jedes Property. “Warum hast du Categories als separate Tabelle statt als Enum?” Die KI erklärt. Du korrigierst. Iteriert, bis Schema stimmt. Erst dann baut ihr darauf auf.
Nach der Requirements-Diskussion sagst du: “Erstelle mir ein Entity Relationship Diagram für dieses System.” Dann schaust du dir jede Entity an, jede Relation, jedes Property. Fehlen wichtige Entities? Sind Entities sinnvoll benannt? Gibt es überflüssige Entities? Sind Relationen korrekt modelliert (1:1, 1:n, n:m)? Machen sie Sinn für die Use Cases? Sind Properties sinnvoll benannt und getypt? Fehlen kritische Properties? Stimmt die Normalisierung? Ist das Schema wartbar?
Wenn irgendwas nicht passt → Stop. Nicht weitermachen. Nicht “wir fixen das später”. Stop. Jetzt. Kläre das Missverständnis. Diskutiere die Struktur. Iteriere das Schema, bis es stimmt.
Du hast deine Starting Stats nicht validiert, wenn du mit Feature-Development beginnst, ohne das Schema gesehen zu haben. Wenn du hoffst, dass die KI “schon das richtige” Datenmodell erstellt hat. Wenn du sagst “Wir schauen später ins Schema.” Wenn du nach Stunden merkst, dass das Datenmodell nicht passt.
Beim Manufacturing-Projekt war das Schema der erste Schritt. Wir haben diskutiert: Welche Entities brauchen wir? Wie hängen sie zusammen? Welche Properties sind wirklich nötig? Erst als das Schema validiert war – wirklich validiert, jede Tabelle durchgesprochen, jede Relation verstanden – erst dann haben wir Code generiert.
Bei der Finance-App habe ich kein Schema validiert. Die KI hat einfach losgelegt. Sie hat ein Schema erstellt. Irgendein Schema. Vermutlich intern konsistent. Aber es hat nicht reflektiert, was ich wirklich wollte. Und alles, was darauf aufbaute, war entsprechend falsch.
Der richtige Prozess: Requirements besprechen. Dann: “Erstelle mir ein Entity Relationship Diagram für dieses System.” Validierung: Jede Entity, jede Relation, jedes Property durchgehen. Iteration: Wenn was nicht passt → diskutieren, anpassen, nochmal schauen. Erst wenn die Starting Stats stimmen: Code bauen.
Das ist nicht Overhead. Das ist die Basis von allem.
Check your Starting Stats. Before the run begins.
Pattern 6: Eine Rolle zur Zeit
Die Kernaussage: Die KI ist nicht gleichzeitig Business Analyst, Architekt und Coder. Du orchestrierst die Rollen sequentiell.
Du gibst der KI einen Epic-Level Prompt: “Bau mir eine Finance-App. Hier ist, was ich will. Mach’s besser als Excel.” Dann gehst du Kaffee holen. Du erwartest, dass die KI Requirements versteht (Business Analyst), Architektur entwirft (Architect), Tech Decisions trifft (Tech Lead), Code produziert (Developer), und alles zusammenbringt (Integration Engineer). Das sind fünf verschiedene Jobs. In einem echten Software-Team würden das fünf verschiedene Expertise-Bereiche sein. Verschiedene Menschen mit verschiedenen Skillsets, die in einem Prozess zusammenarbeiten. Aber der KI gibst du alle Jobs gleichzeitig.
“Ich hab alle Aufgaben einfach über den Zaun geworfen und gesagt: Du bist Requirements Engineer, Du bist Architekt, Du bist Coder, Du bist Business Analyst. Und das sind alles Aufgaben, die auch in Software Teams nicht die gleiche Person durchführt.”
Das funktioniert nicht. Die KI ist kein Magier. Sie ist ein Tool. Ein sehr mächtiges Tool. Aber immer noch ein Tool. Du würdest einem Junior Developer nicht sagen: “Versteh das Geschäftsmodell, design die Architektur, wähl den Tech Stack, und bau mir das System. Ich komm in zwei Stunden wieder.” Das funktioniert nicht. Bei Menschen nicht. Bei KI nicht. Du musst die Rollen orchestrieren.
In einem Software-Projekt gibt es verschiedene Rollen: Der Business Analyst versteht, was eigentlich gebaut werden soll (Was ist das Problem? Was ist die Lösung? Welche Use Cases?). Der Architect entwirft die System-Struktur (Welche Layer? Welche Patterns? Wie trennen wir Concerns?). Der Tech Lead legt Tech Stack und Conventions fest (Welches Framework? Welche Libraries? Welche Conventions?). Der Developer schreibt Code innerhalb der Vorgaben (Wie implementiere ich Feature X mit Pattern Y?). Der Code Reviewer validiert Qualität (Folgt der Code den Patterns? Ist er wartbar? Gibt es Bugs?).
Du bist der Business Analyst. Du klärst, was eigentlich gebaut werden soll. Du bist der Architect. Du entscheidest, wie das System strukturiert sein wird. Du bist der Tech Lead. Du definierst Frameworks, Conventions, Patterns. Die KI ist der Implementierer. Sie nimmt deine Vorgaben und setzt sie um. Wenn du der KI alle Rollen gibst, bekommt sie alle Rollen schlecht hin.
Beim Manufacturing-Projekt habe ich jede Rolle einzeln durchgeführt. Erst Business Analysis: Meetings mit Kunde, Requirements verstehen, Use Cases definieren. Dann Architecture (ich plus KI): “Basierend auf diesen Requirements, wie strukturieren wir das? Was sind die Core Entities? Welche Layer brauchen wir?” Dann Tech Decisions (ich): “Wir nutzen Repository Pattern. Service Layer. Dependency Injection. React plus TypeScript. Tailwind.” Dann Implementation (KI): “Erstelle Repository Layer für Entity X mit CRUD Operations.” Dann Review (ich): Code anschauen, validieren, Feedback geben, iterieren. Sequentiell. Eine Rolle zur Zeit.
Bei der Finance-App: Über-den-Zaun-Wurf. “Mach mal.” Die KI sollte Business Analyst, Architekt, Tech Lead, Developer und Reviewer sein. Alles gleichzeitig. Ergebnis: Keins davon gut.
Nie erwarten, dass die KI alle Rollen erfüllt. Du machst Business Analysis. Du plus KI macht Architecture. Du machst Tech Decisions. KI macht Implementation. Du machst Review. Sequentiell. Klar getrennt. Eine Rolle zur Zeit. Die KI ist Junior Engineer, nicht Magier.
Pattern 7: User Story Level, nicht Epic Level
Die Kernaussage: Schneide Tasks runter. Nutze dein Scrum-Wissen. Schätzbare, klar definierte Einheiten.
“Wir brauchen eine Login Page” – das ist ein Epic. Das sind zehn verschiedene Stories in einem Satz versteckt. OAuth Integration. Session Management. Password Reset. Remember Me. Error Handling. Loading States. Validation. Security. Redirect Logic. UI States. Wenn du das einem Team gibst und sagst “Macht mal”, bekommst du Chaos. Jeder interpretiert anders. Jeder baut sein Stück. Am Ende passt nichts zusammen. Deswegen schneiden wir Epics in User Stories.
Eine User Story ist schätzbar. Klar definiert. Ein Entwickler kann sie sich anschauen und sagen: “Ich weiß, was ich tun muss. Ich weiß, wie ich das umsetze. Es gibt keine Unklarheiten.” Das gleiche gilt für AI-Coding.
“Prompt User Story Level. Man muss aus dem Kontext heraus Aufgaben schneiden, die die Möglichkeit von Unklarheiten und undefinierten Zuständen maximal reduziert.”
Die meisten Leute prompten auf Epic-Ebene: “Bau mir Login mit OAuth, Session Management, Password Reset.” Das sind fünf bis zehn Stories in einem Prompt. Die KI wird interpretieren. Jede Story anders. Jede Entscheidung isoliert. Und am Ende passt nichts zusammen. Du musst runterbrechen. Nicht auf absurd kleine Ebene. Nicht “erstelle mir eine Variable für den Username”. Das wäre Quatsch. Aber auf schätzbare, klar definierte Tasks.
Eine gute Task für KI ist wie eine gute User Story. Sie hat ein klar definiertes Ziel (nicht “Bau mir die Datenbank-Sachen” sondern “Erstelle Transaction Repository mit CRUD Operations”). Sie hat definierte Inputs und Outputs (Repository verwendet Transaction Entity, returns TransactionDTO – nicht “Macht irgendwas mit Transaktionen”). Der Scope ist begrenzt (nur Repository Layer, keine Business Logic – nicht “Mach das komplett fertig”). Die Dependencies sind bekannt (verwendet bereits existierendes IDatabase Interface – nicht “Bau mir die ganze Infrastruktur”). Keine Unklarheiten. Keine undefined states.
Wenn du bei einem Prompt zögerst bei einer dieser Fragen, ist der Task zu groß: Ist das Ziel klar? Kannst du in einem Satz beschreiben, was rauskommen soll? Sind alle Dependencies geklärt? Weißt du, worauf das aufbaut? Ist der Scope begrenzt? Nicht zu viel auf einmal? Kannst du das in 1-2 Stunden implementieren lassen? Wenn nein → zu groß. Schneide weiter.
Schau dir den Unterschied an. Epic-Level (falsch): “Bau mir Login mit OAuth, Session Management, Password Reset und Remember Me.” Die KI interpretiert jedes Feature anders, nichts passt zusammen. User Story Level (richtig): Task 1 ist “Erstelle Authentication Service mit bcrypt Password Hashing. Input: username + password. Output: JWT Token oder Error.” Task 2 ist “Erstelle Session Management Service. Verwendet JWT Token aus Task 1. Provides isAuthenticated() check.” Task 3 ist “Erstelle Password Reset Flow. Email-basiert. Verwendet Temp Token mit 1h Expiry.” Jede Task: 1-2 Stunden Implementierung. Klar. Definiert. Schätzbar.
Du bist auf Epic-Level statt User Story Level, wenn ein Task mehr als 2 Stunden Implementierung brauchen würde, du nicht in einem Satz beschreiben kannst was rauskommen soll, Dependencies unklar sind, der Scope schwammig ist (“mach das fertig”), oder du hoffst dass die KI “schon versteht” was gemeint ist.
Beim Manufacturing-Projekt habe ich keine Epics geprompted. Ich habe Tasks geschnitten: “Erstelle Repository Layer für Entity X”, “Extrahiere Business Logic aus Component Y in Service Z”, “Refactor Data Access in Component A nach Pattern B”. Jede Task: 1-2 Stunden Implementierung. Klar. Definiert. Schätzbar. Bei der Finance-App: “Bau mir die App.” Das ist nicht mal ein Epic. Das ist ein ganzes Programm. Die KI hat interpretiert. Alles auf einmal. Inkohärent.
Nimm deinen Epic. Zerlege ihn. Epic: “User Authentication System”. Stories: User Registration (Email + Password), Login Endpoint mit JWT, Password Hashing mit bcrypt, Session Validation Middleware, Logout Functionality, Password Reset Flow, Email Verification. Jede Story wird zu einem separaten Prompt. Jede Story baut auf validiertem Code auf. Keine Vermischung. Keine Unklarheiten.
User Story Level. Immer.
Pattern 8: Sequencing & Dependencies
Die Kernaussage: Baue Bottom-Up. Keine vertikalen Durchstiche. Jeder Layer wird validiert, bevor der nächste startet.
Man kann nicht “Login bauen” bevor Repository oder Service Layer existiert. Man kann nicht “Dashboard zeigen” bevor die API Endpoints stehen. Man kann nicht “Reports generieren” bevor die Aggregation-Logic implementiert ist. Die Reihenfolge ist wichtig. Für Menschen. Und für KI.
“In dem Moment wo ich versuche, einen kompletten Durchstich in einem System herzustellen, bekomm ich nach links und rechts Ausreißer. Das ist fast unvermeidbar.”
Ein vertikaler Durchstich klingt gut in der Theorie: “Eine End-to-End Story, die alle Layer berührt. Login von Frontend bis Datenbank in einem Schritt.” In der Praxis mit KI? Chaos. Warum? Die KI muss gleichzeitig Architektur-Entscheidungen auf allen Layern treffen. Diese Entscheidungen müssen konsistent sein. Aber sie werden in verschiedenen Dateien, verschiedenen Contexts, verschiedenen Momenten getroffen. Inkonsistenzen sind fast garantiert. Database Schema nutzt einen Approach. Repository Layer einen anderen. Service Layer wieder anders. API macht sein eigenes Ding. Frontend interpretiert alles nochmal neu. Am Ende: Fünf verschiedene Patterns. Nichts passt zusammen.
Bottom-Up ist sicherer. Du etablierst Patterns Layer für Layer. Jeder Layer baut auf validierten, funktionierenden Foundations auf. Die KI hat klare Vorgaben: “So sieht das darunter liegende Layer aus. Mach es konsistent dazu.” Keine Interpretation. Keine Freiheitsgrade. Klar definiert.
Die Build-Sequence sieht so aus: Layer 1 ist Foundation (Datenmodell definieren, Core Entities erstellen, Database Setup). Validiert? Dann weiter zu Layer 2. Layer 2 ist Data Access (Repository Pattern implementieren, Basic CRUD Operations, Database Migrations). Validiert? Dann weiter zu Layer 3. Layer 3 ist Business Logic (Service Layer aufbauen, Domain Logic implementieren, Business Rules kodieren). Validiert? Dann weiter zu Layer 4. Layer 4 ist API (Controllers/Endpoints erstellen, DTOs definieren, Request/Response Handling). Validiert? Dann weiter zu Layer 5. Layer 5 ist Frontend (UI Components bauen, State Management, API Integration). Validiert? Dann weiter zu Layer 6. Layer 6 ist Integration (End-to-End Features, Integration Tests, User Flows validieren).
Du baust nicht Bottom-Up, wenn du versuchst Frontend und Backend gleichzeitig zu bauen, wenn du hoffst dass “alles später zusammenpasst”, wenn du Code auf Layer N hast aber Layer N-1 ist nicht validiert, oder wenn du “probierst mal aus” ob’s funktioniert.
Schau dir den Unterschied an. Vertical Slice (falsch): “Bau mir Login Feature komplett. Frontend bis Datenbank.” Die KI versucht alles gleichzeitig, trifft inkonsistente Entscheidungen auf jedem Layer. Ergebnis: Code existiert. Aber Patterns passen nicht zusammen. Bottom-Up (richtig): Phase 1 ist “Erstelle User Entity mit Properties: id, email, passwordHash, createdAt.” Validiert. Phase 2 ist “Erstelle UserRepository mit CRUD Operations. Verwendet User Entity aus Phase 1.” Validiert. Phase 3 ist “Erstelle AuthService mit register() und login(). Verwendet UserRepository aus Phase 2.” Validiert. Phase 4 ist “Erstelle API Endpoints /register und /login. Verwendet AuthService aus Phase 3.” Validiert. Phase 5 ist “Erstelle Frontend LoginForm. Konsumiert /login Endpoint aus Phase 4.” Validiert. Phase 6 ist “Teste End-to-End Flow: Registrierung → Login → Dashboard.” Jede Phase baut auf validiertem, funktionierendem Code auf.
Beim Manufacturing-Projekt: Bottom-Up. Strikte Sequence. Erst Datenmodell definiert. Validiert. Approved. Dann Repository Layer gebaut. Auf dem validierten Datenmodell. Dann Service Layer mit Business Logic. Konsistent mit dem Repository Pattern. Dann API Endpoints. Konsistent mit der Service Layer Struktur. Dann Frontend Features. Konsumierend die API. In dieser Reihenfolge. Nicht alles auf einmal. Jede Stufe wurde fertig gemacht – wirklich fertig, getestet, validiert – bevor die nächste startete. Bei der Finance-App: Vertikaler Durchstich. “Bau mir eine Feature-Complete App.” Die KI hat versucht, alles gleichzeitig zu machen. Datenbank, Business Logic, API, Frontend. Alles in einem großen Batch. Und natürlich: Inkonsistenzen überall. Patterns, die nicht passten. Strukturen, die kollidierten.
Definiere die Sequence bevor du beginnst: Was muss zuerst existieren? Was baut darauf auf? Was kommt danach? Schreib es auf. Nummeriere die Phasen. Arbeite sie sequentiell ab. Validiere jede Phase, bevor du weitergehst. Das ist nicht langsamer. Das ist schneller. Weil du nicht zurückgehen musst, um Inkonsistenzen zu fixen.
Bottom-Up. Always.
Pattern 9: Reduce Undefined States to Zero
Die Kernaussage: Maximale Klarheit = minimale Freiheitsgrade für die KI. Pattern bekannt. Problem klar. Wie/Wann/Warum definiert. Keine Interpretationsspielräume.
Du sagst: “Bau mir ein Authentication System.” Die KI fragt nicht nach. Sie interpretiert. Aber “Authentication System” hat tausend mögliche Interpretationen: JWT oder Session-based? Welcher Hashing Algorithm? Passwort-Reset via Email oder Security Questions? OAuth Integration? Remember Me Functionality? Account Lockout nach X failed attempts? Jede unklare Anforderung ist ein undefined state. Die KI wird einen Zustand wählen. Irgendein Zustand. Vermutlich nicht der, den du gemeint hast.
Je mehr undefined states, desto mehr Interpretationsspielraum. Je mehr Interpretationsspielraum, desto höher die Wahrscheinlichkeit, dass die KI anders interpretiert als du gemeint hast. Und weil die KI jeden Feature-Prompt isoliert interpretiert, werden verschiedene Features unterschiedlich interpretiert. Das führt zu Inkonsistenz. Feature A nutzt JWT. Feature B nutzt Sessions. Feature C vermischt beides. Nichts passt zusammen. Die Lösung: Eliminate undefined states.
Schau dir den Unterschied an. Mit Undefined States (falsch): “Bau mir ein Authentication System.” Undefined States: Welche Auth-Methode? Welche Security-Maßnahmen? Welche Features? Welche Edge Cases? Die KI interpretiert, wählt irgendwas, baut es. Du hoffst, dass es passt. Ohne Undefined States (richtig): “Bau mir ein Authentication System mit folgenden Spezifikationen: JWT-based (nicht Session-based), bcrypt Password Hashing mit Salt Rounds 12, Password Requirements: min 8 chars, 1 uppercase, 1 number, Account Lockout: 5 failed attempts → 15min lock, Remember Me: Optional, extends JWT expiry to 30 days, Password Reset: Email-based mit Temp Token (1h expiry), Verwendet bereits existierenden EmailService für Versand, Keine OAuth Integration in diesem Sprint.” Undefined States: 0. Die KI baut exakt das, keine Interpretation nötig.
Was du definieren musst: Das Pattern (nicht “Bau mir Data Access” sondern “Bau mir Data Access nach Repository Pattern wie in ARCHITECTURE.md definiert”). Das Problem (nicht “Das muss besser werden” sondern “Business Logic ist im Frontend (Component X, Lines 45-120). Das verletzt Single Responsibility und macht Testing schwer”). Das Wie (nicht “Refactor das” sondern “Extrahiere in TransactionService mit Methods calculateMonthlyTotal() und categorizeTransaction(). Service wird via DI injected”). Das Wann (nicht “Validation irgendwo” sondern “Validation im Service Layer vor DB-Insert. Frontend validation nur für UX, nicht für Security”). Das Warum (nicht nur “mach das”, sondern “Warum? Weil Business Logic im Frontend Testing erschwert und Wiederverwendbarkeit verhindert”).
Du hast undefined states, wenn die KI fragen müsste “Wie meinst du das genau?” (aber nicht fragt, sondern interpretiert), wenn du sagst “Das ist doch klar” ohne es explizit zu definieren, wenn du hoffst dass die KI “schon das Richtige” macht, oder wenn du bemerkst nach der Implementation “Das meinte ich nicht so”.
Beim Manufacturing-Projekt war jeder Task klar definiert: “Extrahiere Business Logic aus ProductionOrderComponent in ProductionOrderService. Business Logic ist aktuell in Lines 120-350: calculateProductionTime(), validateSpecifications(), checkMaterialAvailability(). Service Pattern wie in ARCHITECTURE.md. Dependency Injection. Returns ServiceResult mit Success/Error states. Frontend Component nutzt nur noch Service, keine Business Logic mehr lokal.” Undefined States: 0. Die KI wusste exakt, was zu tun ist. Bei der Finance-App: “Bau mir Transaktions-Tracking.” Undefined States: ~20. Die KI hat interpretiert. Falsch. Inkonsistent.
Bevor du einen Prompt sendest, frag dich: Könnte die KI das unterschiedlich interpretieren? Dann präzisiere. Gibt es mehrere valide Ansätze? Dann wähle einen und kommuniziere ihn. Könnte jemand fragen “Wie genau meinst du das?” Dann beantworte diese Frage im Prompt. Gibt es Annahmen, die “klar sein sollten”? Mach sie explizit. Ziel: Undefined States = 0. Je klarer dein Prompt, desto weniger Interpretationsspielraum, desto konsistenter der Code.
Eliminate ambiguity. Always.
Pattern 10: Erwartungen vor Code
Die Kernaussage: Input → Problem → Ziel → Expected Output. Alles bevor Code fließt.
Du sagst: “Bau mir einen Service für Transactions.” Die KI baut. Code entsteht. Du schaust rein. Der Service macht… irgendwas. Vermutlich was Sinnvolles. Aber ist es das, was du wolltest? Du weißt es nicht. Weil du nicht definiert hast, wie es aussehen sollte, wenn’s fertig ist. Du hattest keine Erwartung. Nur eine vage Vorstellung. Das ist, als würdest du einem Maler sagen “Mal mir was Schönes” und dann überrascht sein, dass es nicht das ist, was du dir vorgestellt hast.
Ohne klar definierte Erwartungen kannst du nicht validieren, ob das Ergebnis korrekt ist. Du kannst nur fühlen: “Hmm, das wirkt irgendwie nicht richtig.” Aber du kannst nicht messen: “Das erfüllt Kriterium X nicht.” Erwartungen sind dein Acceptance Criteria. Dein Definition of Done. Ohne Erwartungen = keine Validierung = hoffnungsbasierte Entwicklung.
Was du definieren musst: Input (nicht “Der Service bekommt Daten” sondern “Der Service bekommt: userId (string), startDate (Date), endDate (Date)”). Problem (nicht “Irgendwas mit Transaktionen” sondern “User braucht monatliche Übersicht aller Transaktionen mit Summen pro Kategorie”). Ziel (nicht “Ein Report” sondern “MonthlyReport Object mit: totalIncome, totalExpenses, categoryBreakdown[], netBalance”). Expected Output mit konkretem Beispiel:
{ month: "2025-11", totalIncome: 5000, totalExpenses: 3200, categoryBreakdown: [ { category: "Food", amount: 800 }, { category: "Rent", amount: 1500 }, { category: "Transport", amount: 200 } ], netBalance: 1800}
Jetzt kann die KI bauen. Und du kannst validieren.
Schau dir den Unterschied an. Ohne Erwartungen (falsch): “Bau mir einen Service für monatliche Reports.” Die KI baut irgendwas. Du schaust rein, unsicher ob’s richtig ist. Mit Erwartungen (richtig): “Bau mir MonthlyReportService mit Method generateReport(). Input: userId (string), month (string format ‘YYYY-MM’). Problem: User braucht Übersicht seiner monatlichen Einnahmen/Ausgaben gruppiert nach Kategorien. Ziel: Return MonthlyReport Object. Expected Output wie oben gezeigt. Pattern: Service Layer wie in ARCHITECTURE.md. Verwendet TransactionRepository. Returns ServiceResult.” Jetzt ist klar, was gebaut werden soll. Und du kannst validieren, ob das Ergebnis diese Erwartungen erfüllt.
Du hast keine klaren Erwartungen, wenn du nicht beschreiben kannst wie der Output aussehen soll, wenn du hoffst dass “es schon passen wird”, wenn du validierst mit Gefühl statt mit Kriterien, oder wenn du merkst nach der Impl “Das meinte ich anders”.
Beim Manufacturing-Projekt: Vor jedem Task Erwartungen definiert. “Erstelle ProductionTimeCalculator Service. Input: productionOrder (ProductionOrder), materialSpecs (MaterialSpecification[]). Problem: Produktionszeit muss basierend auf Materialien und Spezifikationen kalkuliert werden. Expected Output: estimatedTime (450 minutes), breakdown mit step und time, readyAt (Date). Pattern: Service Layer, injected via DI, uses MaterialService for specs lookup.” Die KI wusste exakt, was zu bauen ist. Ich konnte exakt validieren, ob’s passt. Bei der Finance-App: “Bau mir Transactions-Features.” Keine Erwartungen. Keine Input/Output Definition. Kein Expected Result. Die KI hat gebaut. Ich habe gehofft. Es hat nicht gepasst.
Template für jeden Task: Task: [Name]. Input: [Was geht rein? Mit Types!]. Problem: [Was wird gelöst? User Story!]. Ziel: [Was soll rauskommen?]. Expected Output: [Konkretes Beispiel-Output]. Pattern: [Welches Pattern? Welche Dependencies?]. Füll das aus bevor du Code schreiben lässt. Dann: Validiere gegen diese Erwartungen.
Define expectations. Always. Before code.
Pattern 11: Verständnis-Validierung vor Code
Die Kernaussage: Frage aktiv: “Was hast du verstanden?” Nicht annehmen. Validieren.
Du diskutierst Requirements mit der KI. Ihr redet über Features. Über Architektur. Du erklärst, was du willst. Die KI sagt: “Verstanden.” Du denkst: “Gut, dann sind wir aligned.” Dann generierst du Code. Und merkst: Die KI hat was anderes verstanden, als du gemeint hast.
“Davon auszugehen, dass etwas klar ist, funktioniert auch in der menschlichen Kommunikation nicht. Wenn ich einem Engineer sage, was ich brauche, dann haue ich denen nicht drei Sätze an den Kopf, referenziere auf irgendeine Datei, und gehe dann davon aus, dass das verstanden wurde.”
Die KI ist nicht magisch. Sie ist nicht telepathisch. Sie hat kein inhärentes Verständnis von dem, was du wirklich meinst. Sie interpretiert. Basierend auf dem, was du sagst. Und manchmal – oft – ist ihre Interpretation nicht das, was du gemeint hast. Du musst Verständnis validieren. Nicht annehmen. Nicht hoffen. Validieren. In einem echten Engineering-Team würdest du nie sagen: “Hier, lies diese drei Dokumente, schau dir die Excel-Datei an, bau das Feature” – und dann zwei Wochen später das Ergebnis sehen. Du würdest nach einem Tag fragen: “Was hast du verstanden? Erkläre mir deinen Ansatz. Wie willst du das lösen?” Und wenn die Antwort nicht passt? Dann korrigierst du. Sofort. Bevor Code geschrieben wird.
Wann du validieren musst: Nach Requirements-Diskussion (“Fasse zusammen, was du über die Requirements verstanden hast” – die KI fasst zusammen – du liest, siehst Missverständnisse, korrigierst). Nach Architektur-Definition (“Zeig mir das Datenmodell, wie du es verstanden hast” – die KI zeigt ERM – du validierst jede Entity, jede Relation). Nach Task-Definition (“Erkläre mir, was du jetzt genau bauen wirst. Was ist der Input? Was ist der Output? Welches Pattern nutzt du?” – die KI erklärt – du prüfst, ob Verständnis korrekt ist). Nach Code-Generation (“Erkenne ich meine Requirements im Code wieder?” – du scannst Code auf Alignment).
Schau dir den Unterschied an. Ohne Validierung (falsch): “Wir bauen eine Finance-App mit Transactions, Categories, und Monthly Reports. Hier ist meine Excel-Datei. Verstehst du, was ich meine?” “Ja, verstanden.” “Okay, dann bau das mal.” Die KI baut basierend auf ihrer Interpretation. Du merkst zwei Stunden später: Interpretation war falsch. Mit Validierung (richtig): “Wir bauen eine Finance-App mit Transactions, Categories, und Monthly Reports. Ich habe dir meine Excel-Datei gezeigt. Fasse zusammen, was du verstanden hast.” “Ich verstehe: Transaktionen haben ein Datum, einen Betrag, und eine Kategorie. Kategorien sind: Food, Rent, Transport, Entertainment. Monthly Reports zeigen Summen pro Kategorie…” Du liest, siehst: “Entertainment fehlt eigentlich, wir brauchen Utilities stattdessen.” “Fast richtig. Aber wir haben keine Entertainment-Kategorie, sondern Utilities. Und Transaktionen brauchen auch ein ‘description’ Feld.” “Verstanden, ich korrigiere: Kategorien sind Food, Rent, Transport, Utilities. Transaktionen haben: date, amount, category, description.” “Korrekt. Jetzt zeig mir, wie du das Datenmodell strukturieren würdest.” Die KI zeigt ERM. Du validierst, iteriert, bis es stimmt. “Okay, jetzt können wir bauen.”
Du validierst Verständnis nicht, wenn du annimmst dass “es klar sein sollte”, wenn du nicht aktiv nachfragst “Was hast du verstanden?”, wenn du direkt mit Code-Generation startest nach Requirements-Diskussion, oder wenn du merkst nach der Impl “Das meinte ich anders”.
Beim Manufacturing-Projekt: Nach jeder wichtigen Diskussion “Fasse zusammen, was wir gerade definiert haben.” Die KI fasst zusammen. Ich lese es. Ich sehe sofort, wo Missverständnisse sind. Wo die Interpretation abweicht. Wo ich unklarer war, als ich dachte. Dann korrigiere ich. Kläre. Präzisiere. Das dauert zwei Minuten. Aber es verhindert zwei Stunden verschwendete Development-Zeit. Bei der Finance-App: Ich habe auf meine Excel-Datei referenziert. “Schau dir das mal an, verstehst du?” Dann bin ich davon ausgegangen, dass das verstanden wurde. Kein Alignment Check. Keine Zusammenfassung. Keine Validierung. Die KI hat interpretiert. Falsch. Ich habe es zu spät gemerkt.
Nach jeder wichtigen Phase: “Fasse zusammen, was wir gerade definiert haben.” Review: Lies die Zusammenfassung sorgfältig. Korrigiere: Wo ist die Interpretation falsch? Wo fehlt was? Iteriere: Bis das Verständnis aligned ist. Erst dann: Code. Validation Checkpoints: Nach Requirements (“Was hast du verstanden?”), nach Architektur (“Zeig mir das Datenmodell”), nach Task-Definition (“Erkläre deinen Ansatz”), nach Code (“Erkenne ich meine Requirements wieder?”). Wenn eine Validierung fehlschlägt → Stop. Nicht weitermachen.
Validate understanding. Always. Before code.
Pattern 12: Code Reflection Test
Die Kernaussage: Erkennst du deine Requirements im generierten Code wieder? Wenn nein → Abort Mission. Sofort.
Die KI hat Code produziert. Du hast Features definiert – klar erklärt. Oder so dachtest du. Du öffnest die erste File. Schaust auf den Code. Und du verstehst nicht, was du da siehst. Die Features im Code entsprechen nicht dem, was du beschrieben hast. Die Struktur macht keinen Sinn für deine Use Cases. Du siehst Properties, von denen du nicht weißt, woher sie kommen. Du siehst Logik, die du nicht nachvollziehen kannst. Du kannst deine Requirements nicht im Code wiederfinden.
“Ich habe die Requirements definiert. Habe in den Code reingeschaut und habe nicht greifen können, was es hier geht. Die Features haben nicht das widergespiegelt, was ich glaube, reingegeben zu haben.”
Das ist keine Kleinigkeit. Das ist keine Stilfrage. Das ist nicht “Hmm, das hätte ich anders gemacht.” Das ist: Ich verstehe nicht, wie dieser Code meine Anforderungen lösen soll. Das bedeutet fundamental: Die KI hat etwas anderes gebaut, als du wolltest. Der Code Reflection Test ist simpel: Wenn du in den Code schaust und deine Requirements nicht darin erkennst → Abort Mission. Sofort. Nicht “Hmm, vielleicht verstehe ich es noch.” Nicht “Vielleicht wird’s klarer, wenn ich mehr sehe.” Nicht “Lass sie mal weitermachen, vielleicht passt’s dann.” Stop. Jetzt.
Der Test besteht aus drei Scans. Nach dem ersten generierten Code-Block – dem allerersten – machst du: Scan 1 (Alignment): Erkenne ich meine Requirements im Code wieder? Sehe ich meine Features? Sehe ich meine Entities? Sehe ich meine Use Cases? Wenn Nein: Stop. Scan 2 (Patterns): Folgt der Code den Patterns, die ich definiert habe? Nutzt er das Repository Pattern richtig? Ist die Separation of Concerns sauber? Sind die Patterns konsistent? Wenn Nein: Stop. Scan 3 (Structure): Ist der Code clean und nachvollziehbar? Kann ich die Logik verstehen? Macht die Struktur Sinn? Ist der Code wartbar? Wenn Nein: Stop.
Schau dir den Unterschied an. Code Reflection Test Failed (falsch): Du öffnest ersten generierten Code-Block. “Hmm, das sieht irgendwie anders aus als ich dachte. Aber vielleicht wird’s noch. Lass sie mal weitermachen.” Die KI baut eine Stunde weiter auf falschem Fundament. Du merkst nach einer Stunde: alles falsch. Ergebnis: Haufen Code, der aufzuräumen länger dauert als Neustart. Code Reflection Test Passed (richtig): Du öffnest ersten generierten Code-Block. Scan 1 (Alignment): ✓ Ich sehe meine Transaction Entity mit den Properties, die ich definiert habe. Scan 2 (Patterns): ✓ Repository Pattern wie besprochen. Clean Interface. Scan 3 (Structure): ✓ Code ist verständlich. Logik ist nachvollziehbar. “Passt. Weiter mit nächstem Block.”
Code Reflection Test Failed → Stop: Du öffnest ersten generierten Code-Block. Scan 1 (Alignment): ✗ Categories sind anders als besprochen. Properties fehlen. “Stop. Das passt nicht.” “Warum hast du Categories als separate Tabelle statt als Enum modelliert?” “Ich dachte, das wäre flexibler für…” “Nein, wir hatten Enum besprochen. Weil wir nur fixe Categories haben. Keine dynamischen.” “Verstanden, ich korrigiere.” “Lass uns nochmal von vorne. Zeig mir zuerst das Datenmodell, bevor du Code generierst.” Start von vorne. Mit besserem Alignment.
Du machst den Code Reflection Test nicht, wenn du den ersten Code-Block nicht anschaust, wenn du hoffst dass “es schon passen wird”, wenn du weitermachen lässt obwohl du Zweifel hast, oder wenn du erst nach Stunden merkst “Das ist nicht, was ich wollte”.
Beim Manufacturing-Projekt: Nach jedem generierten Block Code Reflection Test. Erkenne ich, was da gebaut wird? Passt das zu meinen Requirements? Wenn nein: Stop. Kläre. Neu. Wenn ja: Nächster Block. Das hat mehrmals verhindert, dass ich stundenlang in die falsche Richtung baue. Bei der Finance-App: Nach dem ersten Output war klar: Das wird Müll. Ich konnte meine Features nicht im Code erkennen. Die Struktur machte keinen Sinn. Aber ich habe eine Stunde weiter entwickeln lassen. Aus Sunk Cost (siehe Pattern 13). Es wurde nicht besser. Es wurde schlimmer. Am Ende: Ein Haufen Code, bei dem Aufräumen länger dauern würde als von vorne anzufangen.
Nach jedem Code-Block (nicht nur dem ersten): Öffne die Files. Scanne: Alignment (Erkenne ich Requirements?), Patterns (Folgt es den Vorgaben?), Structure (Verstehe ich die Logik?). Wenn alles ✓: Weiter. Wenn irgendwas ✗: Stop, kläre, neu. Die zwei Stunden, die du “sparst”, indem du nicht stoppst? Die wirst du zehnfach bezahlen beim Aufräumen. Early stopping ist besser als late fixing.
Code Reflection Test. After every block. Always.
Pattern 13: Stop Loss Rules
Die Kernaussage: Früh stoppen ist besser als spät fixen. Sunk Cost Fallacy ist real. Wenn’s nach dem ersten Block nicht passt → Stop. Nicht weitermachen.
Der Code Reflection Test schlägt fehl. Du siehst: Das passt nicht. Das sind nicht deine Requirements. Aber du hast schon 30 Minuten investiert. Die KI arbeitet schon. Code ist schon generiert. “Vielleicht wird’s noch besser.” “Lass sie mal weitermachen.” “Ich korrigiere das später.” Das ist Sunk Cost Fallacy.
“Ich glaube, das aufzuräumen, dauert länger als von vorne anzufangen. Und das ist genau, wo viele sagen: AI Coding lohnt sich nicht, weil ich habe am Ende in zwei Stunden einen Haufen Code produziert und eine Woche lang gesessen, das wieder zu fixen. App hätte ich in der Zeit aber selber geschrieben.”
Sunk Cost Fallacy ist ein kognitiver Bias. Du triffst Entscheidungen basierend auf bereits investierter Zeit, Geld oder Aufwand – statt basierend auf zukünftigen Kosten und Nutzen. “Ich habe schon 30 Minuten investiert, also muss ich weitermachen” ist Sunk Cost Fallacy. Die 30 Minuten sind weg. Egal ob du stoppst oder weitermachst. Die richtige Frage ist: Was kostet mich weitermachen ab jetzt? Wenn der Code fundamental falsch ist, kostet dich weitermachen exponentiell mehr als ein Neustart. Aber das Gehirn will die bereits investierte Zeit “nicht verschwenden” – also machst du weiter, obwohl stoppen die rational bessere Entscheidung wäre.
Code, der auf falschem Fundament aufbaut, wird nicht besser. Er wird schlimmer. Jede weitere Implementierung baut auf den falschen Annahmen auf. Multipliziert die Fehler. Macht das Chaos exponentiell größer. Nach einer Stunde ist der Code nicht “fast fertig”. Er ist “fundamental falsch”. Und fundamental falscher Code ist nicht reparierbar. Nicht ohne alles zu refactoren. Was länger dauert als Neustart. Early stopping ist besser als late fixing.
Die Stop Loss Triggers: Trigger 1 ist Code Reflection Test schlägt fehl (du erkennst deine Requirements nicht im Code → Stop. Sofort). Trigger 2 ist Patterns passen nicht (der Code folgt nicht den Patterns, die du definiert hast → Stop. Sofort). Trigger 3 ist du verstehst den Code nicht (du schaust auf den Code und verstehst nicht, was er tut → Stop. Sofort). Trigger 4 ist Bauchgefühl sagt Nein (etwas fühlt sich falsch an, du kannst es nicht greifen, aber es fühlt sich nicht richtig an → Stop. Validiere).
“Ich habe schon X Minuten investiert” ist kein Grund weiterzumachen. X investierte Minuten sind weg. Egal ob du stoppt oder weitermachst. Die Frage ist: Was kostet dich weitermachen? Wenn der Code fundamental falsch ist: Weitermachen bedeutet +2 Stunden Development + 1 Woche Cleanup = 1 Woche+ Zeitverlust. Stoppen bedeutet +15 Minuten Neustart + 2 Stunden Development (richtig) = 2.25 Stunden Zeitinvest. Früh stoppen spart Zeit. Nicht andersherum.
Schau dir den Unterschied an. Sunk Cost Fallacy (falsch): Code Reflection Test schlägt fehl. “Hmm, passt nicht. Aber ich habe schon 30 Minuten investiert. Lass sie mal weitermachen.” Die KI baut eine Stunde weiter. Du schaust nach einer Stunde rein: noch schlimmer. “Fuck. Jetzt muss ich aufräumen.” Du verbringst eine Woche mit Cleanup. Ergebnis: 1+ Woche verschwendet. Stop Loss Executed (richtig): Code Reflection Test schlägt fehl. “Stop. Das passt nicht. Wir starten neu.” Du analysierst: Was ist schiefgelaufen? Wo war das Missverständnis? Du klärst Requirements besser, validiert Verständnis. “Okay, jetzt nochmal. Mit klarerem Alignment.” Die KI baut neu, diesmal richtig. Ergebnis: 15 Minuten “Verlust” durch Neustart. Aber sauberer Code am Ende.
Du ignorierst Stop Loss, wenn du weitermachen lässt obwohl Code Reflection Test fehlschlägt, wenn du sagst “Ich fixe das später”, wenn du hoffst “Vielleicht wird’s noch”, oder wenn du an bereits investierte Zeit denkst statt an zukünftige Kosten.
Beim Manufacturing-Projekt: Ich habe mehrmals gestoppt. Nach dem ersten Code-Block: Patterns passten nicht. Stop. Geklärt. Neu gestartet. Nach Datenmodell: Eine Relation machte keinen Sinn. Stop. Diskutiert. Korrigiert. Jeder Stop: 10-15 Minuten “Verlust”. Aber verhindert hat es Stunden bis Tage an Cleanup. Gestoppt wird sofort. Nie aus Sunk Cost weitermachen. Bei der Finance-App: Nach dem ersten Output erkannt, das wird Müll. Aber nicht gestoppt. Eine Stunde weiter generieren lassen. Hoffnung. “Vielleicht wird’s noch.” Es wurde nicht. Am Ende: Alles weggeworfen. Zwei Stunden komplett verschwendet.
“Man muss das einmal gesehen haben, was dann passiert, zu verstehen, was es braucht, das zu verhindern.”
Definiere deine Stop Loss Triggers vor dem Projekt: Code Reflection Test schlägt fehl → Stop. Patterns nicht befolgt → Stop. Code nicht verständlich → Stop. Bauchgefühl sagt Nein → Stop & Validiere. Wenn ein Trigger greift: Stop die Generation (sofort, keine “noch schnell fertig machen”). Analysiere: Was ist schiefgelaufen? Kläre: Wo war das Missverständnis? Restart: Mit besserem Alignment. Nie weitermachen aus: Sunk Cost (“Ich habe schon X investiert”), Hoffnung (“Vielleicht wird’s noch”), oder Bequemlichkeit (“Neu starten ist anstrengend”).
Der frühe Stop ist nie verschwendet. Er spart dir Tage an Cleanup.
Stop Loss Rules. Enforce them. Always.
Der Prozess: Wie Patterns zusammenwirken
Du hast jetzt 13 Patterns gesehen. Jedes einzeln. Isoliert. Aber wie wirken sie zusammen? Wie sieht ein konkreter Prozess aus, der diese Patterns nutzt?
Das ist keine Formel. Kein “Schritt 1, 2, 3, fertig”. Jedes Projekt ist anders. Jeder Kontext erfordert andere Schwerpunkte. Aber es gibt eine sinnvolle Struktur. Vier Phasen, die sich als robust erwiesen haben.
Phase 1: Foundation – Verstehen, was du baust. Bevor Code fließt. Phase 2: Context Building – Shared understanding etablieren. Alignment herstellen. Phase 3: Implementation – Tasks schneiden. Code generieren. Validieren. Phase 4: Integration & Review – Zusammenführen. Testen. Refactoren.
Diese Phasen sind nicht strikt linear. Du wirst zwischen ihnen springen. Zurückgehen. Iterieren. Aber sie geben Struktur. Sie zeigen, wo welche Patterns wichtig sind. Und warum.
Wichtig: Du wirst zwischen den Phasen springen. Zurückgehen. Iterieren. Das ist eine Orientierung, kein Wasserfall. Ein Lernpfad. Ein Sicherheitsnetz, wenn’s schiefgeht.
Denk an Dark Souls: “Roll INTO the attack” ist kein strikter Prozess-Schritt. Aber es ist ein Pattern, das in bestimmten Situationen hilft. Nach 50 Stunden Spiel machst du es automatisch. Diese vier Phasen sind dasselbe. Nach fünf Projekten durchläufst du sie unbewusst. Aber am Anfang musst du sie bewusst praktizieren.
Los geht’s.
Phase 1: Foundation
Worum geht’s: Verstehen, was du baust. Bevor eine Zeile Code generiert wird.
Relevante Patterns: Pattern 1 (Scout Before You Prompt), Pattern 2 (Requirements ≠ Engineering), Pattern 5 (Starting Stats Test).
1. Scout. Bevor du auch nur ein Wort mit der KI wechselst: Schau dir an, was existiert. Bei bestehendem Code: Repo ziehen (GitHub Repo klonen, Projekt lokal öffnen). Code selbst durchschauen (Files öffnen, Struktur analysieren – keine KI, nur du und der Code). Eigene Meinung bilden (Wo sind Probleme? Was muss passieren? Was ist schon da?). Schreib Stichpunkte auf: “Business Logic im Frontend (Component X, Lines 45-120)”, “Keine Abstraktion im Data Access”, “Files zu groß (500+ lines)”. Bei neuem Projekt: Recherchiere ähnliche Projekte (Wie haben andere das gelöst? Welche Patterns sind üblich?). Skizziere grob (Was könnte funktionieren? Welche Architektur macht Sinn?). Sammle Referenzen (Screenshots, Docs, Beispiele – nicht für die KI, für dich). Ergebnis: Du hast eine Meinung. Einen Kompass. Bevor du mit der KI sprichst.
2. Define Architecture. Jetzt definierst du die Architektur. Nicht “die KI soll das machen”. Du. Datenmodell: Was sind die Core Entities? Nicht im Detail. Grob. Skizziere: User (id, email, passwordHash), Transaction (id, userId FK, amount, category, date), Category (id, name). Wie hängen sie zusammen? User ↔︎ Transactions (1:n), Transaction ↔︎ Category (n:1). Das reicht. Für den Anfang. Layer: Wie trennst du Concerns? Mindestens Data Access (Repository Pattern, Database Interaction), Business Logic (Service Layer, Domain Rules), Presentation (API oder Frontend, User Interaction). Vielleicht mehr, wenn’s komplexer ist. Aber mindestens diese drei. Patterns: Welche Patterns nutzt du konsistent? Beispiele: Repository Pattern für Data Access, Service Layer mit Dependency Injection, DTOs als Contracts zwischen API und Frontend, Result Pattern für Error Handling. Schreib es auf. Das sind deine Vorgaben. Tech Stack: Welche Tools nutzt du? Framework (z.B. React + TypeScript, .NET, Django), Database (z.B. PostgreSQL, MongoDB), State Management (z.B. Zustand, Redux, Context), Styling (z.B. Tailwind, CSS Modules). Du entscheidest. Nicht die KI. Ergebnis: Du hast Architektur-Vorgaben. Klar. Dokumentiert. Nicht interpretierbar.
3. Starting Stats Test. Jetzt kommt der erste Moment, wo die KI involviert wird. “Basierend auf diesen Requirements (die du jetzt erklärst): Erstelle mir ein Entity Relationship Diagram für dieses System.” Die KI erstellt ERM. Jetzt validierst du. Jede Entity. Jede Relation. Jedes Property. Validation Checklist: Entities (Fehlen wichtige Entities? Sind Entities sinnvoll benannt? Gibt es überflüssige Entities?), Relationen (Sind Relationen korrekt modelliert – 1:1, 1:n, n:m? Machen sie Sinn für die Use Cases? Fehlen wichtige Relationen?), Properties (Sind Properties sinnvoll benannt und getypt? Fehlen kritische Properties? Gibt es redundante Properties?), Normalisierung (Stimmt die Normalisierung? Ist das Schema wartbar? Performance OK?). Wenn was nicht passt: “Warum hast du Categories als separate Tabelle statt als Enum?” Die KI erklärt. “Nein, das passt nicht. Wir haben nur 5 fixe Categories. Enum ist besser. Ändere das.” Die KI ändert. Du schaust nochmal drauf. Iteriere, bis das Schema stimmt.
Checkpoint: Phase 1 Complete. Du weißt jetzt: Was existiert (Scout), Welche Architektur du nutzt (Architecture Definition), Wie das Datenmodell aussieht (Starting Stats Test), Welche Patterns du einsetzt (Tech Decisions). Erst jetzt – wirklich erst jetzt – gehst du zu Phase 2. Ohne solides Fundament wird alles, was darauf aufbaut, wacklig. Check your Starting Stats. Before the run begins.
Phase 2: Context Building
Worum geht’s: Shared understanding etablieren. Alignment herstellen. Context persistent machen.
Relevante Patterns: Pattern 3 (Sokrates, nicht Befehl), Pattern 4 (Kontext ist König), Pattern 6 (Eine Rolle zur Zeit), Pattern 11 (Verständnis-Validierung).
1. Shared Context aufbauen. Jetzt hast du Foundation. Datenmodell steht. Architektur ist klar. Aber die KI weiß das nur aus diesem einen Gespräch. Wenn du 10 Prompts später bist, ist der Context weg. Du musst Context aktiv bauen und pflegen. Diskutiere Requirements – nicht nur “hier ist, was ich will”, sondern Dialog. “Wir bauen eine Finance-App. User sollen Transaktionen tracken können. Kategorien zuweisen. Monthly Reports sehen. Was würdest du als Core Features sehen?” Die KI schlägt Features vor. “Gut. Aber Password Reset brauchen wir nicht in V1. Und statt dynamischer Categories nutzen wir fixe.” Ihr spielt Pingpong. Diskutiert. Vertieft.
Alignment Check nach jeder wichtigen Diskussion: “Fasse zusammen, was wir gerade definiert haben.” Die KI: “Wir bauen Finance-App mit Transaction Tracking (date, amount, category, description), Fixe Categories (Food, Rent, Transport, Utilities), Monthly Reports (Summen pro Kategorie), Keine Authentication in V1.” Du liest, siehst: “Moment, wir brauchen schon Auth. Nur kein Password Reset.” “Fast richtig. Aber wir brauchen Authentication. Login/Register. Nur kein Password Reset in V1.” Die KI: “Verstanden. Korrigiere: Mit Authentication (Login/Register), aber ohne Password Reset in V1.” “Korrekt.” Das dauert 2 Minuten. Verhindert 2 Stunden verschwendeter Development.
Externalisiere wichtigen Context – schreibe wichtige Entscheidungen in Files:
ARCHITECTURE.md:
# Architektur## Layer- Data Access: Repository Pattern - Business Logic: Service Layer mit DI - API: REST Endpoints mit DTOs - Frontend: React + TypeScript + Zustand ## Patterns- Repository Pattern für alle Entities - Service Layer für Business Logic - DTOs als API Contracts - Result<T> für Error Handling ## Data FlowRequest → API → Service → Repository → Database
REQUIREMENTS.md:
# Requirements V1## Core Features- User Authentication (Login/Register, keine Password Reset) - Transaction Tracking (date, amount, category, description) - Categories (Food, Rent, Transport, Utilities) - fixe Werte - Monthly Reports (Summen pro Kategorie) ## Out of Scope V1- Password Reset - OAuth Integration - Recurring Transactions
DECISIONS.md:
# Tech Decisions- Framework: React 18 + TypeScript - State: Zustand (nicht Redux - zu overhead für V1) - Styling: Tailwind CSS - Database: PostgreSQL - Backend: Node.js + Express - Auth: JWT (nicht Session-based)
In späteren Prompts referenzierst du darauf: “Wie in ARCHITECTURE.md definiert, nutzen wir Repository Pattern.” Context ist jetzt persistent. Referenzierbar. Konsistent.
2. Rollen orchestrieren. Die KI ist nicht gleichzeitig Business Analyst, Architekt, Tech Lead und Developer. Du orchestrierst die Rollen sequentiell. Rolle 1 (Business Analysis – Du): Was ist das Problem? Was muss gebaut werden? Du machst das. Nicht die KI. Du verstehst den Business Case. Du definierst Requirements. Du schreibst User Stories. Beispiel: “User Story 1: User Registration. Als neuer User will ich mich registrieren können, damit ich meine Transaktionen tracken kann. Acceptance Criteria: Email + Password Registration, Password min 8 chars, Email Validation, User wird nach Registration automatisch eingeloggt.”
Rolle 2 (Architecture – Du + KI): Wie sollten wir das strukturieren? Jetzt diskutierst du mit der KI: “Basierend auf diesen Requirements, wie würdest du die Architektur vorschlagen?” Die KI: “Ich würde vorschlagen: UserService mit register() Method, UserRepository für DB Access, JWT für Auth…” “Gut. Aber statt separatem UserService integrieren wir das in AuthService. User Management später separat.” Ihr findet gemeinsam die Struktur. Aber du entscheidest final.
Rolle 3 (Tech Decisions – Du): Welche Tools nutzen wir? Du sagst: “Wir nutzen bcrypt für Password Hashing. JWT mit 24h Expiry. AccessToken + RefreshToken Pattern.” Nicht diskutieren. Ansagen. Das sind deine Vorgaben.
Rolle 4 (Implementation – KI): Jetzt darfst du sagen: “Bau das.” Aber mit allen Vorgaben. Mit allem Context. Mit klaren Erwartungen. “Erstelle AuthService mit register() Method. Input: email, password. Pattern: Service Layer wie in ARCHITECTURE.md. Dependencies: UserRepository (erstelle ich im nächsten Step). Tech: bcrypt Salt Rounds 12, Returns JWT Token. Expected Output:
{ token: string, user: UserDTO }.” Die KI implementiert innerhalb des Rahmens. Keine Interpretation. Keine Freiheitsgrade.Rolle 5 (Review – Du): Nach Implementation: Du reviewst. Validierst. Gibst Feedback. Nicht alles der KI überlassen. Rolle für Rolle.
Checkpoint: Phase 2 Complete. Du hast jetzt: Shared Context etabliert (ARCHITECTURE.md, REQUIREMENTS.md, DECISIONS.md), Alignment validiert (“Was hast du verstanden?”), Rollen klar getrennt (nicht alles auf einmal). Context ist persistent. Alignment ist klar. Rollen sind orchestriert. Jetzt kannst du zu Phase 3: Implementation.
Phase 3: Implementation
Worum geht’s: Tasks schneiden. Code generieren. Validieren. Iterieren.
Relevante Patterns: Pattern 7 (User Story Level), Pattern 8 (Sequencing & Dependencies), Pattern 9 (Reduce Undefined States), Pattern 10 (Erwartungen vor Code), Pattern 12 (Code Reflection Test), Pattern 13 (Stop Loss Rules).
1. Tasks schneiden. Du hast Requirements. Du hast Architektur. Du hast Context. Jetzt zerlegt du Features in Tasks. Von Epic zu User Stories zu Tasks: Epic ist “User Authentication System”. User Stories: User kann sich registrieren, User kann sich einloggen, User kann sich ausloggen, System validiert Login-Status. Tasks für Story 1 (User Registration): Task 1.1 ist Erstelle User Entity (Properties: id, email, passwordHash, createdAt, Validation Rules definieren). Task 1.2 ist Erstelle UserRepository (CRUD Operations, Verwendet User Entity, findByEmail() Method). Task 1.3 ist Erstelle AuthService.register() (Input: email, password, Hasht Password mit bcrypt, Erstellt User via Repository, Returned JWT Token). Task 1.4 ist Erstelle /api/auth/register Endpoint (Nutzt AuthService, Returned UserDTO + Token, Error Handling). Task 1.5 ist Erstelle RegisterForm Component (Email + Password Inputs, Validation, Calls /api/auth/register, Redirects nach Success). Jede Task: 1-2 Stunden. Klar. Definiert. Schätzbar.
2. Sequencing festlegen. Leg die Reihenfolge fest. Bottom-Up. Sequence für User Registration: User Entity (Foundation), UserRepository (Data Access), AuthService (Business Logic), API Endpoint (API Layer), RegisterForm (Frontend). Jede Stufe baut auf der vorherigen auf. Nicht: “Bau mir Registration komplett” (Vertical Slice = Chaos). Sondern: Layer für Layer. Validiert. Approved.
3. Task-by-Task Implementation. Für jeden Task:
A) Definiere Erwartungen. Task: Erstelle AuthService.register(). Input:
{ email: string, password: string }
Problem: User Registration mit Email + Password. Password muss gehasht werden. User in DB speichern. JWT zurückgeben. Expected Output:
{ success: true, data: { token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", user: { id: "uuid", email: "[email protected]", createdAt: "2025-11-09T10:00:00Z" } } }
Pattern: Service Layer wie in ARCHITECTURE.md. Dependency Injection. bcrypt Salt Rounds 12. JWT Secret aus ENV. Dependencies: UserRepository (bereits implementiert in vorherigem Task).
B) Lass generieren. Du gibst Task mit allen Erwartungen. Die KI generiert Code. Nicht 5 Tasks auf einmal. Einer. Zur Zeit.
C) Code Reflection Test. Sofort nach Code-Generation: Öffne die Files. Scan 1 (Alignment): Erkenne ich meine Requirements? Sehe ich register() mit erwartetem Input/Output? Ist bcrypt verwendet? Scan 2 (Patterns): Folgt es dem Service Pattern? Dependency Injection korrekt? Error Handling wie erwartet? Scan 3 (Structure): Ist der Code clean? Verstehe ich die Logik? Ist er wartbar? Wenn alles ✓: Weiter zu D). Wenn irgendwas ✗: STOP. Trigger Stop Loss.
D) Validiere. Teste den Code. Funktioniert er? Schreibe Unit Test (oder lass KI schreiben), Führe Test aus, Passt das Ergebnis zu Expected Output? Wenn ✓: Task complete. Nächster Task. Wenn ✗: Debugge. Fixe. Re-Test.
4. Stop Loss Rules enforced. Trigger 1 (Code Reflection Test schlägt fehl): Du erkennst Requirements nicht im Code → STOP. Analysiere. Kläre. Neu. Trigger 2 (Du verstehst den Code nicht): Du schaust rein und denkst “Was macht das?” → STOP. Frage KI: “Erkläre diesen Code.” Wenn Erklärung nicht passt → Neu. Trigger 3 (Test schlägt fehl und du weißt nicht warum): Test ist rot. Du debuggst. Es wird nicht klarer → STOP. Frage KI: “Warum schlägt dieser Test fehl?” Analysiere. Wenn fundamental falsch → Neu. Trigger 4 (Bauchgefühl): Etwas fühlt sich falsch an → STOP. Validiere. Trust your gut.
5. Iteration. Manche Tasks brauchen Iteration. Task: AuthService.register(). Erster Versuch: Code generiert. Code Reflection Test: ✗ Password Validation fehlt. “STOP. Password Validation fehlt. Requirements waren: min 8 chars, 1 uppercase, 1 number. Füge Validation hinzu.” Die KI fügt hinzu. Code Reflection Test nochmal → ✓. Task complete. Das ist normal. Erwarte nicht Perfektion beim ersten Versuch. Aber: Wenn du 5x iterierst und es passt immer noch nicht → Das ist ein Stop Loss Trigger. Dann ist etwas fundamental falsch. Nicht iterieren. Analysieren, was schiefläuft. Neu starten mit besserem Alignment.
Checkpoint: Phase 3 Complete. Du hast jetzt: Alle Tasks geschnitten (User Story Level), Sequence festgelegt (Bottom-Up), Task-by-Task implementiert (mit Validation), Code Reflection Tests gemacht (nach jedem Block), Stop Loss Rules enforced (früh gestoppt bei Problemen). Layer sind gebaut. Jeder Layer validiert. Code ist clean. Jetzt: Phase 4. Integration.
Phase 4: Integration & Review
Worum geht’s: Layer zusammenführen. End-to-End testen. Code reviewen. Refactoren wo nötig.
1. Integration Testing. Die Layer sind gebaut. Jeder für sich validiert. Jetzt: Zusammenführen. End-to-End Flow testen. Feature: User Registration. Flow: User öffnet RegisterForm, Gibt Email + Password ein, Form validiert Input, Calls /api/auth/register, API Endpoint calls AuthService.register(), AuthService calls UserRepository.create(), Repository speichert in DB, AuthService generiert JWT, API returned Token + UserDTO, Frontend speichert Token, User wird zu Dashboard redirected.
Test den ganzen Flow: Manuell (Öffne App, Registriere User, Funktioniert?), Integration Test:
test('User Registration Flow', async () => { const response = await api.post('/auth/register', { email: '[email protected]', password: 'Test1234' }); expect(response.status).toBe(200); expect(response.data.token).toBeDefined(); expect(response.data.user.email).toBe('[email protected]'); // Verify user in DB const user = await db.users.findByEmail('[email protected]'); expect(user).toBeDefined(); expect(user.passwordHash).not.toBe('Test1234'); // hashed});
Fehler finden: Passen Interfaces? Sind Daten konsistent? Error Handling funktioniert?
Häufige Integration-Probleme: Problem 1 (DTO Mismatch) – Frontend erwartet
{ userId: string, email: string }, API returned { id: string, email: string }. Fix: Align DTOs. Entweder Frontend anpassen oder API. Problem 2 (Error Handling Inkonsistenz) – Service wirft Error, API catched nicht, Frontend bekommt 500 statt 400. Fix: Error Handling Layer-übergreifend konsistent machen. Problem 3 (State Management funktioniert nicht) – Frontend speichert Token, Refresh → Token weg. Fix: localStorage persistence fehlte, Hinzufügen.2. Code Review. Jetzt schaust du über den ganzen Code. Nicht nur einzelne Tasks. Review-Checklist: Konsistenz (Folgen alle Layer denselben Patterns? Sind Naming Conventions konsistent? Ist Error Handling überall gleich?), Clean Code (Sind Functions klein und fokussiert? Sind Names aussagekräftig? Gibt es Code Duplication?), Wartbarkeit (Verstehe ich den Code in 6 Monaten noch? Kann ein neuer Developer sich zurechtfinden? Ist der Code testbar?), Performance (Gibt es offensichtliche Performance-Probleme? N+1 Queries? Unnötige Re-Renders?), Security (Passwords gehasht? SQL Injection verhindert? XSS verhindert? CSRF Protection?).
Was du suchst: Inkonsistente Patterns – File A nutzt
async register(data: RegisterDTO): Promise<User>, File B nutzt register(data: RegisterDTO): Result<User>. Fix: Entscheide für eines. Mache konsistent. Code Duplication – Validation Logic in 3 verschiedenen Files kopiert. Fix: Extrahiere in ValidationService. Reuse. Unclear Names – function doStuff(x: any): any. Fix: Benenne um zu calculateMonthlyTotal(transactions: Transaction[]): number.3. Refactoring. Basierend auf Review: Refactore. Aber: Nur wenn es Sinn macht. Refactoring ist nicht “Lass uns alles schöner machen”, “Ich würde das anders implementieren”, oder Bikeshedding. Refactoring ist: Inkonsistenzen eliminieren, Duplication entfernen, Wartbarkeit verbessern, Performance-Probleme fixen. Refactoring-Tasks: “Extrahiere Validation Logic in ValidationService”, “Mache Error Handling konsistent (überall Result Pattern)”, “Benenne Functions um für bessere Klarheit”. Jedes Refactoring ist ein Task. Mit Erwartungen. Mit Validation. Nicht: “Refactor alles mal” (Das ist ein Epic).
4. Documentation. Jetzt, wo alles funktioniert: Dokumentiere. Was dokumentiert werden sollte: README.md (Was macht die App? Wie starte ich sie? Welche ENV Variablen brauche ich?), ARCHITECTURE.md (Layer-Struktur, Patterns, Data Flow, Wichtige Design Decisions), API.md (Endpoints, Request/Response Formats, Error Codes, Examples), Inline Comments (Nur wo Code nicht selbsterklärend ist, “Warum” nicht “Was”, Business Rules dokumentieren). Was NICHT dokumentiert werden sollte: Offensichtlicher Code, Implementation Details die sich ändern werden, TODOs (die gehören in Issues).
Checkpoint: Phase 4 Complete. Du hast jetzt: End-to-End Flow getestet, Integration-Probleme gefixed, Code reviewed (Konsistenz, Clean Code, Wartbarkeit), Refactored wo sinnvoll, Dokumentiert. Feature ist done. Code ist clean. System ist stabil.
Der Loop beginnt von vorne. Nächstes Feature? Zurück zu Phase 1. Nicht komplett neu. Du hast jetzt: Bestehendes Datenmodell (erweitern, nicht neu aufsetzen), Bestehende Patterns (weiter nutzen), Bestehenden Context (referenzieren). Aber der Prozess bleibt: Foundation (Was wird gebaut?), Context Building (Alignment herstellen), Implementation (Task-by-Task), Integration & Review (Zusammenführen). Iterativ. Immer wieder. Nach 3-5 Features: Der Prozess wird unbewusst. Du machst es automatisch. Dann hast du unbewusste Kompetenz erreicht. Das ist das Ziel.
Case Study: Manufacturing Projekt
Das Setting: Produktionsreifes System für eine industrielle Anlage. Komplexe Prozesse. Produktionsspezifikationen. Qualitätssicherung. Bestehendes Projekt, das jemand anders mit Web-based Tools erstellt hatte. Meine Aufgabe: Produktionsreif machen. Refactoring. Stabilisierung. Deployment-Ready. Nicht von Grund auf neu. Sondern: Cleanup eines bestehenden Systems.
Ergebnis: Nach drei Wochen produktionsreif. Sauberer Code. Funktionierende Tests. Deployment auf Produktion. System läuft stabil.
Was ich richtig gemacht habe.
Phase 1: Foundation. Scout First – Ich habe nicht blind angefangen. Ich habe das GitHub Repo gezogen. Code selbst durchgeschaut. Files geöffnet. Struktur analysiert. Ich habe gesehen: Business Logic vermischt mit Frontend Code, Keine Abstraktion im Data Access Layer, Zu viel Code in einzelnen Files (500+ lines), Fehlende Separation of Concerns. Ich wusste bereits, wo’s brennt. Bevor ich ein Wort mit der KI gewechselt habe.
Finger auf die Wunde (Sokrates) – Ich habe nicht gesagt: “Mach das besser.” Ich habe gesagt: “Analysiere mir detailliert dieses Projekt. Achte auf Clean Code, achte auf Patterns, achte auf Abstraktion. Zeig mir, wo die strukturellen Probleme liegen.” Die KI analysiert. Findet Probleme. Ich sehe: Sie hat verstanden, worauf ich schaue. Dann: Diskussion. “Warum ist das hier ein Problem?” “Wie würdest du das lösen?” Pingpong spielen. Tiefer bohren.
Starting Stats Test – Bestehendes Datenmodell analysiert. Mit KI durchgesprochen: “Ist dieses Schema sinnvoll? Welche Probleme siehst du?” Wir haben validiert: Entities OK. Relationen OK. Properties größtenteils OK, ein paar Anpassungen nötig. Schema war solide. Guter Start.
Phase 2: Context Building. Kontext als Fundament – Wir haben nicht direkt Code generiert. Wir haben Kontext gebaut. Probleme wurden besprochen. Alignment Checks gemacht: “Ich habe verstanden, dass Component X das und das tut, korrekt?” Wichtige Themen wurden in .md Files festgehalten: ARCHITECTURE.md (Layer-Struktur, Patterns, Data Flow), PATTERNS.md (Repository Pattern, Service Layer, DI), REQUIREMENTS.md (Business Rules aus Meetings mit Kunde). PDFs mit Produktionsspezifikationen wurden integriert. Referenziert. Teil des Contexts gemacht.
Engineering-Ebene Definition – Nicht nur: “Die Business Logic muss raus.” Sondern: “Wir extrahieren in einen Service Layer, weil Business Logic nicht im Frontend sein sollte. Das macht Testing schwer, macht Wartung komplex, verletzt Single Responsibility. Wir nutzen Service Pattern mit Dependency Injection. Data Access wird in Repository abstrahiert mit klarem Interface.” Engineering-Sprache. Patterns. Begründungen.
Phase 3: Implementation. User Story Sizing – Keine Epics. Keine “Refactor das ganze System”-Tasks. Sondern: “Erstelle Repository Layer für Entity ProductionOrder mit CRUD Operations”, “Extrahiere Business Logic aus ProductionOrderComponent in ProductionOrderService”, “Refactor Data Access in MaterialComponent nach Repository Pattern”. Jede Task: 1-2 Stunden. Klar. Definiert. Schätzbar.
Sequencing Bottom-Up – Nicht alles gleichzeitig. Sequence: Erst Repository Layer. Für alle Core Entities. Validiert. Funktioniert. Dann Service Layer. Business Logic extrahiert. Getestet. Clean. Dann Frontend Refactoring. Components nutzen Services. Keine Business Logic mehr im Frontend. Keine Durchstiche. Bottom-Up. Layer für Layer.
Code Reflection Test nach jedem Block – Nach jedem generierten Code-Block: Erkenne ich Requirements? Folgt es den Patterns? Verstehe ich die Logik? Mehrmals gestoppt: Beispiel: Repository für MaterialSpecification generiert. Code Reflection Test: ✗ Interface passt nicht zum Rest. STOP. “Warum nutzt du hier anderes Interface-Pattern als bei ProductionOrder Repository?” Korrigiert. Nochmal. ✓. Das hat verhindert, dass Inkonsistenzen sich ausbreiten.
Phase 4: Integration & Review. End-to-End Testing – Alle Layer zusammengeführt. End-to-End Flows getestet: ProductionOrder erstellen → Service → Repository → DB ✓, MaterialSpecification laden → Display im Frontend ✓, QualityCheck durchführen → Results speichern ✓. Paar Integration-Probleme gefunden: DTO Mismatch zwischen API und Frontend, Error Handling nicht konsistent. Gefixed. Re-Test. ✓.
Code Review & Refactoring – Über ganzen Code geschaut: Patterns konsistent? Größtenteils ja. Naming konsistent? Ein paar Anpassungen nötig. Code Duplication? Validation Logic 3x kopiert → in ValidationService extrahiert. Refactoring-Tasks geschnitten. Einzeln abgearbeitet. Validiert.
Warum es funktioniert hat. Disziplin – Ich habe den Prozess durchgezogen. Alle vier Phasen. Strukturiert. Auch bei “kleinen” Tasks. Kein “Das muss nicht so formal sein.” Kein “Ich kann Abkürzungen nehmen.” Prozess. Immer. Validation an jedem Checkpoint – Nach Requirements-Diskussion: “Was hast du verstanden?” Nach Datenmodell: “Zeig mir das Schema.” Nach jedem Code-Block: Code Reflection Test. Nach Integration: End-to-End Tests. Früh validiert. Früh korrigiert. Nie zu spät gemerkt. Stop Loss enforced – Mehrmals gestoppt, wenn Code nicht passte. Nie aus Sunk Cost weitergemacht. 15 Minuten “Verlust” durch Neustart. Aber verhindert hat es Tage an Cleanup.
Das Ergebnis. Nach drei Wochen: Produktionsreifer Code, Clean Architecture (Repository, Service, Components getrennt), Funktionierende Tests, Deployment auf Produktion, System läuft stabil. Der Client war happy. Das Team war happy. Ich war happy. Das ist, wie AI-Coding aussieht, wenn man’s richtig macht.
Case Study: Finance App
Das Setting: Privates Projekt. Finance-Tracking. Simpel. Kategorien. Transaktionen. Budgets. Monatliche Reports. Ich wollte meine Excel-Tabelle loswerden.
Ergebnis: Nach zwei Stunden Code generiert. Komplett unbrauchbar. Alles weggeworfen.
Was ich falsch gemacht habe.
Phase 1: Foundation – ÜBERSPRUNGEN. Kein Scout. Keine Engineering-Ebene. Ich habe gesagt was ich will, aber nicht wie es engineered werden soll. Kein Datenmodell. Keine Layer-Architektur. Keine Patterns. “Mach’s besser als Excel” war meine einzige Vorgabe. Kein Starting Stats Test. Keine Schema-Validierung. Die KI sollte alles selbst herausfinden. Blind.
Phase 2: Context Building – ÜBERSPRUNGEN. Alle Rollen gleichzeitig (Business Analyst + Architect + Tech Lead + Developer). Keine Verständnis-Validierung. Ich habe auf meine Excel referenziert und angenommen, das wurde verstanden. Kein Alignment Check. Kein persistenter Context. Keine .md Files. Context war flüchtig. Weg nach 10 Minuten.
Phase 3: Implementation – CHAOTISCH. Epic-Level Prompt: “Bau mir die App.” Kein User Story Level. Keine Tasks. Keine Sequence. Die KI sollte einen vertikalen Durchstich machen – alles gleichzeitig. Datenbank, Business Logic, API, Frontend in einem großen Batch. Nach dem ersten Code-Block war klar: Das wird Müll. Aber ich habe nicht gestoppt. Ich habe aus Sunk Cost weitergemacht (Pattern 13). Eine Stunde später: Noch schlimmer. Klassischer Fehler.
Phase 4: Integration & Review – GAB ES NICHT. Warum? Weil der Code fundamental falsch war. Zwei Stunden Entwicklung. Alles unbrauchbar. Aufräumen würde länger dauern als von vorne anfangen. Abort Mission.
Die Lektion.
“Man muss das einmal gesehen haben, was dann passiert, zu verstehen, was es braucht, das zu verhindern.”
Ich musste sehen, wie exponentiell der Zusammenhang ist zwischen Prozess-Disziplin und Code-Qualität. Ein bisschen weniger Prozess? Deutlich mehr Chaos. Viel weniger Prozess? Komplettes Disaster.
Der Unterschied zwischen Manufacturing und Finance App: Nicht Komplexität. Nicht Fähigkeiten. Der Prozess. Bei Manufacturing: Alle vier Phasen. Alle Patterns befolgt. Alle Checkpoints gemacht. Bei Finance App: Phase 1 übersprungen. Phase 2 ignoriert. Direkt zu Phase 3.
Was ich daraus gelernt habe. Es gibt keine Abkürzungen. Auch für das kleinste Projekt. Der Prozess ist nicht optional. Er ist fundamental. Der Minimal Viable Process dauert vielleicht 30 Minuten extra. Aber er verhindert zwei Stunden verschwendete Development-Zeit. Oder eine Woche Cleanup. Die 30 Minuten sind die beste Investition. Ich habe das auf die harte Tour gelernt. Du musst das nicht.
Follow the process. Always.
Pattern Cheatsheet: Quick Reference
Diese Cheatsheet ist deine Schnellreferenz. Nicht zum Auswendiglernen. Zum Nachschlagen, wenn du unsicher bist.
Pattern 1: Scout Before You Prompt – Wann: Bevor du mit der KI sprichst. Was: Schau dir Code/Projekt selbst an. Bilde eigene Meinung. Warnsignal: Du fragst KI “Was soll ich bauen?” statt “Wie baue ich X?”
Pattern 2: Requirements ≠ Engineering – Wann: Vor jeder Implementation. Was: Definiere nicht nur WAS, sondern WIE: Datenmodell, Layer, Patterns, Tech Stack. Warnsignal: Du sagst “was” aber nicht “wie es strukturiert sein soll”
Pattern 3: Sokrates, nicht Befehl – Wann: In jedem Dialog mit KI. Was: Führe Dialog. Stelle Fragen. Verstehe Perspektive der KI. Warnsignal: Du gibst nur Befehle, stellst keine Fragen
Pattern 4: Kontext ist König – Wann: Nach wichtigen Diskussionen. Was: Alignment Check → Externalisierung in .md Files → Referenzierung. Warnsignal: KI trifft Entscheidungen, die früheren Entscheidungen widersprechen
Pattern 5: Starting Stats Test – Wann: Vor erster Zeile Feature-Code. Was: Datenbankschema validieren. Jede Entity, Relation, Property durchgehen. Warnsignal: Du beginnst mit Features ohne Schema validiert zu haben
Pattern 6: Eine Rolle zur Zeit – Wann: Bei Task-Definition. Was: Orchestriere Rollen sequentiell: Business Analysis → Architecture → Tech Decisions → Implementation → Review. Warnsignal: Du erwartest, dass KI “alles versteht” aus einem Prompt
Pattern 7: User Story Level – Wann: Beim Task-Schneiden. Was: Breche Epics runter. Jede Task: klar, schätzbar, 1-2h Implementation. Warnsignal: Task würde >2h brauchen oder Scope ist schwammig
Pattern 8: Sequencing & Dependencies – Wann: Vor Implementation. Was: Definiere Build-Sequence. Bottom-Up: Foundation → Data → Business Logic → API → Frontend. Warnsignal: Du versuchst vertikalen Durchstich (alles Layer auf einmal)
Pattern 9: Reduce Undefined States – Wann: Bei jedem Prompt. Was: Eliminate Ambiguity. Pattern? Problem? Wie? Wann? Warum? Alles definiert. Warnsignal: KI könnte das unterschiedlich interpretieren
Pattern 10: Erwartungen vor Code – Wann: Vor jedem Task. Was: Definiere Input, Problem, Ziel, Expected Output, Pattern, Dependencies. Warnsignal: Du kannst nicht beschreiben, wie Output aussehen soll
Pattern 11: Verständnis-Validierung – Wann: Nach jeder wichtigen Diskussion. Was: “Fasse zusammen, was du verstanden hast.” → Review → Korrigiere. Warnsignal: Du hoffst, dass “es klar sein sollte”
Pattern 12: Code Reflection Test – Wann: Nach jedem Code-Block. Was: 3 Scans: Alignment (Requirements erkennbar?), Patterns (befolgt?), Structure (verständlich?). Warnsignal: Du schaust nicht in generierten Code oder hoffst “es passt schon”
Pattern 13: Stop Loss Rules – Wann: Wenn Code Reflection Test fehlschlägt. Was: STOP. Sofort. Nicht weitermachen aus Sunk Cost. Analysiere → Kläre → Neu. Warnsignal: Du denkst “Ich hab schon X investiert, lass sie weitermachen”
Der 4-Phasen-Prozess. Phase 1 (Foundation): Scout (eigene Meinung bilden), Define Architecture (Datenmodell/Layer/Patterns/Tech Stack), Starting Stats Test (Schema validieren). Phase 2 (Context Building): Shared Context (Alignment Checks, Externalisierung), Rollen orchestrieren (sequentiell, nicht parallel). Phase 3 (Implementation): Tasks schneiden (User Story Level), Sequencing festlegen (Bottom-Up), Task-by-Task (Erwartungen → Generieren → Code Reflection Test → Validieren), Stop Loss enforced (bei ersten Warnsignalen stoppen). Phase 4 (Integration & Review): End-to-End Testing, Code Review (Konsistenz/Clean Code/Wartbarkeit), Refactoring (wo sinnvoll).
Häufigste Fehler & Fixes:
| Fehler | Fix |
|——–|—–|
| “Bau mir die App” | Schneide Tasks. User Story Level. |
| Code passt nicht, aber weitermachen | STOP. Stop Loss. Neu starten. |
| KI versteht anders als gemeint | Verständnis-Validierung: “Was hast du verstanden?” |
| Inkonsistente Patterns über Layer | Definiere Patterns in ARCHITECTURE.md. Referenziere. |
| Schema macht nach 2h keinen Sinn | Starting Stats Test VOR Features. |
| Context ist nach 10 Prompts weg | Externalisiere in .md Files. |
| Vertikaler Durchstich = Chaos | Bottom-Up Sequencing. Layer für Layer. |
Quick Decision Tree. Bevor du beginnst: Hast du eigene Meinung? (Scout) ✓, Hast du Datenmodell definiert? (Engineering-Ebene) ✓, Hast du Schema validiert? (Starting Stats) ✓. Bevor du Code generieren lässt: Sind Tasks User Story Level? ✓, Ist Sequence klar? (Bottom-Up) ✓, Sind Erwartungen definiert? (Input/Output/Pattern) ✓, Ist Context persistent? (ARCHITECTURE.md etc.) ✓. Nach Code-Generation: Code Reflection Test gemacht? ✓, Bei Problemen gestoppt? (Stop Loss) ✓, Verständnis validiert? ✓
Remember. Diese Patterns sind keine Checkliste. Sie sind Meta-Prinzipien. Du wirst zwischen ihnen springen. Manche wichtiger als andere je nach Situation. Nach 5 Projekten: Du machst sie unbewusst. Aber am Anfang: Bewusst praktizieren. Bis sie Muskelgedächtnis werden. Genau wie bei Dark Souls. Git gud.
Git Gud
AI-Coding ist nicht die Zukunft. Es ist die Gegenwart. Ich sehe es täglich. Entwickler, die 10x produktiver sind als vor einem Jahr. Systeme, die in Wochen gebaut werden statt Monaten. Legacy-Code, der refactored wird in Tagen statt Quartalen. Das ist keine Hype. Das ist Realität. Aber nur, wenn man es richtig macht.
Warum das wichtig ist. Entwickler, die AI-Coding ignorieren, werden nicht verschwinden. Aber sie werden weniger produktiv sein. Deutlich weniger. Das ist nicht wie früher, als neue Tools langsam adoptiert wurden. Als IDEs Jahre brauchten, um Standard zu werden. Als Git langsam CVS und SVN verdrängte. AI-Coding verändert Produktivität um Größenordnungen. Nicht um Prozente. Aber – und das ist das große Aber – nur wenn man weiß, wie. Die meisten Leute kämpfen. Sie produzieren Müll. Sie verbringen mehr Zeit mit Aufräumen als mit Bauen. Und dann sagen sie: “AI-Coding funktioniert nicht.” Sie haben recht. Für sie funktioniert es nicht. Weil sie versuchen, es wie normales Coding zu machen. Weil sie keine Patterns haben. Keinen Prozess. Keine Disziplin.
Die unbequeme Wahrheit: Es gibt keinen Silver Bullet. Du wirst keine 10-Punkte-Checkliste finden, die dich zum AI-Coding-Experten macht. Keinen Prompt, der immer funktioniert. Keine Formel für Erfolg. Genau wie bei Dark Souls: “Roll INTO the attack” ist kein Cheat Code. Aber es ist ein Pattern, das dein Lernen fokussiert. “Don’t get greedy with hits” ist keine Garantie fürs Überleben. Aber es ist ein Prinzip, das hilft. Du musst trotzdem sterben. Lernen. Iterieren. AI-Coding ist identisch. Die 13 Patterns, die ich dir gezeigt habe? Das sind keine Regeln. Das sind Meta-Prinzipien. Sie fokussieren deinen Trial-and-Error. Sie beschleunigen dein Lernen. Aber du musst trotzdem die Arbeit machen. Du musst Fehler machen. Du musst sehen, was passiert, wenn du vom Prozess abweichst. Du musst deine eigene Intuition entwickeln. Das dauert. Das ist unbequem. Das ist nicht, was Leute hören wollen. Leute wollen den Shortcut. Den Hack. Die magische Prompt-Formel. Es gibt sie nicht.
Was du jetzt tun kannst.
1. Akzeptiere die Realität. Wenn AI-Coding bei dir nicht funktioniert: Das Problem bist du. Nicht deine Fähigkeiten als Developer. Die sind vermutlich gut. Sonst würdest du das hier nicht lesen. Sondern dein Ansatz. Dein Prozess. Deine fehlenden Patterns. Das ist gut. Weil du deinen Ansatz ändern kannst. Du kannst Patterns lernen. Du kannst einen Prozess aufbauen. Du bist nicht festgelegt. Du kannst wachsen.
2. Mach eine Retrospektive. Schau dir deine letzten drei AI-Coding Sessions an. Was lief gut? Wann hat’s funktioniert? Was hast du da richtig gemacht? Was lief schlecht? Wann hast du Müll produziert? Welche Patterns hast du missachtet? Schreib es auf. Mach es bewusst. Analysiere. Das ist, wie Lernen funktioniert. Nicht durch Theorie. Durch Reflexion über Praxis.
3. Experimentiere mit dem Prozess. Nimm ein kleines Projekt. Etwas Echtes. Nicht ein Tutorial. Etwas, das du tatsächlich nutzen wirst. Geh bewusst durch die vier Phasen: Phase 1 (Foundation): Scout (schau dir an, was existiert oder wie andere es gelöst haben), Define Architecture (Datenmodell/Layer/Patterns/Tech Stack), Starting Stats Test (validiere Schema bevor du Code schreibst). Phase 2 (Context Building): Shared Context (diskutiere, Alignment Checks, externalisiere in .md Files), Rollen orchestrieren (Business Analysis → Architecture → Tech Decisions → Implementation). Phase 3 (Implementation): Tasks schneiden (User Story Level, 1-2h pro Task), Sequencing (Bottom-Up, Layer für Layer), Code Reflection Test (nach jedem Block), Stop Loss (bei ersten Warnsignalen stoppen). Phase 4 (Integration & Review): End-to-End Testing, Code Review, Refactoring wo sinnvoll. Dokumentiere, was funktioniert. Was nicht funktioniert. Wo hast du gestoppt? Wo hättest du stoppen sollen? Wo warst du zu vage? Wo zu detailliert? Das ist Trial and Error. Aber bewusstes Trial and Error.
4. Build Pattern Recognition. Das ist das langfristige Ziel: Unbewusste Kompetenz. Du wirst nicht jedes Mal eine Checkliste durchgehen. Du wirst nicht jedes Mal bewusst an die Patterns denken. Du entwickelst Intuition. “Dieser Prompt ist zu vage.” – Du merkst es sofort. “Ich habe das Pattern nicht definiert.” – Du fühlst es. “Der erste Code-Block sieht falsch aus.” – Stop. Automatisch. Das kommt durch Wiederholung. Durch bewusstes Praktizieren der Patterns. Bis sie unbewusst werden. Genau wie bei Dark Souls: Irgendwann rollst du INTO the attack, ohne darüber nachzudenken.
Schlusswort. Ich habe 15+ Jahre Software Engineering Erfahrung. Und ich kämpfe immer noch, wenn ich meine Patterns missachte. Das heißt: Selbst mit Expertise ist Disziplin nötig. Wenn du gerade erst anfängst mit AI-Coding: Das ist normal, dass es schwer ist. Jeder Experte hat am Anfang gekämpft. Jeder hat Müll produziert. Jeder hat gedacht “Das funktioniert nicht.” Der Unterschied: Die Experten haben nicht aufgegeben. Sie haben analysiert. Patterns gefunden. Prozesse gebaut. Iteriert. Du kannst das auch. Es ist lernbar. Nicht über Nacht. Nicht durch einen Blogartikel. Durch Praxis. Durch Iteration. Durch Fehler machen und daraus lernen. Genau wie bei Dark Souls.
Dein nächster Schritt. Nimm dir ein Projekt. Ein kleines. Etwas Echtes. Öffne das Pattern Cheatsheet. Druck es aus. Leg es neben deinen Monitor. Geh bewusst durch die vier Phasen. Checke nach jedem wichtigen Schritt: Welches Pattern ist hier relevant? Befolge ich es? Dokumentiere deine Learnings. “Pattern X habe ich vergessen → Ergebnis war Y.” “Pattern Z war hier kritisch.” Nach 3-5 Projekten: Die Patterns werden unbewusst. Du machst sie automatisch. Das ist das Ziel. Aber der Weg dahin führt über bewusste Kompetenz. Über das explizite Anwenden dieser Patterns, bis sie Teil deines Workflows werden.
You died. Git gud. Try again. Und irgendwann: You won.
Nachwort
Wer ich bin. Norman Schütt, Gründer von Devergency. Software-Consulting-Firma spezialisiert auf Legacy System Modernization. Mit 15+ Jahren Erfahrung im Software Engineering helfe ich Unternehmen, veraltete Systeme in moderne, wartbare Architekturen zu transformieren. Ich entwickle mittlerweile den Großteil meiner Consulting-Projekte mit AI-Unterstützung und arbeite daran, die dabei entstehenden unbewussten Patterns zu explizieren und teilbar zu machen.
Kontakt: LinkedIn | Devergency.com
Feedback erwünscht. Das hier basiert auf realen Projekterfahrungen und ist als Diskussionsgrundlage gedacht, nicht als definitive Anleitung. Feedback, Kritik und Ergänzungen sind explizit erwünscht. Hast du andere Patterns gefunden, die funktionieren? Siehst du Schwachstellen in diesem Ansatz? Hast du Erfolgsgeschichten oder Misserfolge zu teilen? Ich lerne noch. Jeden Tag. Mit jedem Projekt. Teile deine Insights: LinkedIn (Markiere mich in deinem Post), Email ([email protected]), GitHub (Falls das hier als Repository veröffentlicht wird).
Danksagung. An alle Entwickler, die ihre Kämpfe mit AI-Coding öffentlich geteilt haben. Die zugegeben haben “Das funktioniert bei mir nicht.” Die nicht aufgegeben haben, sondern analysiert, gelernt, iteriert. An die Gaming-Community von Dark Souls. Für “Git Gud” – das ehrlichste und hilfreichste Advice, das man geben kann. An die KI-Tools, die täglich besser werden. Claude, GPT, Copilot und alle anderen. Ihr macht uns nicht obsolet. Ihr macht uns produktiver. Wenn wir lernen, euch richtig einzusetzen.
Weiterführende Ressourcen. Auf AI-Coding: GitHub Copilot Research (Studien zu AI-assisted Coding), Anthropic Blog (Updates zu Claude und AI Capabilities), Devergency Blog (Praxis-Erfahrungen aus Consulting-Projekten, coming soon). Auf Software Engineering: “Clean Code” von Robert C. Martin, “The Pragmatic Programmer” von Andrew Hunt & David Thomas, “Domain-Driven Design” von Eric Evans. Auf Game Design & Learning: “The Art of Game Design” von Jesse Schell, “A Theory of Fun for Game Design” von Raph Koster.
Lizenz & Verwendung. Das hier ist für persönliche und berufliche Weiterbildung gedacht. Erlaubt: Teilen mit Kollegen und in Teams, Verwendung in Workshops und Trainings (mit Attribution), Anpassung für interne Prozesse. Nicht erlaubt ohne Genehmigung: Kommerzieller Verkauf oder Weitervertrieb, Nutzung in kostenpflichtigen Kursen ohne Attribution, Claiming als eigene Arbeit. Bei Fragen zur Verwendung: [email protected]
Changelog. Version 1.0 (November 2025): Initial Release, 13 Patterns, 4-Phasen-Prozess, 2 Case Studies. Geplant für Version 1.1: Mehr Case Studies (Community Submissions), Pattern-spezifische Code-Beispiele, Video-Walkthroughs für jeden Pattern, Erweiterte Troubleshooting-Sektion.
You died. Git gud. Try again.
Version 1.0 | November 2025
