Claude Code und der KI-gestützte Entwicklungsworkflow

Vor sechs Monaten habe ich begonnen, Claude Code als mein primäres Entwicklungstool zu nutzen. Nicht als Spielzeug, das ich gelegentlich für Boilerplate öffne, sondern als Standard-Interface zum Schreiben, Debuggen und Refactoren von Code in jedem Projekt, an dem ich arbeite. Die Umstellung war nicht sofort — es dauerte Wochen, Gewohnheiten anzupassen, zu lernen, was man delegieren kann und was man manuell behält, und Workflows aufzubauen, die mich tatsächlich schneller machen statt langsamer.

Dieser Beitrag ist ein praktischer Bericht darüber, wie dieser Workflow in der täglichen Praxis aussieht, welche Patterns die besten Ergebnisse liefern und wo KI-gestützte Entwicklung noch Schwächen hat.

Einrichtung der Entwicklungsumgebung

Claude Code läuft in Ihrem Terminal. Es hat direkten Zugriff auf Ihr Dateisystem, kann Dateien lesen und schreiben, Shell-Befehle ausführen und mit Git interagieren. Das unterscheidet sich grundlegend von einer Chat-basierten KI, die auf eingefügte Code-Snippets arbeitet — Claude Code sieht Ihr gesamtes Projekt, versteht Ihre Verzeichnisstruktur und kann Änderungen über mehrere Dateien in einer einzigen Operation vornehmen.

Das Setup, das dies produktiv macht:

CLAUDE.md-Dateien sind die wichtigste Konfiguration, die Sie schreiben werden. Das sind Anweisungsdateien, die Claude Code automatisch liest — eine globale in ~/.claude/CLAUDE.md für Standards, die für alle Ihre Projekte gelten, und eine projektspezifische im Repository-Root für projektspezifische Konventionen.

Meine globale CLAUDE.md legt Coding-Standards fest: maximale Dateigröße (~300 Zeilen), Regeln zur Komponentenextraktion, Testanforderungen, Commit-Konventionen. Die Projektebenen-Datei spezifiziert den Tech-Stack, Architektur-Patterns, Namenskonventionen und domänenspezifische Regeln. Das ist nicht optional — ohne diese Dateien generiert Claude Code zwar funktionierenden Code, der aber nicht zum Stil oder den Konventionen Ihres Projekts passt.

MCP-Server erweitern, worauf Claude Code zugreifen kann. Ich verbinde einen Datenbankserver (damit Claude meine Entwicklungsdatenbank direkt abfragen kann), einen Datei-Such-Server und projektspezifische Server für Dinge wie Analytics-Daten. Die MCP-Konfiguration liegt in .mcp.json im Projekt-Root. Jeder Server ist ein separater Prozess, mit dem Claude Code über das Model Context Protocol kommuniziert.

Git-Integration ist eingebaut, braucht aber Leitplanken. Ich konfiguriere Claude Code so, dass es niemals Force-Push ausführt, niemals Commits ohne Aufforderung ändert und niemals Pre-Commit-Hooks überspringt. Das sind genau die Arten von destruktiven Aktionen, die leicht rückgängig zu machen sind, wenn man sie selbst ausführt, aber katastrophal, wenn eine KI sie durchführt, ohne dass man es bemerkt.

Integration in den täglichen Workflow

Das Morgen-Muster

Ich beginne jede Coding-Session, indem ich Claude Code im Projektverzeichnis öffne und ihm Kontext darüber gebe, woran ich heute arbeite. Keine detaillierte Spezifikation — ein oder zwei Sätze über das Feature, den Bug oder das Refactoring, das ich angehe.

„Ich füge E-Mail-Benachrichtigungseinstellungen zur Benutzereinstellungsseite hinzu. Nutzer sollen Benachrichtigungen für neue Nachrichten, Projektaktualisierungen und wöchentliche Zusammenfassungen ein- und ausschalten können. Die Einstellungen sollen in der Datenbank gespeichert und mit unserem E-Mail-Dienst synchronisiert werden."

Das schafft Intention. Claude Code hat dann den Kontext, um bei jeder nachfolgenden Anfrage in der Session bessere Entscheidungen über Dateiablage, Benennung und Architektur zu treffen.

Code-Generierungs-Patterns

Die effektivsten Code-Generierungsanfragen sind spezifisch im Was und flexibel im Wie. Gute Anfragen beschreiben das Verhalten, die Einschränkungen und die Integrationspunkte. Schlechte Anfragen beschreiben die Implementierung Schritt für Schritt — an diesem Punkt könnten Sie den Code genauso gut selbst tippen.

