Testen von KI: Qualitätsmerkmale unter der Lupe – ein Erfahrungsbericht

In zeitgemäßer Softwareentwicklung spielt die Qualitätssicherung durch Tests eine zentrale Rolle. Die fortschreitende Komplexität von Softwarelösungen erfordert robuste Mechanismen, um die Zuverlässigkeit und Effizienz von Programmen sicherzustellen [2]. Dabei gewinnen insbesondere Unittests an Bedeutung, da sie eine frühzeitige Erkennung von Fehlern sowie Schwachstellen ermöglichen und sich vor, während oder nach der Implementierung der eigentlichen Funktionalität umsetzen lassen.

Durch das Aufkommen von generativer KI haben sich die Ansätze in der Softwareentwicklung verschoben beziehungsweise ergänzt [4]. Davon sind auch das Testen sowie die Implementierung von Testmethoden nicht ausgeschlossen. Code lässt sich beispielsweise durch generative Modelle analysieren, und auch passende Unittests lassen sich erzeugen. Ebenso ist die Analyse der Testergebnisse möglich, um darauf aufbauend neuen Code zu erzeugen, der das Problem eventuell behebt. Hier sind selbstheilende Tests ein aktuelles Stichwort [5].

Ein weiteres Vorgehen sind Agentensysteme im Kontext von Sprachmodellen. Dabei dient häufig ein spezifisches Modell als ein Agent, der sich für eine bestimmte Aufgabe über einen Prompt mit einer Aufgabe adressieren lässt. Dieses Vorgehen ist hochinteressant, und es wird noch spannend zu beobachten sein, was im Bereich der Testgenerierung, Ergebnisanalyse und Code-Heilung möglich sein wird. Ein Themenkomplex, den dieser Artikel aufgreift.

Was sind Agentensysteme?

Aber zunächst kurz zu einer Einordnung. Agentensysteme sind autonome Softwareeinheiten, die unabhängig arbeiten und auf Veränderungen in ihrer Umgebung reagieren können. Diese Systeme treffen Entscheidungen auf Basis vorgegebener Ziele und verfügen oft über die Fähigkeit, mit anderen Agenten zu interagieren, um komplexe Aufgaben zu bewältigen. Wichtige Konzepte von Agentensystemen sind Autonomie, Flexibilität und Interaktion. Autonomie bedeutet, dass Agenten eigenständig handeln, ohne ständige Benutzerinteraktion. Flexibilität ermöglicht es ihnen, auf veränderte Bedingungen zu reagieren, während Interaktion die Fähigkeit bezeichnet, mit anderen Agenten oder Systemen zu kooperieren.

Moderne Sprachmodelle, wie die von OpenAI, Google oder Microsoft, lassen sich als intelligente Agenten betrachten. Sie reagieren autonom auf Eingaben und generieren kontextabhängige Antworten. Die Fähigkeit, natürlichsprachliche Texte zu verstehen und zu produzieren, macht sie zu leistungsfähigen Agenten in der Kommunikation, die flexibel auf Benutzeranfragen reagieren und komplexe Aufgaben wie Dialogführung oder Problemlösung übernehmen können. Da liegt die Vermutung nahe, dass mehrere dieser Agenten-ähnlichen Systeme komplexere Aufgaben in der Softwareentwicklung im Allgemeinen und in der Qualitätssicherung im Speziellen lösen können. Eine alternative Idee ist es, Mikro-Agenten zu nutzen, um spezifische Aufgabenstellungen zu lösen. Durch den Fokus dieser speziellen Agenten ist es möglich, dass dahinterliegende Modelle nicht so schnell aus der Aufgabenstellung ausbrechen.

Sprachmodelle in der Qualitätssicherung

Sprachmodelle, wie sie durch fortschrittliche KI-Systeme wie GPT repräsentiert sind, bieten innovative Ansätze, um die Qualitätssicherung effizienter und präziser zu gestalten. Diese Modelle lassen sich nicht nur zur Analyse von Code und Unittests einsetzen, sondern auch zum proaktiven Erkennen potenzieller Schwachstellen und fehleranfälliger Muster im Code [3].

