Sauberer Code mit Claude-gestütztem TDD

Beschreibe das Verhalten, das du implementieren willst: "Nutzer sollen ihr Passwort per E-Mail zurücksetzen können. Der Endpunkt soll prüfen, dass die E-Mail existiert, ein zeitlich begrenztes Token generieren und einen Reset-Link versenden." Claude Code schreibt zuerst den Test, der die erwartete HTTP-Antwort, die Token-Generierung und den E-Mail-Versand prüft, bevor irgendeine Implementierung existiert. Es führt den Test aus, um zu bestätigen, dass er aus dem richtigen Grund fehlschlägt (fehlende Funktion, kein Syntaxfehler).

Claude Code schreibt dann die einfachste Implementierung, die den Test bestehen lässt. Es überkonstruiert nicht, sondern schreibt genau genug Code, um die Test-Assertions zu erfüllen. Diese Disziplin ist der Kern von TDD: Der Test definiert den Vertrag, und die Implementierung erfüllt ihn. Claude Code führt die Test-Suite nach der Implementierung aus, um zu verifizieren, dass der neue Test bestanden wird und keine bestehenden Tests fehlschlagen.

Mit bestehenden Tests als Sicherheitsnetz bittest du Claude Code, die Implementierung aufzuräumen: Hilfsfunktionen extrahieren, Variablennamen verbessern, Duplizierung reduzieren oder Performance optimieren. Nach jedem Refactoring-Schritt führt Claude Code die Tests erneut aus. Schlägt ein Test fehl, hat das Refactoring eine Verhaltensänderung eingeführt, und Claude Code macht sie entweder rückgängig oder passt sie an. Diese Phase erzeugt sauberen, wartbaren Code, abgesichert durch umfassende Tests.

Beginne damit, Claude Code zu sagen, was das Feature aus Sicht des Nutzers tun soll. Statt "erstelle eine Funktion calculateDiscount, die einen Preis und einen Prozentsatz nimmt", sag "Kunden mit Premium-Mitgliedschaft sollen 20 % Rabatt auf ihre Bestellsumme bekommen, aber der Rabatt soll nie 50 $ überschreiten". Diese verhaltensbasierte Beschreibung erzeugt bessere Tests, weil die Tests Geschäftsregeln prüfen, nicht Implementierungsdetails.

Claude Code schreibt eine Testdatei mit mehreren Testfällen: dem Happy Path (Premium-Nutzer, gültiger Rabatt), Edge Cases (Rabatt übersteigt die 50-$-Grenze, Bestellung mit Preis null), und Fehlerfällen (Nicht-Premium-Nutzer, negativer Preis). Überprüfe diese Tests, bevor Claude Code das Feature implementiert. Die Testfälle definieren deine Spezifikation, fehlt ein Fall, füge ihn jetzt hinzu. Es ist viel günstiger, einen Testfall hinzuzufügen, als einen fehlenden Edge Case erst in der Produktion zu entdecken.

Sobald du die Tests freigibst, sag Claude Code, das Feature zu implementieren. Es schreibt den Code, führt die Tests aus und zeigt dir die Ergebnisse. Bestehen alle Tests beim ersten Versuch, kannst du zum Refactoring übergehen. Schlagen manche Tests fehl, liest Claude Code die Fehlerausgabe und passt die Implementierung an. Dieser Zyklus ist typischerweise nach ein bis zwei Iterationen abgeschlossen, weit schneller als der manuelle Schreiben-Ausführen-Debuggen-Zyklus.

Der häufigste Grund, warum Entwickler TDD überspringen, ist, dass das Schreiben von Tests sich langsam und mühsam anfühlt, besonders Setup-Code, Mocking und Boilerplate-Assertions. Claude Code beseitigt diese Reibung vollständig. Du beschreibst in einem Satz, was passieren soll, und Claude Code generiert die komplette Testdatei mit korrekten Imports, Fixtures, Mocks und Edge-Case-Abdeckung. Die kognitive Last verschiebt sich von "wie mocke ich diese Abhängigkeit" zu "welches Verhalten ist wichtig".