Gute Anfrage: „Füge einen PATCH-Endpunkt zum User-Settings-Router hinzu, der einen JSON-Body mit Benachrichtigungseinstellungen akzeptiert. Validiere, dass jeder Einstellungsschlüssel einer der erlaubten Typen ist. Speichere in der user_settings-Tabelle. Gib die aktualisierten Einstellungen zurück."

Schlechte Anfrage: „Erstelle eine Funktion namens updateNotificationPrefs, die req und res nimmt, body.preferences destrukturiert, durch sie iteriert, für jede db.update aufruft und ein 200 zurückgibt."

Die erste Anfrage gibt Claude Code Raum, Best Practices anzuwenden — es wird die Validierungsbibliothek verwenden, die Ihr Projekt bereits nutzt, den Fehlerbehandlungsmustern Ihrer anderen Routen folgen und das Antwortformat Ihrer bestehenden Endpunkte einhalten. Die zweite Anfrage produziert genau das, was Sie beschrieben haben, selbst wenn das Beschriebene nicht ideal ist.

Multi-Datei-Operationen

Hier übertrifft Claude Code das traditionelle Programmieren wirklich. Wenn ein Feature mehrere Dateien betrifft — eine Datenbankmigration, eine Service-Schicht, einen Route-Handler, eine React-Komponente und Tests — kann Claude Code alle in einer einzigen Operation erstellen oder modifizieren und dabei Konsistenz über alle hinweg wahren.

„Füge eine notification_preferences JSONB-Spalte zur Users-Tabelle hinzu, erstelle eine Migration dafür, füge eine Service-Methode zum Aktualisieren von Einstellungen mit Validierung hinzu, exponiere sie über den API-Router und erstelle die React-Komponente für die Einstellungsseite, die den Endpunkt aufruft."

Claude Code generiert alle diese Dateien, importiert die richtigen Module, verwendet die korrekten Tabellen- und Spaltennamen über Migration, Service und API-Schicht hinweg und erstellt eine Frontend-Komponente, die zum API-Vertrag passt. Das manuell zu tun bedeutet, ständig zwischen Dateien zu wechseln und Namen abzugleichen. Wenn es atomar passiert, spart das erheblich Zeit.

Iterative Verfeinerung

Die besten Ergebnisse kommen durch iterative Konversation, nicht durch einzelne Anfragen. Ich generiere die initiale Implementierung, überprüfe sie und verfeinere dann:

„Die Benachrichtigungseinstellungen-Komponente sieht gut aus, aber sie sollte optimistische Updates verwenden — die UI sofort aktualisieren und zurückrollen, wenn der API-Aufruf fehlschlägt. Außerdem einen Ladezustand für den initialen Fetch hinzufügen."

Das funktioniert, weil Claude Code den vollständigen Kontext dessen hat, was es gerade generiert hat. Es modifiziert die exakte Komponente, fügt das Muster für optimistische Updates mit dem State-Management-Ansatz Ihres Projekts hinzu und bewahrt alles andere, was es erstellt hat.

Debugging mit KI

Debugging ist der Bereich, in dem Claude Code die dramatischste Produktivitätsverbesserung bietet. Die traditionelle Debugging-Schleife ist: Fehler lesen, Hypothese bilden, Logging hinzufügen, reproduzieren, Logs lesen, Hypothese anpassen, wiederholen. Claude Code komprimiert das.

Fehlerdiagnose

Wenn ich auf einen Fehler stoße, füge ich den Stack-Trace oder die Fehlermeldung ein und sage „dieser Fehler tritt auf, wenn ich versuche, Benachrichtigungseinstellungen nach dem Umschalten der wöchentlichen Zusammenfassung zu speichern." Claude Code kann:

1. Die relevanten Quelldateien lesen, um den Code-Pfad zu verstehen
2. Potenzielle Ursachen basierend auf dem Stack-Trace und dem beschriebenen Auslöser identifizieren
3. Auf häufige Probleme wie Typ-Mismatches, fehlende Null-Checks oder Race Conditions prüfen
4. Einen Fix mit Erklärung vorschlagen, warum er funktioniert

Bei einfachen Bugs — ein fehlendes await, ein falscher Property-Name, ein Off-by-One-Fehler — identifiziert und behebt Claude Code das Problem schneller, als ich die relevante Zeile manuell finden kann. Bei komplexen Bugs, die State-Management, asynchrones Timing oder Interaktionen zwischen mehreren Systemen betreffen, grenzt es den Suchraum erheblich ein, selbst wenn es nicht den exakten Fix liefert.