Sprachmodelle analysieren beispielsweise die Struktur, Syntax und Logik des Codes und vergleichen ihn mit bekannten Mustern aus hochwertigen Codebasen. Durch diese automatische Analyse lässt sich die Qualität des Codes und der Unittests objektiv bewerten. Das ermöglicht eine schnelle Rückmeldung über die Stabilität und Sicherheit des Codes, bevor er in größere Systeme integriert wird.

Ein wesentlicher Vorteil liegt in der Fähigkeit von Sprachmodellen, Code nicht nur auf Syntaxebene, sondern auch im Hinblick auf logische Zusammenhänge zu überprüfen. Die Modelle können erkennen, ob bestimmte Codestücke effizient geschrieben sind oder ob mögliche Fehlerquellen wie ungenutzte Variablen, nicht behandelte Ausnahmen oder Redundanzen vorliegen.

Das bietet zahlreiche Möglichkeiten, die Modelle für Analysen und Verbesserungen einzusetzen. Dieser Artikel widmet sich in diesem Kontext der Möglichkeit, ein Sprachmodell als Agent wahrzunehmen und mit Daten, Code, Fragen, Ergebnissen und Rückfragen zu füttern, um nicht nur funktionierenden, sondern im besten Fall fehlerfreien Code zu erzeugen.

Klassische Agenten und Mikro-Agenten

Agentensysteme haben in der Softwareentwicklung ein breites Einsatzspektrum, insbesondere in der Testcodierung. Sie ermöglichen eine Automatisierung und Optimierung von Testprozessen, was zu einer höheren Effizienz und Qualitätssicherung führt. Ihre Fähigkeit, autonom und intelligent auf sich verändernde Umgebungen zu reagieren, macht sie zu einem unverzichtbaren Werkzeug für die Generierung, Analyse und Verbesserung von Unittests.

Ein weiteres Konzept ist das des Micro Agent [1] oder Mikro-Agenten. Das ist ein spezifisches Konzept innerhalb der Künstlichen Intelligenz (KI), insbesondere im Bereich der Multi-Agenten-Systeme. Es handelt sich dabei um eine einfache, oft spezialisierte Softwareeinheit, die in der Regel eine kleine und klar definierte Aufgabe erfüllt. Mikro-Agenten sind in ihrer Funktionalität stark fokussiert und meist darauf ausgelegt, in einer kooperativen Umgebung mit anderen Mikro-Agenten oder größeren Agentensystemen zu arbeiten. Die Bezeichnung Mikro beschreibt somit nicht zwingend den Funktionsumfang, sondern die Spezifität und die Fokussierung auf ein eng abgestecktes Aufgabengebiet. Die Hauptmerkmale eines Mikro-Agenten lassen sich wie folgt zusammenfassen:

• spezialisierte Aufgaben: Ein Mikro-Agent hat eine klar begrenzte Funktion oder Aufgabe, die er erledigen soll. Diese Aufgaben sind oft eng umrissen und können von der Überwachung eines bestimmten Prozesses bis hin zu einer spezifischen Datenanalyse reichen.
• Kooperation: Mikro-Agenten agieren häufig in Multi-Agenten-Systemen, in denen sie mit anderen Agenten zusammenarbeiten, um komplexere Aufgaben zu lösen. Sie kommunizieren und koordinieren ihre Aktivitäten, um das Gesamtsystem zu unterstützen.
• Autonomie: Ein Mikro-Agent handelt autonom in dem Sinne, dass er selbstständig Entscheidungen trifft, wie er seine Aufgabe erfüllen soll, basierend auf seiner Programmierung und den Informationen, die er erhält.
• leichtgewichtig und ressourcenschonend: Im Vergleich zu größeren Agenten oder Systemen sind Mikro-Agenten in der Regel weniger komplex, was bedeutet, dass sie weniger Rechenressourcen benötigen und einfacher zu implementieren und zu verwalten sind.
• Modularität: Durch ihre spezialisierte und klar abgegrenzte Funktion sind Mikro-Agenten leicht in größere Systeme integrierbar und können flexibel hinzugefügt oder entfernt werden, ohne das gesamte System zu stören.
• Skalierbarkeit: Ein System, das auf Mikro-Agenten basiert, lässt sich durch Hinzufügen oder Entfernen von Agenten leicht skalieren. Das ist besonders nützlich in dynamischen Umgebungen, wo die Anforderungen schnell ändern können.

