Der Session-Lebenszyklus: 8 Befehle, die KI-gestütztes Programmieren in ein System verwandeln

56 Befehle sind Zutaten. Das hier ist das Rezept.

Die meisten Entwickler installieren ein Set von KI-Coding-Templates und sehen eine Liste von Optionen. Sie wählen eins aus, nutzen es, schließen die Session. Das ist wie eine Fitnessstudio-Mitgliedschaft abzuschließen und dann nur den Wasserspender zu benutzen.

Die wahre Stärke liegt im Session-Lebenszyklus: eine wiederholbare Schleife aus 8 Befehlen, die jede Coding-Session in sich potenzierende Fortschritte verwandelt. Das ist der exakte Workflow, mit dem eine 97-seitige mehrsprachige Website, ein PDF-Ebook in 4 Sprachen und ein Open-Source-CLI-Tool gebaut wurden. Die KI hat dabei die gesamte Umsetzung übernommen.

Die Schleife

Jede produktive KI-Coding-Session folgt der gleichen Struktur:

1. Fortsetzen (/read-handover). Dort weitermachen, wo die letzte Session aufgehört hat. Die vorherige Session hat eine HANDOVER.md gespeichert mit erledigter Arbeit, getroffenen Entscheidungen, verworfenen Alternativen und exakten nächsten Schritten. Die KI verarbeitet all das, bevor sie irgendetwas anfasst.

2. Priorisieren (/strategic-next). Bevor irgendetwas passiert, die Arbeit mit dem höchsten Impact bestimmen. Ein vollständiges Projekt-Audit durchführen, Möglichkeiten brainstormen, sie auf einer Impact/Effort-Matrix bewerten. Das bauen, was zählt, nicht das, was sich dringend anfühlt.

3. Erkunden (/creative-brainstorm). Sobald klar ist, WAS gebaut werden soll, erkunden, WIE. Das Problem auf verschiedene Arten umformulieren. Ideen durch unterschiedliche Perspektiven generieren: umkehren, entfernen, vereinfachen, übertreiben. Auf den besten Ansatz konvergieren. Die Erste-Idee-Falle vermeiden.

Dann wird gebaut, mit dem passenden Template für die jeweilige Arbeit: /feature-build für Features, /quick-task für kleine Änderungen, /debug-rootcause für Bugs. Die Planungsphasen haben die Richtung bereits vorgegeben. Die Umsetzung sind die 20%.

4. Logik verifizieren (/verify-thorough). Fünf Verifikationsebenen: logisch (ergibt es Sinn?), kontextuell (passt es ins System?), Vollständigkeit (alle Pfade abgedeckt?), empirisch (tatsächlich ausführen), Regression (wurde etwas kaputt gemacht?). “Sieht richtig aus” ist keine Verifikation.

5. Visuell verifizieren (/visual-verify). Logik findet funktionale Bugs. Visuelle Verifikation findet alles andere: responsive Layouts auf Desktop, Tablet und Mobilgeräten. Konsolenfehler. Netzwerkprobleme. Interaktionstests. Screenshots als Nachweis.

6. Standards prüfen (/principles-check). Nachdem der Code funktioniert und gut aussieht, ihn gegen die Engineering-Prinzipien prüfen. KISS, DRY, YAGNI, SRP, Sicherheit, Testing, Dokumentation. Jeder Verstoß bekommt eine exakte Datei:Zeile-Angabe.

7. Aufräumen (/housekeeping). Dokumentationsgenauigkeit. Entfernung von totem Code. Dependency-Audit. Git-Hygiene. Konsolidierung. Die Codebase besser hinterlassen, als man sie vorgefunden hat.

8. Zustand speichern (/low-context-handover). Alles speichern: was passiert ist, was erledigt ist, was in Arbeit ist, Entscheidungen und verworfene Alternativen, bekannte Probleme, exakte nächste Schritte. Das verbindet zurück zu Schritt 1 der nächsten Session. Die Schleife ist geschlossen.

Acht Befehle. Eine Schleife. Jede Session.

Warum jeder Schritt wichtig ist

Die Schritte sind nicht willkürlich. Jeder einzelne verhindert einen bestimmten Fehlermodus.

Ohne Handovers verschwendet jede Session 10 bis 20 Minuten damit, den Kontext wiederherzustellen. Über 50 Sessions sind das 8 bis 16 Stunden, die für Wiederentdeckung verloren gehen.

Ohne strategische Planung driftet man ab. Man fixt unwichtige Bugs, während kritische Features ungebaut bleiben. Man optimiert CSS, während der Bezahlvorgang kaputt ist.