Log-Analyse

„Hier sind die letzten 50 Zeilen des Server-Logs. Die API gibt intermittierend 500-Fehler am /api/settings-Endpunkt zurück. Was geht schief?"

Claude Code liest die Logs, identifiziert Muster (der Fehler tritt immer auf, wenn der Request-Body eine bestimmte Größe überschreitet, oder wenn zwei Anfragen gleichzeitig auf dieselbe Ressource zugreifen) und schlägt eine Diagnose vor. Es kann dann den Fix direkt vornehmen — ein Body-Parser-Limit anpassen, einen Mutex hinzufügen oder eine Race Condition beheben.

Testgetriebenes Debugging

Wenn ich auf einen Bug stoße, den ich im Browser nicht leicht reproduzieren kann, bitte ich Claude Code, einen fehlschlagenden Test zu schreiben, der das exakte Szenario erfasst:

„Schreibe einen Test, der Benachrichtigungseinstellungen mit einem leeren Objekt speichert, dann erneut mit gültigen Einstellungen speichert. Das zweite Speichern sollte das erste überschreiben, aber ich denke, es wird stattdessen gemergt."

Der Test besteht entweder (widerlegt meine Hypothese) oder schlägt fehl (bestätigt den Bug und gibt mir einen reproduzierbaren Fall). In jedem Fall habe ich einen Test, den ich behalten kann.

Refactoring-Strategien

Refactoring ist ein perfekter Anwendungsfall für KI-Unterstützung, weil es mechanisch komplex, aber konzeptuell einfach ist. Sie wissen, wie der Code nach dem Refactoring aussehen soll — die Herausforderung besteht darin, alle Änderungen konsistent vorzunehmen, ohne etwas kaputt zu machen.

Komponenten extrahieren

„Diese Dashboard-Komponente hat 450 Zeilen. Extrahiere das Stats-Panel, den Activity-Feed und den Quick-Actions-Bereich in separate Komponenten. Behalte sie im selben Verzeichnis. Bewahre alle Props und das State-Management."

Claude Code liest die Komponente, identifiziert die logischen Grenzen, extrahiert jeden Abschnitt in eine eigene Datei mit korrekten Props-Interfaces und aktualisiert das Dashboard, um die neuen Komponenten zu komponieren. Es übernimmt die Imports, die Typdefinitionen und den State, der geliftet oder übergeben werden muss.

Umbenennen und Umstrukturieren

„Benenne das user-Modul im gesamten Projekt in account um. Das umfasst den Verzeichnisnamen, alle Dateinamen, alle Import-Pfade, alle Referenzen in der Codebase und den Datenbank-Tabellen-Alias in der Query-Schicht."

Das ist mühsame, fehleranfällige manuelle Arbeit. Claude Code erledigt es in einem Durchgang, findet Referenzen, die Sie übersehen würden, und kann danach die Test-Suite ausführen, um zu verifizieren, dass nichts kaputtgegangen ist.

Pattern-Migration

„Wir migrieren vom alten Fehlerbehandlungsmuster (try/catch in jedem Route-Handler) zum zentralisierten Error-Middleware-Pattern. Hier ist ein Beispiel für das neue Pattern. Wende es auf alle Route-Handler im /api/settings-Verzeichnis an."

Claude Code liest das Beispiel, versteht das Pattern und wendet es konsistent über alle Dateien an. Es behandelt Sonderfälle — Routen mit mehreren try/catch-Blöcken, Routen mit Cleanup-Logik, die bleiben muss, Routen, die spezifische Fehlertypen abfangen.

Kontext in großen Projekten beibehalten

Die größte Herausforderung bei KI-gestützter Entwicklung ist der Kontext. Claude Code hat ein Context Window — ein Limit, wie viele Informationen es gleichzeitig berücksichtigen kann. In einem kleinen Projekt kann es alles lesen. In einem großen Monorepo nicht.

CLAUDE.md als Architekturdokumentation

Ihre CLAUDE.md-Datei dient nicht nur Coding-Standards. Nutzen Sie sie, um die Architektur Ihres Projekts auf hoher Ebene zu beschreiben:

## Architecture
- API routes are in /src/routes, one file per resource
- Business logic is in /src/services, called by route handlers
- Database access uses Drizzle ORM, schemas in /src/db/schema
- Frontend components are in /src/components, organized by feature
- Shared UI components are in /src/components/ui
- State management uses Zustand, stores in /src/stores

