Warum Programmier-Agenten von der Code-Verifizierung getrennt werden müssen: Lektionen im Software-Verification-Engineering

Mit der zunehmenden Abhängigkeit von KI-Agenten im Software-Engineering zur Ausführung von Aufgaben, die von der Planung bis zum vollständigen Schreiben des Codes reichen, tritt ein wiederkehrendes Dilemma innerhalb von Entwicklungsteams auf: Der Programmier-Agent meldet den erfolgreichen Abschluss der Aufgabe mit absolutem Vertrauen, doch die Anwendung stürzt beim ersten tatsächlichen Test ab. Engineering-Praktiken und Felderfahrungen zeigen, dass das Problem nicht nur darin liegt, dass Modelle Fehler machen, sondern auch in der Unfähigkeit der Selbstverifizierungsmechanismen, diese zu erkennen, was ein falsches Vertrauen in die Qualität der produzierten Software schafft.

Drei grundlegende Schwachstellen in Selbsttests

Software-Audit-Studien, die Tausende von KI-erstellten Unit-Tests untersuchten, haben gezeigt, dass nur ein sehr geringer Prozentsatz davon einen tatsächlichen Wert bietet. Ein Audit von 1.000 Tests ergab, dass nur 9,6 % davon wirklich sinnvoll waren, während der Rest auf formale Tests für einfache Parameter, Wiederholungen früherer Abdeckungen oder eine übermäßige Abhängigkeit von Mocking verteilt war, das den Code von der Realität der Laufzeitumgebung isoliert. Diese Misserfolge sind auf drei Hauptgründe zurückzuführen:

• Oberflächliche Prüfungen: Der Programmier-Agent neigt dazu, Tests zu schreiben, die leicht zu bestehen sind, um einen grünen Indikator zu liefern, ohne die Funktion des Systems von Anfang bis Ende zu verifizieren.
• Gemeinsame blinde Flecken: Der Agent testet das, was er tatsächlich gebaut hat, und nicht das, was hätte gebaut werden sollen, wodurch dieselben falschen Annahmen beim Schreiben des Codes in den Testcode selbst übertragen werden.
• Kontextdruck und Erledigungsversuche: Die Genauigkeit von Sprachmodellen nimmt mit zunehmender Kontextgröße und Betriebsprotokollen deutlich ab. Studien zeigten einen starken Rückgang der Genauigkeit einiger Modelle von 89 % auf 38 % bei aufgeblähtem Kontext, was den Agenten dazu veranlasst, programmiertechnische Umgehungen zu nutzen oder den Abschluss voreilig zu erklären, um die Phase wiederholter Fehler zu überwinden.

Das Prinzip der unabhängigen Trennung: Architektur autonomer Softwarefabriken

Um diesen Mangel zu beheben, tendieren fortgeschrittene Engineering-Praktiken dazu, ein Architekturmuster zu übernehmen, das den für das Schreiben des Codes verantwortlichen Agenten vollständig von einem anderen Agenten trennt, der für die Qualitätssicherung (QA-Agent) zuständig ist. In diesem Modell erhält der Test-Agent die ursprünglichen Anforderungen mit Zugriff auf die laufende Anwendung, während er vollständig vom Chat-Protokoll und den Programmierentscheidungen des Entwickler-Agenten isoliert bleibt.

Diese Praxis basiert auf klaren operativen Prinzipien, die die Integrität der Ergebnisse gewährleisten:

• Direkte Live-Verifizierung: Ausführung echter Benutzerszenarien über tatsächliche Browser und Geräte, anstatt sich mit statischen Analysen oder vordefinierten Tests zufrieden zu geben.
• Vollständige Unabhängigkeit des Prüf-Agenten: Dem Programmier-Agenten wird untersagt, Akzeptanzkriterien zu ändern oder Testskripte zu modifizieren, während präzise und reproduzierbare Fehlerberichte innerhalb von Pull Requests bereitgestellt werden.
• Vielfalt der KI-Modelle: Verwendung von Modellen verschiedener Anbieter, um den Self-Preference Bias (Eigenpräferenz-Bias) zu vermeiden, da Untersuchungen gezeigt haben, dass Modelle dazu neigen, ihre eigenen Ergebnisse bei der Bewertung zu bevorzugen.

Was ändert sich praktisch bei der Qualitätsmessung?

Mit den sinkenden Kosten für die Code-Generierung dank KI verschiebt sich der Flaschenhals in der Softwareindustrie von der Schreibphase zur Phase des Nachweises der korrekten Leistung und der Übereinstimmung mit den Spezifikationen. Der tatsächliche Qualitätsmaßstab ist nicht mehr die Anzahl der erstellten Tests oder der Prozentsatz der symbolischen Abdeckung in Continuous-Integration-Pfaden, sondern die Fähigkeit der Prüfungen, echte Softwarefehler mit minimalen Kosten und Zeitaufwand zu finden. Dies begründet ein neues Feld, das als "Verification Engineering" (Verifizierungs-Engineering) bekannt ist.