Zum Inhalt springen
Reality Graph

Methode

Der Soll-Ist-Abgleich

Zuletzt aktualisiert: 2026-08-15Lesezeit ca. 5 Min.

Der Soll-Ist-Abgleich prüft KI-generierten Code gegen einen schriftlichen Auftrag - Ziel, Grenzen, Akzeptanzkriterien - statt gegen die Erinnerung an den Prompt. Aus „sieht richtig aus“ wird ein Ja/Nein-Vergleich, und das Review bekommt einen externen Bezugspunkt, den das generierende Modell nicht beeinflussen kann.

„Tests laufen durch“vom Agenten gemeldetexit code 0von Reality Graph gestartetBelegnur die Ausführung zählt
Inhalt

Warum „sieht richtig aus“ nicht mehr reicht

Die Zahlen beschreiben ein merkwürdiges Gleichgewicht: In Sonars State-of-Code-Umfrage 2026 sagen 96 % der Entwickler, sie vertrauten KI-generiertem Code nicht voll - aber nur 48 % prüfen ihn immer vor dem Commit, und 53 % berichten von KI-Code, der korrekt aussieht, aber nicht zuverlässig ist. Gleichzeitig stammen laut derselben Umfrage bereits rund 42 % des committeten Codes von KI. Misstrauen ohne Methode wird zu Resignation.

Der Fehlermodus ist spezifisch: KI-Code scheitert selten laut, sondern in der Lücke zwischen dem, was die Anforderung meinte, und dem, was das Modell darunter verstanden hat. Ein Diff-Review kann diese Lücke nicht fangen, denn der Diff zeigt nur, was gebaut wurde - nicht, was beauftragt war. Das fehlende Artefakt ist der schriftliche Auftrag, und jeder Merge ohne ihn zahlt auf die Verification Debt ein.

Das Zirkularitätsproblem: ein Modell prüft sich selbst

Der naheliegende Fix - die KI testet und reviewt ihren eigenen Output - hat einen strukturellen Haken: Beide Seiten des Vergleichs entstammen denselben Annahmen. Tests, die das generierende Modell schreibt, prüfen, was das Modell angenommen hat - und das ist subtil etwas anderes als das, was gefordert war. Aktuelle Forschung zu KI-gestütztem Review kommt zum selben Schluss: die Spezifikation ist das Quality Gate, gerade weil sie eine Referenz einführt, die unabhängig vom Modell existiert - ohne sie prüft das Review den Code gegen sich selbst.

Wie groß die Selbstbewertungslücke werden kann, ist dokumentiert: Ein Team hat 449 KI-Code-Reviews nachgemessen - das System bewertete sich selbst mit 98,6 % Validität, die unabhängige Validierung ergab 69 %. Dreißig Punkte zwischen Selbstbild und Realität. Die Konsequenz heißt nicht „kein KI-Review“, sondern: Referenz und Generator trennen.

Der Abgleich in fünf Schritten

Tool-agnostisch - funktioniert mit Claude Code, Cursor, Copilot und jedem anderen Agenten:

  1. Das Soll vor dem Run aufschreiben. Ein Zielsatz, die Grenzen (welche Dateien und welches Verhalten tabu sind) und 3-7 Akzeptanzkriterien. Fünf Minuten, Klartext.
  2. Jedes Kriterium prüfbar machen. „Liefert bei 429-Antworten einen korrekten Retry-After-Header“ ist prüfbar; „verbessert das Rate-Limiting“ nicht. Wer keine Ja/Nein-Frage formulieren kann, schärft das Kriterium nach.
  3. Das Tool unverändert laufen lassen. Die Methode stellt nichts zwischen euch und den Agenten - gleiche Prompts, gleiches Tempo.
  4. Das Ist gegen das Soll abgleichen. Den Diff Kriterium für Kriterium durchgehen. Änderungen außerhalb des Scopes sind Befunde, auch wenn sie wie Verbesserungen aussehen - im Scope Creep verstecken sich die stillen Regressionen.
  5. Das Ergebnis festhalten. Welche Kriterien bestanden, was übersprungen wurde, was offen bleibt - wenige Zeilen, beim Code gespeichert. Genau diese Notiz formalisiert ein Prüfbericht.

Das ganze Artefakt bleibt auf einen Blick lesbar:

soll-ist-abgleich.md