Ein praktisches Beispiel wären Mikro-Agenten in einem E-Commerce-System, wo ein Agent für das Tracking von Bestellungen, ein anderer für die Preisüberwachung und wieder ein anderer für die Kundenkommunikation zuständig ist. Sie arbeiten zusammen, um eine vollständige Lösung zu bieten, aber jeder Agent bleibt auf seine spezifische Funktion fokussiert.

Mikro-Agenten(-Systeme) in der Codeerzeugung

Agentensysteme sind in der Lage, automatisch Unittests zu erstellen, indem sie den Quellcode analysieren und basierend auf Spezifikationen passende Testfälle generieren. Das beschleunigt im besten Fall den Entwicklungsprozess, da weniger manuelle Arbeit erforderlich ist. Bei Codeänderungen erstellen Agenten automatisch neue Testfälle, um die Kompatibilität sicherzustellen. Sie identifizieren auch Randfälle und Testlücken, um die Robustheit der Tests zu verbessern. Zudem können Agentensysteme auf fehlschlagende Tests reagieren, problematische Codeabschnitte erkennen und Vorschläge zur Fehlerbehebung machen, was die Effizienz im Entwicklungsprozess steigert.

Insbesondere dieser letzte Punkt ist ein guter Anwendungsfall für einen Mikro-Agenten. Dadurch lässt sich das Problem vieler aktueller KI-Assistenten in der Softwareentwicklung lösen, die zwar auf Aufforderung schnell und viel Code erzeugen, der aber häufig nicht gut funktioniert. Das führt zu einer Schleife von Codeerzeugung, Fehlersuche, neuem Prompt an die KI, Codeerzeugung und wieder von vorne. Abbildung 1 verdeutlicht das mit der Aussage, dass Fehler nach der Codeerzeugung ein Problem des Benutzers sind.

Abb. 1: Darstellung der Unterscheidung bei einem fehlerhaft erzeugten Code als Benutzerproblem

Die Grundidee dieser Codegenerierung passt sehr gut auf einen Mikro-Agenten, denn die Codeerzeugung ist auf einen sehr spezifischen Anwendungsfall hin eingeschränkt. Das erlaubt es uns, dem hinter dem Agenten liegenden Sprachmodell eine sehr spezifische Anweisung zu geben, das Ergebnis der Erzeugung zu prüfen und bei Ausführungsfehlern diese an das Sprachmodell zu geben, mit dem Prompt, es doch noch einmal zu versuchen. Ein typischer Workflow für die Zusammenarbeit mit so einem Mikro-Agenten sieht dann wie folgt aus:

• Funktionsbeschreibung: Eine Beschreibung der Funktion oder des Codes, den wir erzeugen wollen. Die Beschreibung erfolgt als Anweisung in natürlicher Sprache so wie bei vielen anderen Sprachmodellen auch.
• Testerzeugung: Basierend auf diesem Prompt, in Kombination mit vordefinierten Anweisungen, erzeugt der Agent einen Unittest, um das Verhalten der gewünschten Funktion oder des gewünschten Codes zu erfüllen. Hier erzeugt das Sprachmodell auch direkt Beispiele für Eingabe- und Ausgabedaten. Die Testdatenerstellung ist somit direkt inkludiert. Mit Bezug auf den spezifischen Anwendungsfall der Testerzeugung sowie auf den beschriebenen Code oder die beschriebene Funktion, die wir erzeugt haben möchten.
• Codeerzeugung: Nachdem die Funktionsbeschreibung, der Unittest und die Testdaten vorliegen, versucht sich der Mikro-Agent daran, den funktionalen Code in einer angegebenen Programmiersprache zu erzeugen. Hier kommt wieder das zugrunde liegende Sprachmodell zum Einsatz.
• Codeausführung und Iteration(en): Der Agent führt die Tests aus und schaut sich die Ergebnisse an. Schlagen die Tests fehl, beispielsweise durch Syntaxfehler oder weil die erzeugten Ausgaben nicht mit den erwarteten Ergebnissen übereinstimmen, dann nutzt der Agent die Fehlermeldungen und gewonnen Daten, um den Quelltext der gewünschten Funktion anzupassen. Die Tests werden nicht angepasst, sondern anschließend erneut ausgeführt, um die Resultate zu prüfen.

