Das Ziel eines jeden Entwicklers ist die Erstellung von gut durchdachtem und korrektem Code. Eine Methode, die sich dabei besonders gut bewährt, ist die testgetriebene Entwicklung (TDD). Obwohl TDD Ihren Code nicht für Sie entwirft oder schreibt, handelt es sich dabei um eine Methode der Softwareentwicklung, die Ihnen in einem iterativen Entwicklungszyklus schnelles Feedback zu Designentscheidungen ermöglicht.
Ob Unit-Tests vor oder nach dem Codieren geschrieben werden oder ob überhaupt keine Tests geschrieben werden, hängt von der Wahl des Entwicklers ab. Natürlich führt das Niemalsschreiben von Tests zu kritischen Situationen in der Produktion. Wenn der Entwickler Glück hat, entdeckt er Fehler während der manuellen Testphase.
Es ist besser, nach der Fertigstellung des Codes Tests zu schreiben, als gar keine Tests durchzuführen. Die meisten Entwickler, auch wir, wenden den Code-First-Ansatz direkt an und schreiben dann Tests. Trotzdem ist der geschriebene Code nicht besser. Wenn wir den Testfall vergessen, treten einige Funktionsfehler auf. Es ist viel besser, vorab für jeden Codeabschnitt fehlgeschlagene Testfälle zu schreiben und dann den Code hinzuzufügen, damit dieser Test gemäß dem TDD-Zyklus erfolgreich ist.
Derzeit diskutieren wir, wie wir Generative AI nutzen können, um unsere Arbeit stärker zu automatisieren. In dieser Arbeit stellen wir ein neues Experiment vor, inspiriert von Allen Heltons Blog. Wir schreiben mehrere Testfälle für das Projekt und bitten dann ChatGPT, den testbezogenen Code zu generieren.
Generative KI für Test-First-Entwicklung
Angesichts des Potenzials menschlicher Fehler beim manuellen Testen stellt sich die Frage: Warum wird TDD nicht mithilfe von Generative AI automatisiert? Generative AI kann eine transformative Rolle bei TDD spielen, indem es die Erstellung von Unit-Tests und des entsprechenden Codes automatisiert. Hier ist ein vorgeschlagener Workflow:
- Von Entwicklern geschriebene Tests: Entwickler beginnen mit dem Schreiben der ersten Komponententests und geben die gewünschten Ergebnisse für ihren Code an.
- Von KI generierter Code: Generative KI liest diese Unit-Tests und erstellt den erforderlichen Code, um sie zu bestehen. Wenn der Code erfolgreich ausgeführt wird, wird er auf der Festplatte gespeichert. Andernfalls generiert die KI einen Fehlerbericht und versucht erneut, den richtigen Code zu erstellen. Dadurch entsteht eine Schleife, bis die Tests erfolgreich sind. Durch die Einbindung von KI auf diese Weise können Entwickler sicherstellen, dass ihr Code gründlich getestet und validiert wird, wodurch das Fehlerrisiko minimiert wird.
Vorteile der Verwendung generativer KI in TDD
Durch die Automatisierung der Codegenerierung und des Testprozesses können Entwicklungszyklen erheblich beschleunigt werden. Außerdem wird das Potenzial für menschliche Fehler bei Testfällen und beim Schreiben von Code reduziert. Dabei wird sichergestellt, dass alle Tests umfassend und konsistent abgedeckt sind, und der Entwicklungsprozess kann problemlos skaliert werden, ohne den manuellen Arbeitsaufwand zu erhöhen.
Mögliche Herausforderungen und Lösungen
Die Integration von generativer KI in TDD bietet zwar zahlreiche Vorteile, ist aber nicht ohne Herausforderungen. Die anfängliche Einrichtung von KI-Systemen für TDD kann manchmal komplex und zeitaufwändig sein. Entwickler müssen möglicherweise geschult werden, um KI-Tools effektiv nutzen und ihnen vertrauen zu können. Aber selbst wenn die Entwickler bereit sind, damit umzugehen, kann KI mit einzigartigen oder Randfällen zu kämpfen haben, die in den Trainingsdaten nicht gut dargestellt sind, was die gewünschten Szenarien verwirren kann. Generative KI reagiert mit anständigem Code, ist aber nicht die beste Wahl. Denn der Code wendet noch keinen Feedback-Mechanismus an. Um großartigen Code zu produzieren, sollten wir Feedback-Mechanismen auf KI anwenden, wie den Code-Review-Ansatz der Entwickler. Wir können KI mit menschlicher Aufsicht kombinieren, um komplexe Szenarien zu bewältigen, zumindest für den Moment. :)
Feedback Angewandte Generative KI in TDD
Feedback-Mechanismus
Um den Prozess weiter zu verfeinern, kann ein Feedback-Mechanismus eingeführt werden. Entwickler schreiben die Unit-Tests und ein Entwickler-Agent generiert den Code. Eine neue Kontrollebene wird durch einen Code-Reviewer-Agenten hinzugefügt, der den Code überprüft und dem Entwickler-Agenten Feedback gibt.
Iterative Verbesserung
Der Entwickleragent überarbeitet den Code anhand des Feedbacks des Prüfagenten und reicht ihn erneut zur Prüfung ein. Dieser iterative Prozess wird fortgesetzt, bis der Code die Prüfung erfolgreich besteht.
Abschließende Prüfung
Sobald der Code vom Prüfagenten genehmigt wurde, werden Unit-Tests ausgeführt. Wenn diese erfolgreich sind, wird der Code gespeichert. Wenn sie fehlschlagen, wird ein Fehlerbericht generiert und der Prozess kehrt zur Codegenerierung zurück.
Im Wesentlichen würde der Arbeitsablauf wie folgt aussehen:
- Der Entwickler schreibt die Unit-Tests.ev
- Die KI liest diese Tests und generiert den notwendigen Code.
- Wenn die Tests erfolgreich verlaufen, wird der Code gespeichert. Wenn nicht, wird ein Fehlerbericht erzeugt und die KI versucht in einer Schleife den Code zu korrigieren.
- Diese anfängliche Automatisierung kann fehleranfälligen Code erzeugen. Hier kommt der Feedback-Mechanismus ins Spiel.
- Entwickler schreiben die Unit-Tests und der Entwickler-Agent generiert den erforderlichen Code und die erforderlichen Methoden.
- Ein Code-Prüfer-Agent prüft den Code und sendet Feedback an den Entwickler-Agent.
- Der Entwickleragent verfeinert den Code auf Grundlage des Feedbacks und übermittelt ihn erneut zur Überprüfung.
- Dieser Zyklus wird fortgesetzt, bis der Codeprüfer-Agent den Code genehmigt.
- Nach der Genehmigung werden die Unit-Tests ausgeführt. Bei Erfolg wird der Code gespeichert. Andernfalls wird ein Fehlerbericht generiert und die Schleife wird fortgesetzt.
Durch die Einbindung eines Feedback-Mechanismus verbessert sich die Qualität des generierten Codes deutlich und es wird sichergestellt, dass dieser die notwendigen Standards erfüllt und alle Tests zuverlässig besteht.
Fazit
Die Integration generativer KI in testgetriebene Entwicklung (TDD) hat das Potenzial, die Softwareentwicklung zu revolutionieren. Durch die Automatisierung der Generierung von Unit-Tests und entsprechendem Code können Entwickler eine höhere Codequalität sicherstellen, Fehler reduzieren und ihren Workflow optimieren. Zwar sind Herausforderungen zu bewältigen, aber die Vorteile überwiegen die anfänglichen Hürden bei weitem, was dies zu einem vielversprechenden Ansatz für die Zukunft des Programmierens macht. Sie können unsere Coder-KI Projekt, wenn Sie Interesse an der Unterstützung der Programmierung mittels generativer KI haben.
Zukünftige Richtungen
Auf diesem Ansatz möchten wir in drei Punkten aufbauen:
Erweiterte Sprachunterstützung: Obwohl wir uns auf Java konzentriert haben, kann diese Methodik auf andere Sprachen wie Python, JavaScript und mehr ausgeweitet werden.
Automatisierte Testgenerierung: Wir können Generative AI dazu veranlassen, die Tests basierend auf den von Entwicklern bereitgestellten hohen Anforderungen zu schreiben, anstatt Tests manuell schreiben zu müssen.
Erweiterung des Agentic AI-Teams: Über einen einfachen Code-Prüfer hinaus könnten wir spezialisiertere Agenten einführen, beispielsweise einen QA-Agenten zum Testen von Randfällen, einen Performance-Agenten zur Optimierung der Code-Leistung usw.
Wir empfehlen jedem Softwareentwickler, seine Zeit darauf zu verwenden, robustere und präzisere Testfälle zu schreiben und dann von der Leistungsfähigkeit der generativen KI zu profitieren, um qualitativ hochwertigen Code zu produzieren.
