tdd ist eine Skill für Test-Driven Development zum Entwickeln von Features, Beheben von Bugs und Schreiben belastbarer Tests mit dem Red-Green-Refactor-Zyklus. Der Fokus liegt auf verhaltensbasierten Tests über öffentliche Schnittstellen, Mocking nur an den Grenzen und praxisnahen Hinweisen zu Testautomatisierung, Refactoring und Interface-Design.
Diese Skill erreicht 78/100 und ist damit ein solider Kandidat für das Verzeichnis: Sie reagiert klar auf Anfragen zu TDD bzw. Red-Green-Refactor und liefert genug Workflow-Hinweise, um Rätselraten zu reduzieren. Sie ist allerdings eher erklärend als toolartig und bietet keine Automatisierung beim Installieren oder Begleitdateien. Wer für Agents ein praktikables TDD-Playbook sucht, sollte sie in Betracht ziehen; wer eine tiefere projektspezifische Einbindung braucht, dürfte mehr Gerüst erwarten.
- Hohe Triggerbarkeit: In den Frontmatter-Hinweisen steht ausdrücklich, dass sie für das Entwickeln von Features oder das Beheben von Bugs mit TDD, Red-Green-Refactor, Integrationstests oder Test-first-Entwicklung genutzt werden soll.
- Die operative Anleitung ist konkret: Sie behandelt Tests über öffentliche Schnittstellen, den sinnvollen Einsatz von Mocks, Interface-Design für gute Testbarkeit und Refactoring-Kandidaten – inklusive Codebeispielen und verlinkten Unterthemen.
- Gute schrittweise Orientierung: Die zentrale SKILL.md verweist auf fokussierte Begleitdokumente (Tests, Mocking, Interface-Design, Refactoring, tiefe Module), sodass ein Agent ohne Rätselraten gezielt tiefer einsteigen kann.
- Es gibt keinen Installationsbefehl und keine Support-Dateien oder Skripte, daher beschränkt sich die Nutzung auf das Lesen der Anleitung statt auf automatisierte Abläufe.
- Der Inhalt ist klar auf Integrationstests und das Vermeiden interner Mocks ausgerichtet; das passt möglicherweise nicht zu Teams, die stark auf unit-test-lastige TDD-Ansätze setzen.
Überblick über tdd
tdd ist eine Test-Driven-Development-Skill zum Entwickeln von Features und Beheben von Bugs mit der red-green-refactor-Schleife. Sie eignet sich besonders für Engineers, die einen praxisnahen tdd-Leitfaden suchen, der Tests an Verhalten statt an Implementierungsdetails ausrichtet. Wenn du in einer Codebasis arbeitest, in der Refactorings häufig sind, Schnittstellen wichtig sind und brüchige Tests dich ausbremsen, hilft dir diese Skill dabei, Tests zu schreiben, die Änderungen überstehen.
Die zentrale Aufgabe ist einfach: Eine grobe Feature-Idee in eine sichere Abfolge kleiner, testbarer Schritte zu übersetzen. Die tdd-Skill ist besonders nützlich für Testautomatisierung, integrationnahe Tests und Code, der von klareren Grenzen profitiert. Ihre stärkste Haltung ist, über öffentliche Schnittstellen zu testen und nur an echten Systemgrenzen zu mocken.
Wofür tdd gedacht ist
Nutze tdd, wenn du einen testfirst-orientierten Workflow für neues Verhalten, Bugfixes oder Refactorings mit Sicherheitsnetz willst. Sie passt, wenn du das erwartete Ergebnis schon kennst, aber den saubersten Implementierungsweg noch nicht.
Was diese tdd-Skill anders macht
Das Repo sagt nicht nur „schreibe zuerst Tests“. Es fordert eine konkrete Disziplin: keine horizontale Zerlegung, Tests mit Fokus auf Verhalten und Schnittstellen entwerfen, die leicht zu testen sind. Dadurch ist die tdd-Skill hilfreicher als ein generischer Prompt, wenn du langlebige Tests statt schneller, fragiler Tests brauchst.
Wann tdd eine schlechte Wahl ist
Wenn du nur schnell einen einzelnen Unit-Test brauchst, ein Wegwerfskript schreibst oder interne Aufrufe mit viel Mocking verifizieren willst, ist das wahrscheinlich das falsche Werkzeug. Die Skill ist auf Software ausgelegt, die du voraussichtlich refaktorierst, bei der Testqualität wichtiger ist als Testmenge.
Wie man die tdd-Skill verwendet
Skill installieren und laden
Nutze den Installationsbefehl des Verzeichnisses für den Schritt tdd install und öffne dann zuerst SKILL.md. Lies anschließend tests.md, mocking.md, interface-design.md, refactoring.md und deep-modules.md, denn dort stehen die Regeln, die die Ausgabequalität tatsächlich prägen.
Gib der Skill ein Verhalten, keine Lösung
Der beste tdd usage-Einstieg beginnt mit einem für Nutzer sichtbaren Ergebnis, einem Input und einem erwarteten Resultat. Starke Prompt-Form:
- „Füge eine Checkout-Validierung hinzu, sodass ungültige Warenkörbe einen klaren Fehler zurückgeben und gültige Warenkörbe die Zahlung abschließen“
- „Behebe den Fehler, bei dem doppelte E-Mails zwei Konten erzeugen“
- „Schreibe Tests für einen Retry-Flow gegen eine Payment API und nutze dafür die öffentliche Service-Schnittstelle“
Schwache Prompt-Form:
- „Schreibe Tests für Checkout“
- „Mach dieses Modul testbarer“
- „Mocke die Datenbank und prüfe, ob die Funktion aufgerufen wurde“
Folge der red-green-refactor-Schleife
Beginne mit dem kleinsten beobachtbaren Verhalten, schreibe einen fehlgeschlagenen Test, der es belegt, implementiere nur so viel Code wie nötig, damit er besteht, und refaktoriere dann bei grünem Testzustand weiter. Batching ist hier ausdrücklich fehl am Platz: erst alle Tests und später die Implementierung zu schreiben, erzeugt laut Skill vorgestellte statt geprüfte Behauptungen. Deshalb warnt die Skill ausdrücklich vor horizontalen Schnitten.
Diese Dateien zuerst lesen
Für die praktische Umsetzung solltest du zuerst diese Dateien priorisieren:
SKILL.mdfür Philosophie und Workflowtests.mdfür gute und schlechte Testmustermocking.mdfür Mocking nur an Grenzeninterface-design.mddafür, Code besser testbar zu machenrefactoring.mdfür die Punkte, die du nach dem ersten grünen Lauf verbessern solltest
FAQ zur tdd-Skill
Ist tdd nur für Unit-Tests?
Nein. Diese tdd-Skill bevorzugt integrationnahe Tests über öffentliche Schnittstellen. Genau deshalb ist sie oft besser für Testautomatisierung und Verhaltensprüfung geeignet als für strikt isolierte, stark auf Unit-Tests ausgerichtete Setups.
Muss ich alles mocken?
Nein. Eine Kernregel in diesem tdd guide ist, nur an Systemgrenzen zu mocken, etwa bei externen APIs, Zeit, Zufall oder manchmal Dateisystem und Datenbank. Mocke nicht deine eigenen Module nur, damit Tests bestehen.
Können Anfänger tdd nutzen?
Ja, wenn sie erwartetes Verhalten klar beschreiben können. Die eigentliche Lernkurve liegt nicht in der Syntax, sondern darin, die richtige Grenze zu wählen und Tests auf Implementierungsdetails zu vermeiden.
Worin unterscheidet sich tdd von einem normalen Prompt?
Ein normaler Prompt kann Tests erzeugen, die nur kompilieren. Die tdd-Skill ist deutlich meinungsstärker: Sie setzt auf Verhalten vor Interna, kleine Schritte und Schnittstellendesign, das Tests bei Refactorings stabil hält.
Wie man die tdd-Skill verbessert
Mit schärferem Input starten
Mit tdd bekommst du bessere Ergebnisse, wenn du Verhalten, Grenze und Einschränkung mitlieferst. Sag zum Beispiel: „Baue einen wiederholbar versendbaren E-Mail-Sender, der einen echten Service-Wrapper nutzt, aber Zeit und den externen Provider mockt“, statt nur „mach das testbar“.
Auf die häufigsten Fehlermuster achten
Die größten Fehler sind zu viel Mocking, das Testen privater Methoden und Tests, die beschreiben, wie Code funktioniert, statt was der Nutzer sieht. Wenn der erste Entwurf zu sehr nach Implementierung riecht, überarbeite den Prompt so, dass die öffentliche API und das beobachtbare Ergebnis genannt werden.
Vom Test zum Design iterieren
Nutze nach der ersten Ausgabe die Fehler, um das Schnittstellendesign zu verbessern: kleinere Parameter, klarere Rückgabewerte und weniger Side Effects. Wenn sich der Code immer noch schwer testbar anfühlt, liegt das Problem möglicherweise an der API-Form, nicht an den Tests.
Nach grün gezielt nach Refactor-Zielen fragen
Sobald das Verhalten abgedeckt ist, bitte die Skill darum, Duplikate, lange Methoden, flache Module, Feature Envy oder Primitive Obsession zu identifizieren. Genau dort liefert die tdd-Skill ihren Zusatznutzen: Sie hilft dir, von „Tests bestehen“ zu einem saubereren Design zu kommen, das auch künftig leicht testbar bleibt.