Ohne Brainstorming baut man das Erste, was einem einfällt, und refactored es dann später, obwohl ein einfacherer Ansatz die ganze Zeit existierte.

Ohne doppelte Verifikation liefert man Code aus, der in der Demo funktioniert und in Produktion bricht. Oder der perfekt funktioniert, aber auf dem Handy kaputt aussieht. Die 48% Verifikationslücke (Sonar, 2026) ist der Ort, an dem Bugs leben.

Ohne Prinzipien-Audits sammelt die Codebase langsam “nur dieses eine Mal”-Ausnahmen an, bis die eigenen Standards nur noch eine Erinnerung sind.

Ohne Aufräumen sammelt sich Unordnung. Veraltete Dokumentation führt in die Irre. Tote Dateien verwirren.

Jeder Schritt ist ein Sicherheitsnetz. Zusammen bilden sie ein System, durch das nichts durchrutscht.

Der Parallelismus-Multiplikator

Die Schleife ist für ein einzelnes Projekt leistungsfähig. Sie wird zum Kraftmultiplikator, wenn man mehrere Projekte gleichzeitig betreibt.

Ein Projekt pro IDE. Eine IDE pro Claude Code Session. Mehrere IDEs gleichzeitig geöffnet:

• IDE 1: Eine Website bauen
• IDE 2: Ein Ebook schreiben
• IDE 3: Ein CLI-Tool entwickeln
• IDE 4: Marketing-Inhalte vorbereiten

Jedes Projekt durchläuft seinen eigenen Lebenszyklus. Jedes produziert sein eigenes Handover. Wenn man zu einem Projekt zurückkehrt, setzt /read-handover genau dort fort, wo man aufgehört hat. Das Handover-System ermöglicht es, zehn Projekte gleichzeitig zu jonglieren, ohne in einem davon den Kontext zu verlieren.

Ohne Handovers bedeutet jeder Projektwechsel, den Kontext neu aufzubauen. Mit Handovers nimmt die KI in Sekunden den Faden wieder auf. Der Session-Lebenszyklus ist in jedem Projekt derselbe, also ist der kognitive Aufwand beim Wechseln nahezu null.

Einfach starten, Schichten hinzufügen

Man braucht nicht alle 8 Befehle am ersten Tag.

Woche 1. Mit /kickoff und /low-context-handover starten. Einfach Sessions ordentlich beginnen und beenden. Das allein bringt einen schon nach vorne.

Woche 3. /read-handover und /verify-thorough hinzufügen. Jetzt bleibt der Kontext über Sessions erhalten und Bugs werden abgefangen, bevor sie ausgeliefert werden.

Monat 2. /strategic-next und /visual-verify hinzufügen. Jetzt baut man die richtigen Dinge und beweist visuell, dass sie funktionieren.

Monat 4. Die volle 8-Befehle-Schleife plus Parallelismus über mehrere IDEs.

Diese Progression spiegelt das Gürtelsystem aus den Kampfkünsten wider. Man baut Muskelgedächtnis auf jeder Stufe auf, bevor man die nächste Schicht hinzufügt.

Der Zinseszinseffekt

Jeder Befehl ist für sich nützlich. Zusammen potenzieren sie sich.

Handovers eliminieren Kontextverlust, sodass Entscheidungen über Sessions hinweg bestehen bleiben. Strategische Planung verhindert Abdriften, sodass man das baut, was zählt. Brainstorming verhindert Erste-Idee-Bias, sodass man es auf die richtige Art baut. Doppelte Verifikation findet Bugs früh, sodass es später weniger Debugging gibt. Prinzipien-Audits verhindern Verfall, sodass die Codebase sauber bleibt. Aufräumen verhindert Unordnung, sodass die Codebase navigierbar bleibt. Parallelismus multipliziert den Durchsatz.

Nach 50 Sessions mit dieser Schleife hat man das Äquivalent dessen gebaut, wofür ein kleines Team Monate bräuchte. Nicht weil KI schnelleren Code schreibt, sondern weil man nie den Kontext verliert, nie das Falsche baut und nie unverifizierten Code ausliefert.

Das ist die Methodik. Keine Sammlung von Templates. Eine Schleife, konsequent ausgeführt, die sich über die Zeit potenziert.

Die Tools für diesen Workflow sind kostenlos und Open Source. Mit npx @ccprompt/cli install-generic . installieren und mit /kickoff starten. Die vollständige Methodik erklärt die Prinzipien hinter jedem Schritt.