Diese Art von Agentensystemen bieten einen erheblichen Mehrwert für die Code- und Testerzeugung, indem sie Prozesse automatisieren, die Testabdeckung optimieren und potenzielle Fehler frühzeitig aufdecken. Durch die intelligente Analyse und Anpassung von Code und Tests tragen Agentensysteme wesentlich zur Qualitätssicherung bei und ermöglichen es, sich auf komplexere Aufgaben zu konzentrieren, während Routineaufgaben von den Agenten übernommen werden.

Implementierungsideen und Beispiel

Eine Implementierungsidee für so einen Mikro-Agenten ist ein Prompt, der das Sprachmodell auffordert, die Aufgabe zu erfüllen, aktuellen Code zu berücksichtigen, Tests auszuführen, einen Fehler zu berücksichtigen sowie den Code neu zu implementieren oder zu aktualisieren und dabei Richtlinien zum Code-Style und zu verwendeten Paketen einzuhalten. Das könnte beispielsweise wie in Listing 1 aussehen.

Bitte erfülle die nachfolgende Aufgabe:
<task>
Der aktuelle Code lautet:
<current-code>
Der Testcode lautet wie folgt:
<test-code>
Der Fehler dieses Codes lautete:
<code-error>
Bitte aktualisiere den Code, oder generiere ihn neu, wenn erforderlich, um die Aufgabe zu erfüllen und den Tests zu entsprechen.

Dieser komplexere Prompt, in Kombination mit den Eingabedaten, reicht bereits aus, um sehr gute Ergebnisse zu erzielen. Dieser Prompt kann Code erzeugen und vorhandenen Code nutzen. Zudem werden bereits erzeugte Tests für die Ausführung und für den Check der Ausgaben genutzt.

Um diese Tests initial auf Basis eines Prompts mit Aufgabenbeschreibung zu erzeugen, lässt sich das Prompt-Beispiel aus Listing 2 nutzen.

Du gibst ausschließlich Code für Unit Tests zurück. Keine weiteren Wörter, nur den Code.
Bitte erzeuge Test für die folgende Aufgabe:
<task>
Lege den Code an die folgende Stelle ab:
<location>

Das ist ebenfalls ein recht einfacher Prompt. In Kombination mit dem dritten Prompt, der einen Test und Feedback zu diesem Test verarbeitet, lassen sich alle weiter oben beschriebenen Anforderungen umsetzen. Diesen Prompt zeigt Listing 3.

Du gibst ausschließlich Code für Unit Tests zurück. Keine weiteren Wörter, nur den Code.
Hier ist ein Unit-Test, der auf Basis der folgenden Aufgabe erzeugt wurde:
<task>
Der konkrete Test-Code lautet:
<test-code>
Zu diesem Test gibt es das folgende Feedback. Bitte aktualisiere den Code, oder schreibe den Code neu, damit der Test dem Feedback entspricht.
<feedback>
Bitte gib nur den Code zurück, der den Fehler adressiert.

Die Kombination aus diesen drei Prompts, der Aufgabenstellung und den erzeugten Tests und Testdaten erlaubt es, einen Mikro-Agenten zu implementieren, der die oben beschriebenen Anforderungen erfüllt. Listing 4 zeigt einen Ausschnitt aus den so erzeugten Tests für eine Python-Funktion, um eine Zahl auf eine Primzahl zu prüfen.

const isPrime = require('./check-prime');