Beispiel - keine echten Run-Daten
SOLL (vor dem Run geschrieben)
Ziel:      Korrekten Retry-After-Header bei 429-Antworten liefern
Grenzen:   nur api/middleware/* · Rate-Limit-Logik unangetastet
Kriterien: [1] Header bei jeder 429        [2] Wert = Rest des Fensters
           [3] 2xx/4xx-Pfade unverändert   [4] Unit-Tests grün

IST (nach dem Run geprüft)
[1] BESTANDEN  [2] BESTANDEN
[3] NICHT BESTANDEN - 403-Handler mitgeändert (außerhalb des Scopes)
[4] BESTANDEN (61 grün, 3 neu - vor dem Run geschrieben)

Ergebnis:  VERWORFEN → neuer Run mit Grenz-Hinweis · [3] erneut prüfen

Grenzen und typische Fehler

  • Soll-Theater. Ein Soll, gegen das niemand abgleicht, ist Ritual statt Verifikation. Der Abgleich ist der Punkt - das Dokument nur sein Input.
  • Überspezifikation. Wer die Implementierung statt der Absicht beschreibt, produziert Vorgaben, die schlecht altern und übersprungen werden. Festhalten, was gelten muss - nicht, wie es zu bauen ist.
  • Der Abgleich fängt nicht, was das Soll vergisst. Geprüft wird die formulierte Absicht. Anforderungen, an die niemand gedacht hat, bleiben ungeprüft - deshalb behandelt die Forschung Intent-Formalisierung als offene Grand Challenge, nicht als gelöstes Problem.
  • Das Festhalten überspringen. Ein nicht dokumentierter Abgleich verdunstet. Einen Monat später kann niemand einen verifizierten Merge von einem glücklichen unterscheiden.

Wo Reality Graph ansetzt

Alles oben funktioniert manuell - mit einer Textdatei und Disziplin. Reality Graph systematisiert genau diese Methode: Das Soll wird zu einer strukturierten Auftragsdatei mit festgelegten Grenzen, das Ist wird nach dem Run dagegen geprüft, und das Ergebnis landet in einem prüfbaren Bericht - eingebettet in den größeren Verifikations-Loop.

Die Methode liefert

  • Einen externen Bezugspunkt, den das Modell nicht beeinflusst
  • Einen Ja/Nein-Vergleich statt „sieht richtig aus“
  • Scope-Creep-Erkennung als Nebeneffekt der Grenzen
  • Ein festgehaltenes Ergebnis, auf dem das nächste Review aufbaut

Sie leistet nicht

  • Anforderungen fangen, die das Soll nie enthielt
  • Tests, Typen oder Security-Review ersetzen
  • Formale Methoden erzwingen - Klartext genügt
  • Abhängigkeit von einem bestimmten KI-Tool erzeugen

Wenn diese Grenzen zu eurem Team passen:

FAQ

Wie verifiziert man KI-generierten Code systematisch?
Vor dem Run Ziel, Grenzen, Annahmen und Akzeptanzkriterien festhalten. Danach Diff-Review, Tests und Soll-Prüfungen ausführen, Abweichungen und genehmigte Ausnahmen dokumentieren und die Belege für eine menschliche Entscheidung bewahren. Konformität ist durch die Qualität des Solls begrenzt: Ein unvollständiges oder falsches Soll zu erfüllen, belegt keine geschäftliche Korrektheit.
Ist das nicht einfach Testen?
Tests sind ein Instrument innerhalb des Abgleichs, nicht der Abgleich selbst. Eine Testsuite prüft das Verhalten, an das der Testautor gedacht hat - und wenn dasselbe Modell Code und Tests schreibt, teilen beide dieselben Annahmen. Der Soll-Ist-Abgleich ergänzt den fehlenden Bezugspunkt: eine Auftragsbeschreibung, die unabhängig vom Modell existiert und gegen die Code, Tests und Scope verglichen werden.
Braucht es dafür formale Methoden?
Nein. Formale Verifikation ist die stärkste Ausprägung der Idee und ein aktives Forschungsfeld, aber die praktische Methode funktioniert in Klartext: ein Zielsatz, harte Grenzen, drei bis sieben prüfbare Akzeptanzkriterien. Der größte Teil des Nutzens entsteht schon dadurch, dass der Auftrag überhaupt schriftlich existiert - Strenge kann dort nachwachsen, wo das Risiko sie rechtfertigt.
Wie detailliert muss das Soll sein?
Detailliert genug für eine Review-Entscheidung, mit Annahmen, Ausschlüssen und dem Eigentümer von Ausnahmen. Ein Ja/Nein-Kriterium prüft nur die kodierte Eigenschaft; Mehrdeutigkeit, fehlende Anforderungen und geänderter Geschäftskontext bleiben Risiken. Akzeptierte Abweichungen dokumentieren, statt das Soll nach Sichtung der Implementierung still umzudeuten.
Was, wenn der Code schon existiert und es nie ein Soll gab?
Dann entsteht das Soll eben zur Review-Zeit: aufschreiben, was die Änderung nach eurem Verständnis leisten soll, und den Diff gegen diese Aussage prüfen. Das fühlt sich verkehrt herum an, bricht aber trotzdem die Zirkularität - der Code muss sich nicht mehr selbst erklären. Beim nächsten Run steht der Auftrag zuerst.
Bremst der Soll-Ist-Abgleich das Team aus?
Er verlagert Minuten an den Anfang der Aufgabe. Den Auftrag aufzuschreiben dauert etwa fünf Minuten; einen Diff gegen ein schriftliches Soll zu prüfen ist meist schneller, als aus dem Diff zu rekonstruieren, was gewollt war. Wirklich langsam macht Teams die Nacharbeitsschleife, wenn „sah richtig aus“-Code doch falsch war - 53 % der Entwickler kennen genau dieses Muster bei KI-Code.

Weiterlesen

Quellen

Wollt ihr sehen, wie euer letzter Agenten-Run ausgesehen hätte?

Zugang anfragen