Wenn Claude Code Tests aus einer Verhaltensbeschreibung schreibt, generiert es Edge Cases, die Entwickler oft vergessen: leere Eingaben, Grenzwerte, gleichzeitiger Zugriff, Null-Handling und ungültige Zustandsübergänge. Es tut dies, weil es Millionen von Test-Suites gesehen hat und weiß, welche Edge Cases häufig Bugs verursachen. Du bekommst gründlichere Testabdeckung, ohne selbst an jeden Fall denken zu müssen.

TDD ist schwer durchzuhalten, weil die Versuchung, den Test zu überspringen und direkt den Code zu schreiben, immer vorhanden ist. Mit Claude Code ist es tatsächlich schneller, zuerst den Test zu schreiben, als zuerst die Implementierung zu schreiben, es gibt keinen Anreiz, ihn zu überspringen. Der Rot-Grün-Refactor-Zyklus wird natürlich, weil Claude Code jeden Schritt durchsetzt: Es schreibt den Test, führt ihn aus, um das Fehlschlagen zu bestätigen, implementiert den Code und führt den Test erneut aus, um den Erfolg zu bestätigen.

Auf jeden Fall. Claude Code liest deine bestehende Testinfrastruktur, Testframework, Fixtures, Mocks, Factories und Konventionen, und schreibt neue Tests, die sich natürlich in deine bestehende Suite einfügen. Nutzt dein Projekt pytest mit conftest.py-Fixtures, generiert Claude Code Tests, die diese Fixtures nutzen. Nutzt dein React-Projekt Testing Library mit eigenen Render-Utilities, folgt Claude Code diesem Muster. Du musst nicht von null anfangen.

Der Coverage-Prozentsatz ist weniger wichtig als die Coverage-Qualität. Claude Code hilft dir, dich auf Behavior Coverage statt Line Coverage zu konzentrieren. Wenn du das Feature danach beschreibst, was es tun soll (nicht wie), decken die generierten Tests natürlich die wichtigen Pfade ab. Claude Code kann aber auch deinen bestehenden Coverage-Report analysieren, untestete Zweige identifizieren und dann gezielte Tests schreiben, um Lücken zu schließen. Strebe gründliche Abdeckung der Geschäftslogik und Fehlerbehandlung an, nicht 100 % Line Coverage.

Ja. Claude Code schreibt Integrationstests, die mehrere Komponenten zusammen testen, API-Endpunkte, die eine echte Testdatenbank treffen, React-Komponenten, die mit gemockten API-Antworten interagieren, oder Service-Layer, die mehrere Abhängigkeiten koordinieren. Es übernimmt Testdatenbank-Setup und -Teardown, Test-Fixtures und Mock-Server-Konfiguration. Für API-Integrationstests generiert es Tests, die den vollständigen Request-Response-Zyklus einschließlich Authentifizierung, Validierung und Fehlerantworten prüfen.

Nach Grün (Tests bestehen mit funktionierender Implementierung) betrittst du die Refactor-Phase. Bitte Claude Code, die Implementierung zu verbessern, Funktionen zu extrahieren, Duplizierung zu reduzieren, Benennung zu verbessern oder Performance zu optimieren. Claude Code macht die Änderungen und führt nach jedem Refactoring-Schritt die Test-Suite erneut aus. Schlägt ein Test fehl, bedeutet das, dass das Refactoring das Verhalten geändert hat, und Claude Code wird entweder das Refactoring korrigieren oder die Verhaltensänderung zur Überprüfung markieren. Die Tests dienen die ganze Zeit als Sicherheitsnetz.

Beschreibe das Feature-Verhalten in natürlicher Sprache, lass Claude Code den fehlschlagenden Test schreiben (Rot), bitte es dann, den Code zur Implementierung zu schreiben, der den Test bestehen lässt (Grün), und fordere schließlich ein Refactoring an (Refactor). Dieser Rot-Grün-Refactor-Zyklus mit Claude Code ist schneller als manuelles TDD, weil Claude sowohl die Tests als auch die Implementierung schreibt, während du dich auf die Definition der Anforderungen konzentrierst.

Ja. Claude Code führt deine Test-Suite nach dem Schreiben jedes Tests und nach jeder Implementierungsänderung aus. Es liest die Testausgabe, identifiziert Fehlschläge und iteriert, bis die Tests bestehen. Du kannst auch Hooks einrichten, die nach jeder Dateibearbeitung automatisch Linter und Type-Checker ausführen, und so ein vollständig automatisiertes Quality Gate schaffen.