describe('isPrime', () => {
  // Test for a small prime number
  test('should return true for a small prime number', () => {
    expect(isPrime(3)).toBe(true);
  });

  // Test for a small non-prime number
  test('should return false for a small non-prime number', () => {
    expect(isPrime(4)).toBe(false);
  });

  // Test for the smallest prime number
  test('should return true for the smallest prime number', () => {
    expect(isPrime(2)).toBe(true);
  });

  // Test for the smallest non-prime number
  test('should return false for the smallest non-prime number', () => {
    expect(isPrime(1)).toBe(false);
  });

  // Test for zero
  test('should return false for zero', () => {
    expect(isPrime(0)).toBe(false);
  });

  // Test for a negative number
  test('should return false for a negative number', () => {
    expect(isPrime(-5)).toBe(false);
  });

  // Test for a larger prime number
  test('should return true for a larger prime number', () => {
    expect(isPrime(29)).toBe(true);
  });
});

Der Mikro-Agent hat die inhaltlich und Code-technisch gut aussehenden Tests innerhalb weniger Sekunden erzeugt. Ebenso wie die konkrete Funktion für die Prüfung.

Das Unternehmen BuilderIO hat so einen Mikro-Agent in Python umgesetzt. Dieser lässt sich über das verlinkte Repository auf GitHub (github.com/BuilderIO/micro-agent) auschecken/herunterladen und direkt ausprobieren.

Und was ist mit anderen Tools?

Bei der Beschreibung dieser Art von Mikro-Agenten kommt schnell die Frage auf, ob es nicht schon Systeme gibt, die genau das Versprochene umsetzen? Die Antwort ist ambivalent, denn grundsätzlich gibt es bereits Angebote, die aber anders vorgehen.

• Auto-GPT (agpt.co) ist beispielsweise ein autonomes KI-System, das auf OpenAIs GPT-Modellen basiert. Die Plattform ist entstanden, um eine Aufgabe zu automatisieren, indem es kontinuierlich Ziele verfolgt und Zwischenziele definiert, ohne dass Benutzer ständig eingreifen müssen. Auto-GPT kombiniert mehrere GPT-Instanzen, um komplexe Aufgaben zu lösen und dabei mehrere Schritte durchzuführen, was über die Fähigkeiten eines einzelnen GPT-Modells hinausgeht.
• Auto-GPT funktioniert, indem es die GPT-3- oder GPT-4-Sprachmodelle verwendet, um Aufgaben autonom zu planen und auszuführen. Benutzer geben ein Ziel ein, und Auto-GPT generiert dann nicht nur eine Lösung, sondern auch weitere Teilaufgaben, die zum Erreichen des Ziels erforderlich sind. Dabei agiert es wie ein Agent, der auf der Grundlage der Ergebnisse Entscheidungen trifft, neue Ziele definiert und sich selbst Feedback gibt, um die Strategie anzupassen. Es kann Informationen aus verschiedenen Quellen wie dem Internet oder eigenen gespeicherten Datenbanken verwenden, um den Aufgabenverlauf zu steuern.
• BabyAGI ist ein ähnliches KI-Tool, das darauf abzielt, ein autonomes System zu schaffen, das sich selbst Feedback gibt und kontinuierlich arbeitet, um Aufgaben zu erfüllen. BabyAGI nutzt ebenfalls GPT-Modelle, kombiniert diese aber mit einer Task-Manager-Komponente, um verschiedene Aufgaben zu priorisieren und umzusetzen. BabyAGI bietet dabei ein flexibles Framework, eine Task-Verwaltung und Selbstkorrekturmechanismen.
• Die Anwendung AgentGPT bietet eine webbasierte Plattform, auf der Benutzer KI-Agenten erstellen können, die in der Lage sind, selbstständig Aufgaben auszuführen. Es ähnelt Auto-GPT in der Funktionsweise und erfordert keine tiefgehenden technischen Kenntnisse. Die Plattform ist nutzerfreundlich, cloudbasiert und skalierbar für unterschiedliche Aufgaben.
• LangChain ist eine Open-Source-Bibliothek, die es ermöglicht, größere KI-basierte Arbeitsabläufe zu erstellen, indem sie GPT-Modelle in verschiedene Pipelines integrieren. Sie ermöglicht das Erstellen komplexer Anwendungen durch die Verknüpfung mehrerer Tools und APIs. Die Bibliothek ist sehr flexibel, Open Source, stark anpassbar und bietet die Integration verschiedener Sprachmodelle.
• Jarvis, auch als Jarvis GPT bekannt, ist ein KI-System, das auf GPT-Modellen basiert und Benutzern hilft, komplexe Aufgaben zu bewältigen. Es ist für den Einsatz in verschiedenen Branchen optimiert und darauf ausgelegt, Inhalte, Analysen und strategische Empfehlungen zu erstellen. Die Plattform bietet die Automatisierung von Geschäftsprozessen, eine Inhaltsgenerierung und verschiedene Analysetools.

