Bewertungsschleife (Review Loop)
Iterativer Arbeiter-Prüfer-Zyklus innerhalb einer einzigen Sitzung. Du erledigst die Arbeit, erzeugst einen Prüfer-Subagenten, um sie zu kritisieren, überarbeitest sie auf Basis des Feedbacks und wiederholst den Vorgang, bis die Qualitätsschwelle erreicht ist.
Kernprinzip: Erste Entwürfe sind niemals endgültig. Iterative Kritik liefert bessere Ergebnisse als ein einzelner Durchlauf.
Plattformhinweis: Dieses Skill funktioniert am besten mit Agenten, die das Erzeugen von Subagenten unterstützen. Auf Plattformen ohne diese Fähigkeit simuliere den Prüfschritt, indem du einen neuen Chat-Kontext öffnest, nur das Arbeitsergebnis (ohne vorherige Überlegungen) einfügst und es bittest, eine Bewertung von 1-10 mit spezifischem Feedback zu geben.
Kurzanleitung
- Sage: "
Implementiere X, verwende review-loop" oder "Führe review-loop für die Datei aus, die ich gerade geschrieben habe" - Der Agent erledigt die Arbeit (oder liest vorhandene Arbeit)
- Ein separater Kritik-Subagent bewertet sie mit 1-10 und gibt spezifisches Feedback
- Der Agent überarbeitet und wiederholt, bis die Bewertung >= 8 (Standard-Qualitätsschwelle) ist
- Eine Zusammenfassung der Schleife wird mit der endgültigen Ausgabe geliefert
Wann verwenden
- Benutzer sagt "use review-loop", "polish this", "iterate on this", "/review-loop"
- Komplexe Implementierungen, bei denen Qualität wichtiger ist als Geschwindigkeit
- Designdokumente, Spezifikationen oder technische Texte
- Code, der robust sein muss (Sicherheit, Datenpipelines, Finanzlogik)
- Wenn der Benutzer eine adversarische Kritik in den Prozess eingebaut haben möchte
Wann NICHT verwenden
- Einfache Korrekturen, schnelle Änderungen, Einzeiler-Änderungen
- Aufgaben, bei denen Tests die Qualitätsschwelle sind (TDD + CI verwenden)
- Wenn der Benutzer es einfach schnell erledigt haben möchte
- Erkundungs-/Spike-Arbeiten, bei denen das Ziel Lernen und nicht Ausliefern ist
- Aufgaben ohne klare Abnahmekriterien – definiere diese zuerst, dann verwende review-loop
Standardeinstellungen
| Einstellung | Standard |
|---|---|
| Min. Schleifen | 2 |
| Max. Schleifen | 4 |
| Qualitätsschwelle | 8/10 |
| Arbeitsmodell | (dein aktuelles Modell) |
| Prüfmodell | (dein aktuelles Modell oder schnelle/ausgewogene Alternative) |
Modellauswahl
Die Prüferaufgabe bewertet Logik und Einschränkungen. Die Arbeiteraufgabe schreibt und ändert Code. Wähle die Fähigkeiten der Subagenten entsprechend aus.
KRITISCHE REGEL: Der Prüfer muss immer GLEICH oder LEISTUNGSFÄHIGER als der Arbeiter sein. Wenn der Prüfer schwächer als der Arbeiter ist, kann er komplexe Logik nicht richtig kritisieren oder subtile Regressionen erkennen.
| Aufgabenkomplexität | Arbeiterfähigkeit | Prüferfähigkeit | Begründung |
|---|---|---|---|
| Einfach/mechanisch (CRUD, Formatierung, Boilerplate) | Schnell / Leichtgewichtig | Ausgewogen | Leichtgewichtiger Arbeiter ist schnell, ausgewogener Prüfer erkennt Probleme leicht |
| Standard (Funktionen, Refaktorisierungen, Docs) | Ausgewogen | Ausgewogen | Gute Mischung aus Kosten, Geschwindigkeit und Qualität |
| Komplex (mehrere Dateien, Integration, Design) | Ausgewogen | Fortgeschritten / Reasoning | Fortgeschrittener Prüfer erkennt subtile Architekturprobleme, ausgewogener Arbeiter kann sie umsetzen |
| Sehr komplex (Sicherheit, Quant, verteilte Systeme) | Fortgeschritten / Reasoning | Fortgeschritten / Reasoning | Beide benötigen vollständigen Kontext und Denkfähigkeit. Der Prüfer MUSS die Leistung des Arbeiters erreichen. |
Die goldene Regel: Der Arbeiter muss klug genug sein, um auf das Feedback des Prüfers zu REAGIEREN. Wenn der Prüfer sagt "Behebe die Race-Condition mit einem kanalbasierten Semaphor" und der Arbeiter kann nicht über Parallelität nachdenken, wird die Schleife nicht konvergieren.
Eskalationssignal: Wenn sich die Bewertung nach 2 aufeinanderfolgenden Schleifen mit demselben Feedback nicht verbessert, ist das Arbeitermodell zu schwach. Eskaliere:
- Option A: Bitte den Benutzer, zu einem leistungsfähigeren Modell zu wechseln
- Option B: Senke die Qualitätsschwelle vorübergehend und weise den Benutzer auf die Lücke hin
- Option C: Zerlege die Aufgabe in kleinere Teilaufgaben und führe review-loop für jede aus
Standardverhalten: Da du (der Hauptagent) DER Arbeiter bist, erzeuge einen Prüfer-Subagenten, der deiner aktuellen Fähigkeit entspricht oder sie übertrifft, basierend auf der Aufgabe:
- Die meisten Aufgaben → Standard/Ausgewogener Prüfer
- Spezialisierte/schwierige Aufgaben → Fortgeschrittener/Reasoning-Prüfer
- Schnelle Überprüfungen → Schneller/Leichtgewichtiger Prüfer (nur wenn du auch als leichter Arbeiter agierst)
Benutzerüberschreibungen
Benutzer können jede Standardeinstellung inline mit ihrer Anfrage überschreiben. Analysiere diese natürlich:
"Implementiere X mit review-loop, Qualitätsschwelle 9, verwende fortgeschrittenes Modell für die Prüfung, max. 5 Schleifen"
"Polier das, mindestens 2 Schleifen, Schwelle bei 8"
"Führe review-loop mit schnellem Prüfer aus, max. 2 Schleifen"
"Verwende review-loop, Reasoning-Prüfer, Qualitätsschwelle 9, min. 3 max. 6"
Analyseregeln:
- "Qualitätsschwelle N" oder "Schwelle N" → quality_gate = N
- "[Modell]-Prüfer" oder "prüfen mit [Modell]" → Überschreibung des Prüfmodells
- "max. N Schleifen" → max_loops = N
- "min. N Schleifen" → min_loops = N
- Wenn der Benutzer nichts angibt, verwende die Standardwerte
- Wenn der Benutzer "gründlich" oder "streng" sagt → interpretiere als quality_gate 8, min_loops 2
- Wenn der Benutzer "schnell" oder "flott" sagt → interpretiere als max_loops 2, quality_gate 6
Der Prozess
flowchart TD
A[Arbeit erledigen] --> B[Prüfer-Subagenten erzeugen]
B --> C{Min. Schleifen erreicht?}
C -- nein, immer fortfahren --> E[Auf Basis des Feedbacks überarbeiten]
C -- ja --> D{Bewertung >= Qualitätsschwelle?}
D -- ja --> F[Endgültiger Feinschliff]
D -- nein --> G{Max. Schleifen erreicht?}
G -- ja, trotzdem anhalten --> F
G -- nein --> E
E --> B
F --> H([Fertig])
Schritt-für-Schritt
Schritt 1: Die Arbeit erledigen
Erledige die Aufgabe wie gewohnt. Schreibe den Code, erstelle die Spezifikation, implementiere die Funktion. Halte dich nicht zurück – erstelle deinen besten ersten Versuch.
Schritt 2: Prüfer-Subagenten erzeugen
Verwende das Agent-Tool, um einen Prüfer zu beauftragen. Der Prüfer muss:
- Ein separater Subagent sein (frischer Kontext, keine Verankerung an deine Überlegungen)
- Nur das Arbeitsergebnis erhalten (Dateien, Diffs) – nicht deinen Gedankengang
- Mit 1-10 bewerten mit spezifischem, umsetzbarem Feedback
- Standardmäßig ein ausgewogenes/Standard-Modell verwenden (oder ein fortgeschrittenes Reasoning-Modell für komplexe/spezialisierte Aufgaben)
Vorlage für den Prüfer-Prompt:
Du bist ein kritischer Prüfer. Bewerte die folgende Arbeit mit 1-10 und gib spezifisches, umsetzbares Feedback.
## Was gemacht wurde
{kurze Beschreibung der Aufgabe}
## Bewertungskriterien
{aufgabenspezifische Kriterien – was für DIESE Aufgabe wichtig ist}
Beispiele für gut formulierte Kriterien:
Für einen REST-API-Endpunkt:
- Korrekte HTTP-Statuscodes verwendet
- Eingabevalidierung für alle Parameter vorhanden
- Authentifizierung erzwungen; kein unauthentifizierter Zugriff
- Keine N+1-Abfragemuster
Für ein Designdokument:
- Problemstellung ist eindeutig
- Alternativen mit Abwägungen betrachtet
- Keine vagen Aussagen zur Implementierungskomplexität
- Erfolgsmetriken sind messbar
Für eine Datenpipeline:
- Idempotent – sicher wiederholbar
- Schemaänderungen werden elegant gehandhabt
- Fehlermodi dokumentiert
- Umgang mit personenbezogenen Daten (PII) adressiert
## Anweisungen
1. Lies die Arbeit sorgfältig
2. Bewerte mit 1-10, wobei:
- 1-3: Grundlegend fehlerhaft oder wichtige Anforderungen fehlen
- 4-6: Funktioniert, hat aber erhebliche Mängel
- 7-8: Gut, nur kleinere Probleme
- 9-10: Hervorragend, bereit zur Auslieferung
3. Liste spezifische Probleme mit Datei:Zeilen-Verweisen auf, wo anwendbar
4. Erkläre für jedes Problem, WARUM es wichtig ist und WAS zu beheben ist
5. Sei NICHT höflich – sei ehrlich und direkt
6. Gib deine Bewertung klar als "Bewertung: N/10" an
## Zu prüfende Dateien
{Dateiinhalte einfügen oder Dateipfade mit relevanten Auszügen auflisten}
Schritt 3: Feedback analysieren
Aus der Prüferantwort extrahieren:
- Bewertung (die Zahl)
- Probleme (kategorisiert in Kritisch / Wichtig / Geringfügig)
- Spezifische Korrekturen (was zu ändern ist)
Dem Benutzer melden:
Schleife {N}/{max}: Bewertung {X}/10
- {Zusammenfassung der wichtigsten Feedbackpunkte}
Schritt 4: Stoppbedingungen prüfen
In dieser Reihenfolge:
- Wenn abgeschlossene Schleifen < min_loops → fortfahren (immer)
- Wenn Bewertung >= Qualitätsschwelle → anhalten, zum endgültigen Feinschliff gehen
- Wenn abgeschlossene Schleifen >= max_loops → anhalten, zum endgültigen Feinschliff gehen
- Sonst → überarbeiten und Schleife wiederholen
Schritt 5: Überarbeiten
Das Feedback des Prüfers umsetzen. Kritische und wichtige Probleme beheben. Geringfügige Probleme sind optional. Dann zurück zu Schritt 2.
Wichtig: Jede Überarbeitung sollte gezielt sein. Schreibe nicht alles neu – behebe, was der Prüfer beanstandet hat. Führe eine mentale Liste ALLER vorherigen Rückmeldungen, um Regressionen zu vermeiden.
Schritt 6: Endgültiger Feinschliff
Sobald die Schleife beendet ist (Qualitätsschwelle erreicht oder maximale Schleifenanzahl erreicht):
- Behebe verbleibende geringfügige Probleme, wenn sie trivial sind
- Überprüfe, ob die endgültige Ausgabe kohärent ist (keine Artefakte aus Überarbeitungszyklen)
- Melde die endgültige Bewertung und Schleifenanzahl an den Benutzer
Anpassung der Prüfkriterien nach Aufgabentyp
| Aufgabentyp | Prüfer sollte sich konzentrieren auf |
|---|---|
| Code | Korrektheit, Randfälle, Fehlerbehandlung, Lesbarkeit, keine Sicherheitsprobleme |
| Spezifikation/Design | Vollständigkeit, Machbarkeit, keine vagen Aussagen, Umsetzbarkeit |
| Refaktorisierung | Keine Verhaltensänderungen, keine Regressionen, sauberer als zuvor |
| Text | Klarheit, Struktur, zielgruppengerecht, keine Füllwörter |
| Fehlerbehebung | Ursache behoben, Regressionstest vorhanden, keine Nebenwirkungen |
| Infrastruktur / IaC | Idempotenz, minimale Privilegien, keine fest codierten Geheimnisse, Löschsicherheit |
| Datenbankmigration | Rückgängig machbar, Indexstrategie, Datenverlustrisiko, Leistung bei Skalierung |
| API-Design | Rückwärtskompatibilität, Authentifizierung, Versionierung, Fehlervertrag |
| Testsuite | Abdeckung von Randfällen, keine Testabhängigkeiten, aussagekräftige Behauptungen |
Zwei Betriebsmodi
Modus A: "Erledigen und Prüfen" (vollständiger Zyklus)
Benutzer gibt eine Aufgabe + sagt, review-loop zu verwenden. Du erledigst die Arbeit UND führst die Bewertungsschleife aus.
Benutzer: "Implementiere die Caching-Schicht. Verwende review-loop, Qualitätsschwelle 8."
Du:
1. Implementiere Caching-Schicht
2. Erzeuge Prüfer → Bewertung 6, Feedback: fehlende Verdrängung, kein TTL
3. Überarbeite: Verdrängung + TTL hinzufügen
4. Erzeuge Prüfer → Bewertung 8, Feedback: geringfügige Namensnennung
5. Endgültiger Feinschliff, fertig
Modus B: "Vorhandenes prüfen" (nur Prüfung)
Benutzer hat bereits gearbeitet oder du hast bereits gearbeitet. Führe einfach die Bewertungsschleife für das Vorhandene aus.
Benutzer: "Führe review-loop für das Auth-Modul aus, das ich gerade geschrieben habe"
Du:
1. Lese das Auth-Modul
2. Erzeuge Prüfer → Bewertung 5, Feedback: SQL-Injection, keine Ratenbegrenzung
3. Behebe: Abfragen parametrisieren, Ratenbegrenzer hinzufügen
4. Erzeuge Prüfer → Bewertung 8, genehmigt
5. Fertig
Warnsignale (Red Flags)
Niemals:
- Selbstprüfung anstatt einen Subagenten zu erzeugen (Verankerungsbias)
- Einen Überarbeitungszyklus überspringen, weil "das Feedback falsch ist", ohne Begründung
- Die eigene Bewertung aufblähen ("Ich denke, das ist eigentlich eine 9")
- Über max_loops hinaus fortfahren ohne Zustimmung des Benutzers
- Den Prüfer mit deiner vollständigen Überlegung/Historie erzeugen (sie müssen die ARBEIT prüfen, nicht deine Absicht)
Wenn der Prüfer falsch liegt:
- Widersprich mit Beweisen (Zeige Code/Tests, die das Feedback widerlegen)
- Überspringe diesen spezifischen Punkt bei der Überarbeitung
- Halte es in deinem Bericht an den Benutzer fest
- Senke NICHT die Qualitätsschwelle, um dies auszugleichen
Beispielberichtsformat
--- Bewertungsschleife: {Aufgabenname} ---
Schleife 1/4: Bewertung 6/10
Prüfer: Fehlende Eingabevalidierung, keine Fehlerbehandlung bei Netzwerk-Timeout,
Funktion zu lang (80 Zeilen).
Aktion: Alle drei Probleme beheben.
Schleife 2/4: Bewertung 8/10
Prüfer: Sauber. Geringfügig: Variablenname `d` könnte aussagekräftiger sein.
Aktion: Qualitätsschwelle erreicht (8 >= 8). Endgültiger Feinschliff.
Ergebnis: 8/10 in 2 Schleifen. Fertig.
Bekannte Einschränkungen
- Der Prüfer-Subagent hat kein Gedächtnis an vorherige Schleifen – füge explizit Kontext zu früherem Feedback in jeden Prüfer-Prompt ein, um bereits gelöste Probleme nicht zu wiederholen
- Bewertungsinflation ist möglich, wenn die Kriterien im Prüfer-Prompt zu vage sind – investiere Zeit in das Schreiben spezifischer, messbarer Kriterien
- Dieses Skill ersetzt keine menschliche Code-Überprüfung für sicherheitskritischen oder compliance-relevanten Code; behandle die Ausgabe als starken ersten Durchlauf
- Schleifenkonvergenz ist nicht garantiert, wenn die Aufgabe zu vage spezifiziert ist – definiere klare Abnahmekriterien, bevor du beginnst
Kosten und Geschwindigkeit
- Jede Schleife = 1 Aufruf des Prüfer-Subagenten
- Für einen vollständigen 3-Schleifen-Zyklus ist mit etwa dem 1-2-fachen der Zeit eines einzelnen Implementierungsdurchlaufs zu rechnen
- Dies ist günstig im Vergleich zum Ausliefern von fehlerhaftem Code, vagen Spezifikationen oder dem Auslösen eines späten Überprüfungszyklus
- Verwende dein Standard-/Ausgewogenes Modell für die meisten Prüfungen; aktualisiere nur auf fortgeschrittene Reasoning-Modelle für spezialisierte Bereiche (Sicherheitsaudits, verteilte Systeme, quantitative Finanzen)
Lizenz
MIT – frei verwendbar, anpassbar und weiterverbreitbar mit jedem KI-Tool oder jeder Plattform. Namensnennung geschätzt. Beiträge willkommen.