Das ermöglicht Claude Code eine intelligente Navigation im Projekt, auch wenn es nicht jede Datei gelesen hat. Es weiß, wo es nach Datenbank-Schemas suchen muss, wo neue Komponenten abgelegt werden und wie die Schichten verbunden sind.

Strategisches Datei-Lesen

Bitten Sie Claude Code nicht, „das gesamte Projekt zu lesen." Verweisen Sie stattdessen auf die relevanten Teile:

„Lies den User-Settings-Service, die Settings-API-Route und die Notification-Preferences-Komponente. Ich möchte Rate Limiting zum Preferences-Update-Endpunkt hinzufügen."

Das gibt Claude Code genau den Kontext, den es braucht, ohne Context Window auf irrelevante Dateien zu verschwenden. Es kann zusätzliche Dateien anfordern, wenn nötig, aber fokussiert zu starten ist besser.

Session-Kontinuität

Lange Coding-Sessions bauen natürlich Kontext durch Konversation auf. Aber wenn Sie eine neue Session starten, ist dieser Kontext weg. Ich handle das folgendermaßen:

1. CLAUDE.md mit aktuellen Architekturentscheidungen auf dem neuesten Stand halten
2. Jede Session mit einer kurzen Kontextaussage beginnen, woran ich arbeite
3. Git-Commit-Nachrichten verwenden, die Claude Code lesen kann, um aktuelle Änderungen zu verstehen

Das Git-Log ist eine unterschätzte Kontextquelle. Wenn Claude Code die letzten 10 Commit-Nachrichten liest, versteht es, was sich kürzlich geändert hat, und kann Konflikte mit laufenden Arbeiten vermeiden.

Was funktioniert und was nicht

Wo KI-Unterstützung glänzt

Boilerplate und CRUD-Operationen. Einen neuen API-Endpunkt mit Validierung, Fehlerbehandlung und Tests zu erstellen, ist zu 80 % mechanisch. Claude Code generiert das schneller und konsistenter, als ich es tippe.

Dateiübergreifende Konsistenz. Wenn eine Änderung 8 Dateien berühren muss (Typdefinition, Schema, Migration, Service, Route, Komponente, Test, Dokumentation), wahrt Claude Code Konsistenz über alle hinweg. Ich vergesse unweigerlich, eine zu aktualisieren.

Testgenerierung. Das gewünschte Verhalten beschreiben und Claude Code den Test schreiben lassen ist schneller als manuell, und es entdeckt Grenzfälle, an die ich nicht denken würde. „Schreibe Tests für den Notification-Preferences-Service. Decke ab: gültige Eingabe, leere Eingabe, ungültige Preference-Keys, Datenbankfehler und gleichzeitige Updates."

Code-Review und Analyse. „Gibt es potenzielle Race Conditions in dieser Datei?" oder „Was passiert, wenn diese Funktion mit einem null-User aufgerufen wird?" Claude Code analysiert den Code und identifiziert Probleme, die bei manueller Überprüfung leicht übersehen werden.

Neue APIs und Bibliotheken erlernen. Wenn ich eine Bibliothek verwenden muss, mit der ich nicht vertraut bin, kann Claude Code korrekte Nutzungsmuster generieren, weil es die Dokumentation und Tausende von Nutzungsbeispielen kennt. Das ist schneller als die Dokumentation für jede Funktionssignatur zu lesen.

Wo KI-Unterstützung Grenzen hat

Komplexe Geschäftslogik. Wenn die Logik tiefes Verständnis der Geschäftsdomäne erfordert — die Regeln sind nuanciert, die Grenzfälle domänenspezifisch, die Anforderungen mehrdeutig — sieht KI-generierter Code oft vernünftig aus, verfehlt aber kritische Feinheiten. Ich schreibe die Kern-Geschäftslogik immer selbst und nutze Claude Code für das Gerüst drumherum.

Performance-kritischer Code. Claude Code generiert korrekten Code, aber nicht unbedingt optimalen. Für Hot Paths, enge Schleifen oder speichersensitive Operationen schreibe ich die Implementierung selbst und nutze Claude Code, um Benchmarks und Tests drumherum zu generieren.

Architekturentscheidungen. Claude Code kann jede Architektur implementieren, die Sie beschreiben, aber es sollte die Architektur nicht für Sie wählen. Die Abwägungen zwischen einem Microservice und einem Monolithen, zwischen SQL und NoSQL, zwischen Server-Rendering und Client-Rendering — das erfordert Verständnis für Ihr Team, Ihre Skalierung, Ihren Zeitplan und Ihre Nutzer. KI hat diesen Kontext nicht.