Diese Art von vielseitigen KI-Plattformen oder Agenten ist somit nicht neu. Automatisieren können diese Systeme die unterschiedlichsten Aufgaben aus den verschiedensten Bereichen. Der Unterschied zu Mikro-Agenten ist, dass diese Form von Agenten deutlich stabiler ist und sich erheblich besser auf das Aufgabengebiet fokussiert. Der Hintergrund ist, dass die Unittests dafür sorgen, dass der Agent nicht so schnell aus der Bahn geworfen wird, wie die Abbildung 2 verdeutlicht.

Abb. 2: Unittests als Checkpunkt, um die Codegenerierung des Modells in Bahnen zu lenken

Während andere Systeme in einer Endlosschleife gefangen sein können, sorgen die Tests dafür, dass ein Mikro-Agent nicht vom Weg abkommt und gleichzeitig schneller und präziser zu einem funktionierenden Ziel kommt. Hier schließt sich der Kreis zwischen Menschen und Maschine wieder. Unittests können auch menschlichen Entwicklern dabei helfen, nicht vom richtigen Code-Weg abzukommen und das Ziel im Auge zu behalten. Nichts anderes passiert bei Sprachmodellen in Form dieser Art von Mikro-Agenten. Ein Test ist eine sehr gute Richtlinie und eine sehr klare Definition von Erfolg.

Mikro-Agenten im aktuellen KI-Kosmos

Tools wie GitHub Copilot bieten während des Tippens Vorschläge zur Codevervollständigung. Diese Inline-Codevervollständigung ist nützlich, um schnell Standardcode oder häufige Muster zu schreiben. Allerdings sind diese Vorschläge lokal begrenzt und garantieren keine vollständige Korrektheit des Codes.

KI-Assistenten wie ChatGPT ermöglichen es, in natürlicher Sprache zu beschreiben, was man programmieren möchte, und generieren daraufhin Code-Snippets. Diese konversationsfähigen Code-Assistenten sind hilfreich, um Ideen zu entwickeln oder Blockaden zu überwinden, aber der generierte Code ist oft manuell anzupassen.

Die Aufgabe eines Mikro-Agenten ist es nicht, Inline-Vervollständigung, konversationsfähige Assistenten oder andere KI-zu-Code-Tools zu ersetzen. Stattdessen fokussiert sich diese Möglichkeit auf das spezifische Anwendungsgebiet der zuverlässigen Generierung vollständiger Funktionen, wobei Tests als Leitplanken dienen. Die Stärken so eines Mikro-Agenten sind lokal begrenzte Funktionen, die aber eine gute Testabdeckung besitzen, sodass der Code am Ende korrekt und verlässlich funktioniert.

Herausforderungen und Grenzen von Agentensystemen

Agentensysteme bieten in der Softwareentwicklung und Qualitätssicherung viele Vorteile, stoßen jedoch auf technische und ethische Herausforderungen. Der Einsatz von KI-gestützten Agenten wirft Fragen zur Verlässlichkeit, Sicherheit und Kontrolle auf.

Technisch gesehen sind Agentensysteme oft komplex und ressourcenintensiv. Diese Aussage mag kontraintuitiv zu einer vorherigen Passage in diesem Artikel sein, dass Mikro-Agenten kleine und überschaubare Softwaresysteme sind. Das ist auch korrekt, aber die Kombination von vielen Mikro-Agenten ist wiederum komplex. Ihre Implementierung erfordert tiefgreifendes Wissen über maschinelles Lernen und die Anwendungsfälle. Darüber hinaus besteht die Gefahr, dass KI-gestützte Agenten unvorhergesehene Entscheidungen treffen, was bei sicherheitskritischen Anwendungen problematisch sein kann. Ethische Herausforderungen betreffen vor allem den Einfluss von automatisierten Entscheidungen auf Menschen. Eine unzureichend überwachte Automatisierung könnte etwa negative Konsequenzen in der Arbeitswelt haben oder Vorurteile in den Algorithmen verstärken.

