Sollten wir auf Unit-Tests verzichten, weil Coding-Agenten ohnehin nur Unmengen kleinteiliger Tests erzeugen? Oder definieren wir die Unit falsch? Dieser Artikel zeigt, warum hohe Coverage und Mutation Scores bei Agentic AI trügerisch sein können und was Modultiefe mit Refactoring-Sicherheit zu tun hat.
„Verbiete deinem Coding-Agenten, Unit-Tests zu schreiben!“#
Seit Coding-Agenten immer größere Teile unserer Software entwickeln, lese ich häufiger eine provokante Forderung: Wir sollten den Agenten das Schreiben von Unit-Tests verbieten. Sie erzeugten ohnehin nur Unmengen kleinteiliger Tests, die beim nächsten Umbau wieder kaputtgingen.
Ich verstehe diese Kritik. Und trotzdem wird mir bei der Konsequenz mulmig.
Wenn wir Unit-Tests abschaffen, verlieren wir eine schnelle Feedback-Schleife. Wir verlieren die Möglichkeit, komplexe fachliche Regeln in Sekunden zu prüfen. Und wir verzichten womöglich auf Mutationstests – eines der interessantesten Werkzeuge, um herauszufinden, ob unsere Tests überhaupt Fehler erkennen.
Aber was, wenn die Kritiker ein reales Problem sehen und nur die falsche Schlussfolgerung ziehen?
Meine These: Nicht Unit-Tests sind das Problem. Wir definieren die Unit zu klein.
Die perfekte Testsuite, die Refactoring erschwert#
Stellen wir uns die Implementierung eines REST-Endpunkts in einem Backend vor, dessen fachliche Funktionalität auf zwanzig Klassen verteilt ist. Für jede Klasse erzeugt ein Coding-Agent eigene Tests. Jede Methode wird sorgfältig geprüft. Am Ende stehen grandiose 100 Prozent Code Coverage und ein Mutation Score von nahezu 100 Prozent.
Sieht hervorragend aus.
Nun wollen wir die Fachlogik neu strukturieren: Klassen zusammenlegen, Verantwortlichkeiten verschieben, neue interne Komponenten einführen und andere entfernen. Das beobachtbare Verhalten soll exakt gleich bleiben. Genau das bedeutet Refactoring: die innere Struktur von Code ändern, ohne sein beobachtbares Verhalten zu ändern.
Trotzdem scheitern zahlreiche Tests – nicht weil sich das Verhalten verändert hat, sondern weil die Tests Konstruktoren, interne Methoden, Aufrufreihenfolgen oder andere Implementierungsdetails festschreiben.
Das ist die eine Seite. Die andere: Mit dem wegfallenden Implementierungscode fallen auch dessen Tests weg, obwohl die Funktionalität nach wie vor existiert, nur anders strukturiert. Gerade beim Umbau verlieren wir also die Tests, die uns zeigen sollten, dass das Verhalten erhalten geblieben ist.
Wir haben sehr erfolgreich die gegenwärtige Struktur getestet. Aber wie gut haben wir das dauerhaft zugesagte Verhalten abgesichert?
Code Coverage sagt, welcher Code während der Tests ausgeführt wurde. Ein Mutation Score sagt, welcher Anteil der erzeugten, berücksichtigten Mutanten durch die Tests erkannt wurde. Beides sind nützliche Informationen. Keine der beiden Kennzahlen sagt für sich allein, auf welcher Abstraktionsebene die Tests das Verhalten absichern.
Und genau diese Information ist für Refactoring entscheidend.
Eine Unit muss keine Klasse sein#
Die Gleichsetzung von Unit mit Methode oder Klasse ist bequem, aber keineswegs zwingend und meistens sogar eher falsch. Auch Martin Fowler schreibt in Unit Test, dass er oft mehrere eng zusammengehörige Klassen als eine einzige Unit behandelt.
Eine Unit kann eine fachliche Komponente sein: eine Zustandsmaschine, eine Pricing Engine, ein Regelwerk oder ein ganzes Backend-Modul. Sie darf intern viele Klassen und Methoden besitzen. Entscheidend ist, dass sie nach außen einen überschaubaren, stabilen Verhaltensvertrag anbietet.
Nehmen wir dieselben zwanzig Klassen wie zuvor. Statt jede einzeln zu testen, prüfen wir die fachliche Komponente über ihre öffentliche API. Die internen Klassen werden dabei nicht durch Test-Doubles ersetzt, also nicht durch Platzhalter wie Stubs, Fakes oder Mocks; nur externe Infrastruktur wird, wo nötig, durch geeignete Test-Doubles ersetzt. So wird eine sinnvolle Unit als Ganzes getestet und kann auch als Ganzes umstrukturiert werden.
Was genau ist ein Test-Double?
Ein Test-Double ist jedes Objekt, das im Test an die Stelle eines produktiven Objekts tritt, so wie ein Stunt-Double im Film. Der Begriff stammt von Gerard Meszaros (xUnit Test Patterns); Martin Fowler fasst die Arten in Test Double zusammen:
- Dummy: wird nur herumgereicht, aber nie benutzt, etwa um eine Parameterliste zu füllen.
- Fake: eine funktionierende, aber vereinfachte Implementierung, die für die Produktion nicht taugt, etwa eine In-Memory-Datenbank.
- Stub: liefert vorgefertigte Antworten auf die Aufrufe im Test.
- Spy: ein Stub, der zusätzlich aufzeichnet, wie er aufgerufen wurde.
- Mock: ist mit Erwartungen vorprogrammiert, welche Aufrufe er erhalten soll, und prüft diese.
Im Alltag wird „Mock“ oft für alle fünf Arten verwendet; dieser Artikel sagt „Test-Double“, wenn die Art keine Rolle spielt.
Jetzt können wir die zwanzig Klassen intern neu aufteilen, ohne die Tests ändern zu müssen – solange der öffentliche Verhaltensvertrag erhalten bleibt.
Das ist die Refactoring-Freiheit, die ich von einer Testsuite erwarte.
Sicher umstrukturieren können wir nur, was unterhalb der Schnittstelle liegt, über die unsere Tests prüfen.
Eine wichtige Einschränkung: Nicht jeder Test einer kleinen Funktion ist schlecht. Ein isolierter Algorithmus mit einem stabilen Vertrag kann eine ausgezeichnete Unit sein. Problematisch wird es, wenn Tests zufällige Implementierungsgrenzen dauerhaft zu Verträgen erklären.
TDD: Entwicklungsschritte sind nicht automatisch dauerhafte Testgrenzen#
Auch Test-driven Development schützt uns nicht automatisch davor.
Die London School wird häufig mit Outside-in und stärkerer Verwendung von Mocks verbunden, die Chicago beziehungsweise Detroit School mit klassischem, oft Inside-out betriebenem TDD und einer Präferenz für zustandsorientierte Tests. Diese Zuordnungen sind Vereinfachungen; keine Schule schreibt zwangsläufig winzige Units vor, auch wenn das leider von vielen Entwicklerkollegen so verstanden und umgesetzt wird. Martin Fowler beschreibt beide Schulen in Mocks Aren’t Stubs unter den Namen „mockist“ und „classicist“.
Beide Vorgehensweisen können während der Entwicklung sehr kleine Tests hervorbringen. Das ist nicht unbedingt falsch: Ein Test kann helfen, einen einzelnen Entwurfsschritt zu durchdenken.
Aber nicht jeder Test, der beim Entstehen einer Implementierung nützlich war, muss dauerhaft Teil der Regressionstestsuite bleiben.
Ein Mensch kann später entscheiden, welche Tests zusammengefasst, ersetzt oder gelöscht werden sollten. Ein Coding-Agent tut das nicht zwangsläufig. Ohne explizite Leitlinien wächst eine Testsuite leicht entlang der jeweils aktuellen Klassenstruktur. Die Agenten übernehmen damit möglicherweise ein Muster, das schon in menschlich geschriebenen Codebasen verbreitet ist – und skalieren es.
Die Antwort ist nicht, Unit-Tests oder TDD abzuschaffen. Die Antwort ist, Entwicklungstests und Tests für explizite Vertragsgrenzen bewusst zu unterscheiden.
Die fehlende Dimension: getestete Modultiefe#
Zwei Testsuiten können denselben Coverage-Wert und denselben Mutation Score haben und trotzdem ganz unterschiedliche Refactoring-Freiheit bieten.
Was fehlt, ist die Tiefe der getesteten Komponente: Wie viel zusammenhängende interne Implementierung liegt hinter der Schnittstelle, über die das Verhalten geprüft wird?
Die Begriffe „tiefes“ und „flaches Modul“ stammen von John Ousterhout aus A Philosophy of Software Design (Kapitel „Modules Should Be Deep“): Ein tiefes Modul verbirgt viel Funktionalität hinter einer einfachen Schnittstelle, ein flaches bietet wenig Funktionalität hinter einer im Verhältnis dazu aufwendigen Schnittstelle.
Bei einer tiefen Komponente schützt ein Test den äußeren Vertrag, während viele interne Entwurfsentscheidungen frei bleiben. Bei einer flachen Komponente ist hinter der getesteten Grenze kaum etwas austauschbar.
Deshalb meine zugespitzte These:
Coverage und Mutation Score sind als Maß für Refactoring-Sicherheit ohne die getestete Modultiefe unvollständig.
Das ist noch keine fertige, wissenschaftlich validierte Metrik. Es ist zunächst eine Anforderung an eine bessere Bewertung von Testsuiten: Wir sollten nicht nur fragen, wie viel getestet wird und wie wirksam die Tests Mutanten erkennen, sondern auch, welche interne Struktur sie unangetastet verändern lassen.
Dabei genügt es nicht, schlicht die Zahl der Klassen hinter einer API zu zählen.
Eine künstlich schmale execute(Command)-Schnittstelle mit hundert unabhängigen Operationen ist keine gute Kapselung.
Und ein riesiges Modul wird nicht allein dadurch wartbar, dass seine API klein ist.
Zur sinnvollen Modultiefe gehören auch Kohäsion, Kopplung, Modulbreite (die effektive Breite der API) und Modulgröße.
Kohäsion entscheidet, ob hinter der Schnittstelle wirklich etwas Zusammengehöriges liegt, das sich als Ganzes testen lässt. Kopplung entscheidet, wie viel von außen ersetzt werden muss, bevor ein solcher Test überhaupt läuft: Je stärker ein Modul von anderen abhängt, desto mehr Test-Doubles braucht es und desto weniger sagt der Test über das reale Zusammenspiel.
Wie man diese Eigenschaften messen könnte, verdient einen eigenen Artikel.
Mutationstests auf der richtigen Ebene#
Mutationstests sind für diese Überlegung besonders interessant.
Angenommen, eine fachliche Komponente A besteht aus den internen Komponenten AA, AB und AC.
Wenn wir Mutanten in AA, AB und AC ausschließlich durch deren jeweilige interne Unit-Tests töten,
sagt der hohe Gesamtscore wenig darüber aus, ob wir A als Ganzes umstrukturieren können.
Für die Refactoring-Sicherheit von A sollten wir deshalb einen separaten Mutation Score bestimmen:
- Mutiert wird der relevante produktive Code innerhalb von
A, einschließlich ihrer internen Komponenten. - Zum Score zählen nur Tests, die
Aüber ihre festgelegte öffentliche Testgrenze ansprechen. - Interne Tests dürfen während der Entwicklung helfen, erhöhen aber diesen Score nicht.
So entsteht die Idee eines modulbezogenen, potenziell hierarchischen Mutation Scores. Ein Modul kann auf seiner eigenen Ebene gut abgesichert sein, obwohl die Tests seiner Subkomponenten anders aussehen – und umgekehrt.
Auch dieser Score beweist keine vollständige Refactoring-Sicherheit: Mutationsoperatoren erfassen nur bestimmte Fehlerarten; manche Mutanten sind äquivalent oder über die gewählte API nicht beobachtbar. Aber die Kennzahl beantwortet eine wesentlich passendere Frage als ein globaler Score über sämtliche Tests.
Wie sähe das in einem Spring-Boot-Backend aus?#
Bei einem typischen Backend kann eine fachliche Testgrenze beispielsweise die REST-API eines Moduls sein. Sie muss es aber nicht: Eine eigenständige State Machine oder ein fachliches Regelwerk kann eine ebenso sinnvolle Testgrenze bilden.
Für schnelle modulbezogene Mutationstests würde ich die fachliche Implementierung vollständig ausführen
und langsame externe Abhängigkeiten – etwa Datenbankzugriffe, Messaging oder fremde HTTP-Dienste – gezielt ersetzen.
In Spring Boot kann MockMvc ein geeigneter Einstieg sein.
Ein reiner @WebMvcTest, der auch die fachlichen Services durch Test-Doubles ersetzt, wäre dafür zu flach.
Natürlich bergen Test-Doubles eigene Risiken: Sie können falsch konfiguriert sein und, vor allem als Mocks, ihrerseits interne Aufrufdetails festschreiben. Deshalb brauchen wir weitere, anders ausgerichtete Tests:
- BDD- beziehungsweise Szenariotests prüfen das fachliche Verhalten möglichst vollständig integriert, beispielsweise mit Gherkin und echter Infrastruktur.
- Adapter-Integrationstests prüfen gezielt Repositories gegen eine echte Datenbank oder Messaging-Adapter gegen einen realen Broker, etwa mit Testcontainers.
Diese Tests ergänzen die schnellen Modul-Mutationstests. Sie müssen nicht alle in denselben Mutation Score einfließen.
Und es gibt Grenzen: Module können indirekt über gemeinsame Datenbanktabellen oder externe Systeme gekoppelt sein. Modulbezogene Mutationstests beweisen daher weder vollständige Modulunabhängigkeit noch die Korrektheit sämtlicher Integrationen. Dafür sind gegebenenfalls zusätzliche Tests nötig. Das ist wichtig, aber nicht das Thema dieses Artikels.
Testgrenzen gehören zur Architektur#
Wenn wir möchten, dass Coding-Agenten diese Strategie zuverlässig umsetzen, dürfen wir ihnen die Wahl der Testebene nicht jedes Mal neu überlassen.
Modulgrenze, Vertragsgrenze und Testgrenze sollten zusammenfallen; in vielen Codebasen tun sie es nicht. Module haben keinen klar zugesagten Vertrag, und Tests setzen an Stellen an, die nie als Vertrag gedacht waren.
Die Architektur sollte explizit festlegen, welche fachlichen Schnittstellen als dauerhafte Testgrenzen gelten, welche internen Komponenten nicht direkt getestet werden sollen und welche Infrastrukturadapter in schnellen Tests ersetzt werden dürfen.
In Java oder Kotlin könnten Annotationen und Architekturprüfungen dabei helfen; ebenso kommen Package-Grenzen, ArchUnit, Spring Modulith oder – wo passend – das Java Platform Module System infrage. Entscheidend ist nicht die konkrete Technik, sondern dass die Regeln automatisch überprüfbar werden.
Ein Agent kann dann durchaus kleinteilige Tests als temporäre Entwicklungshilfe schreiben. Vor dem Abschluss eines Pull Requests muss aber sichergestellt sein, dass die dauerhafte Testsuite das Verhalten an den festgelegten Testgrenzen absichert. Überflüssige Tests, die nur interne Struktur konservieren, können entfallen.
Fazit: Nicht weniger Sicherheit, sondern die richtige Sicherheit#
Die Forderung, Coding-Agenten das Schreiben von Unit-Tests zu verbieten, greift mir zu kurz. Sie reagiert auf ein reales Problem: Tests können so eng an der Implementierung hängen, dass sie jede größere Umstrukturierung erschweren.
Aber die Lösung kann nicht sein, auf schnelle, präzise Feedback-Schleifen zu verzichten – gerade nicht bei Agentic AI.
Agentic AI nimmt uns das Coden ab. Aber gerade dadurch haben wir endlich die Zeit, uns mit Software-Engineering zu befassen: mit Modulgrenzen, Verträgen und Teststrategien. Das macht den Unterschied aus zwischen Vibe Coding, wie Andrej Karpathy es genannt hat, und Vibe Engineering, wie Simon Willison es vorschlägt.
Wir müssen die Unit neu ernst nehmen: als bewusst abgegrenzte, kohäsive Komponente mit einem stabilen Verhaltensvertrag.
Dann erhalten Coverage und Mutationstests einen Kontext, in dem sie auch für Refactoring-Sicherheit aussagekräftiger werden. Nicht jeder beim TDD entstandene Kleinsttest muss bleiben. Entscheidend ist, ob die dauerhaften Tests das Verhalten schützen, während die Implementierung veränderbar bleibt.
Habe ich das hier Beschriebene selbst immer richtig gemacht? Sicherlich nicht. Etwas an diesem Thema hat mir schon lange Unbehagen bereitet. Nun habe ich gründlich darüber nachgedacht und bin hoffentlich auf dem richtigen Weg. Umsetzen muss ich es in meinen eigenen Repositories aber erst noch – jedenfalls dort, wo die Kritikalität den Aufwand rechtfertigt.
Die nächste Frage lautet deshalb: Was macht ein Modul überhaupt tief – und wie messen wir das, ohne uns von einer kleinen API oder einer großen Menge Code täuschen zu lassen?
Darum wird es später in einem Folgeartikel über Modulbreite, Modultiefe, Kohäsion, Kopplung und Modulgröße gehen.
Quellen und weiterführende Literatur#
- John Ousterhout: A Philosophy of Software Design – Tiefe und flache Module: Funktionalität im Verhältnis zur Breite der Schnittstelle (Kapitel „Modules Should Be Deep“).
- Martin Fowler: Unit Test – Was eine Unit ist, und der Unterschied zwischen „solitary“ und „sociable“ Tests.
- Gerard Meszaros: Test Double – Ursprung des Begriffs, aus xUnit Test Patterns.
- Martin Fowler: Test Double – Der Überbegriff nach Gerard Meszaros und die fünf Arten Dummy, Fake, Stub, Spy und Mock.
- Martin Fowler: Mocks Aren’t Stubs – Zustands- und Verhaltensprüfung, klassisches und mockistisches TDD.
- Sandro Mancuso: Does TDD really lead to good design? – London School und Detroit School, Outside-In TDD.
- ArchUnit – Architekturregeln für Java als ausführbare Tests.
- Spring Modulith – Fachliche Module in Spring-Boot-Anwendungen, mit Prüfung der Modulgrenzen und Modultests.
- dev.java: Modules – Einführung in das Java Platform Module System.
- Andrej Karpathy: Post auf X vom Februar 2025 – Ursprung des Begriffs „Vibe Coding“.
- Simon Willison: Vibe engineering – Vorschlag des Gegenbegriffs für verantwortliche Softwareentwicklung mit KI-Agenten.
Dieser Artikel ist mit Unterstützung von KI entstanden.