Sicherheitsrelevanter Code. Authentifizierungsflows, Verschlüsselung, Zugriffskontrolle — das schreibe ich manuell und lasse es von einem Menschen überprüfen. Claude Code kann Auth-Code generieren, der funktioniert, aber „funktioniert" und „ist sicher" sind verschiedene Standards.

Wann man KEINE KI-Unterstützung verwenden sollte

Es gibt Situationen, in denen der Griff zu Claude Code die Produktivität aktiv beeinträchtigt:

Wenn Sie den Code tiefgehend verstehen müssen. Wenn Sie ein komplexes Problem debuggen oder lernen, wie ein System funktioniert, bedeutet KI den Fix schreiben zu lassen, dass Sie das Problem nicht verstehen. Manchmal muss man jede Zeile manuell lesen. Das Verständnis ist der Punkt, nicht der Fix.

Wenn die Aufgabe weniger als 30 Sekunden dauert. Eine Variable umbenennen, einen Tippfehler korrigieren, einen CSS-Wert anpassen — machen Sie es einfach. Der Overhead, die Änderung Claude Code zu beschreiben, übersteigt die Zeit, es selbst zu machen.

Wenn die Spezifikation unklar ist. Wenn Sie nicht wissen, was Sie bauen wollen, wird Claude Code etwas selbstsicher Falsches bauen. Klären Sie zuerst Ihre Anforderungen, dann delegieren Sie die Implementierung.

Wenn die Überprüfung von KI-generiertem Code länger dauert als das Schreiben. Bei kurzen, kritischen Funktionen dauert das Schreiben von 15 Codezeilen weniger als das Lesen von 15 Zeilen KI-generiertem Code, die Überprüfung seiner Korrektheit und das potenzielle Beheben von Problemen. Der Break-even-Punkt variiert je nach Komplexität, aber er existiert.

Praktische Tipps

Nach Monaten täglicher Nutzung sind dies die Patterns, die konsistent die besten Ergebnisse liefern:

Seien Sie explizit bei Konventionen. „Verwende das bestehende Fehlerbehandlungs-Pattern" ist besser als nichts, aber „Verwende den asyncHandler-Wrapper und wirf AppError mit passenden Statuscodes" ist besser. Je spezifischer Sie beim Wie sind, desto weniger müssen Sie hinterher korrigieren.

Überprüfen Sie jede Änderung. Claude Code zeigt Ihnen Diffs, bevor es sie anwendet. Lesen Sie jeden Diff. Nicht überfliegen — wirklich lesen. Das ist der Punkt, an dem Sie Probleme erkennen. Die Überprüfung zu überspringen, weil „die KI es wahrscheinlich richtig gemacht hat", ist der Weg, wie Bugs in die Produktion gelangen.

Verwenden Sie inkrementelle Anfragen. Anstatt ein komplettes Feature in einer Nachricht zu beschreiben, bauen Sie es Schicht für Schicht auf: erst die Datenbankschicht, dann die Service-Schicht, dann API, dann Frontend. Überprüfen Sie jede Schicht, bevor Sie zur nächsten übergehen. Das gibt Ihnen Checkpoints und hält jede Generierung fokussiert.

Halten Sie Ihre CLAUDE.md aktuell. Wenn Sie Architekturentscheidungen treffen, aktualisieren Sie die CLAUDE.md. Wenn Sie ein neues Pattern übernehmen, dokumentieren Sie es. Wenn Sie einen Ansatz deprecaten, vermerken Sie es. Diese Datei ist Ihr stärkster Hebel zur Beeinflussung der Codequalität.

Lassen Sie es lesen, bevor es schreibt. Bitten Sie Claude Code explizit, die relevanten Dateien zu lesen, bevor es Änderungen vornimmt. „Lies die bestehenden Settings-Routen und füge dann eine neue Route hinzu, die demselben Pattern folgt." Das produziert Code, der deutlich besser zu Ihrem Projekt passt als Generierung von Grund auf.

KI-gestützte Entwicklung geht nicht darum, weniger zu tippen. Es geht darum, Ihre kognitive Energie auf die Entscheidungen zu konzentrieren, die zählen — Architektur, Geschäftslogik, User Experience — und die mechanische Übersetzung dieser Entscheidungen in Code zu delegieren. Claude Code ist das beste Tool, das ich für diese Delegation gefunden habe, aber es bleibt ein Tool. Das Urteilsvermögen des Entwicklers ist es, was die Ergebnisse gut macht.