Obwohl Agentensysteme die Testcodierung effizienter gestalten können, gibt es Grenzen der Automatisierung. Nicht alle Aspekte der Softwareentwicklung lassen sich (aktuell) vollständig durch KI abbilden. Komplexe, kreative Problemstellungen erfordern menschliches Urteilsvermögen, und automatisierte Testverfahren stoßen an ihre Grenzen, wenn sie dynamische oder nicht vorhersagbare Anforderungen adressieren müssen. Zudem besteht das Risiko, dass automatisch generierte Tests ungenaue oder irreführende Ergebnisse liefern, insbesondere bei unzureichend trainierten Systemen.

Fazit und Einschätzung

Mikro-Agenten, basierend auf Sprachmodellen, weiten ihren Einfluss auf die Softwareentwicklung aus, indem sie präzise und spezialisierte Aufgaben bei der Code- und Testerzeugung übernehmen. Diese kleinen, autonom agierenden Einheiten analysieren Code, generieren passende Unittests und beheben Fehler eigenständig, indem sie Testfehlschläge auswerten und den Code entsprechend anpassen. Dies führt zu einer schnelleren Entwicklung und einer höheren Codequalität, da potenzielle Schwachstellen frühzeitig erkannt und adressiert werden.

Durch ihre Fokussierung auf eng umgrenzte Aufgaben bleiben Mikro-Agenten effizient und ressourcenschonend, ohne aus der Aufgabenstellung „auszubrechen“. Besonders in dynamischen Umgebungen können sie ihre Stärken ausspielen, da sie flexibel auf Änderungen reagieren und sich leicht in größere Systeme integrieren lassen. Die Automatisierung durch diese Agenten reduziert manuelle Arbeitsschritte und sorgt dafür, dass Entwickler sich auf komplexere Problemstellungen konzentrieren können, während Agenten Routineaufgaben zuverlässig erledigen.

Die gezielte Anwendung von Tests stellt sicher, dass die von Mikro-Agenten erzeugten Lösungen robust und fehlerfrei sind. So können die Agenten beispielsweise nicht nur Code schreiben, sondern auch selbstständig Fehler identifizieren und beheben, indem sie auf Testfehler reagieren. Diese Methode verhindert, dass die Agenten in eine endlose Schleife von fehlerhaftem Code und neuen Korrekturen geraten, was bei generativen KI-Modellen häufig der Fall ist.

Mikro-Agenten haben damit das Potenzial, eine vielversprechende Lösung für die Herausforderungen in der modernen Softwareentwicklung und Qualitätssicherung zu bieten. Vor allem, wenn es um die Automatisierung von Aufgaben geht, die eine hohe Präzision und Zuverlässigkeit erfordern. Die ersten Ansätze in diesem Bereich sind vielversprechend. Es ist spannend zu beobachten, wie die Community diese Ansätze weiterentwickelt und in welchem Umfang größere Anbieter von Sprachen und Tools mitmischen möchten.

Literaturverzeichnis

[1] S. S. Borysov, J. Rich, F. C. Pereira, How to generate micro-agents? A deep generative modeling approach to population synthesis, in: Transportation Research Part C: Emerging Technologies, 106(1), Seiten 73 – 97, 2019

[2] L. Crispin, Driving Software Quality: How Test-Driven Development Impacts Software Quality, in: IEEE Software, 23(6), Seiten 70-71, 2026

[3] F. Deitelhoff, Test- und Testdatengenerierung mit Large Language Models, in: German Testing Magazin, 1/2024, siehe: www.sigs.de/artikel/test-und-testdatengenerierung-mit-large-language-models

[4] C. Ebert, P. Louridas, Generative AI for Software Practitioners, in: IEEE Software, 40(4), Seiten 30- 38, 2023

[5] N. Tihanyi et al., A New Era in Software Security: Towards Self-Healing Software via Large Language Models and Formal Verification, preprint arXiv:2305.14752, 2023, siehe: arxiv.org/pdf/2305.14752