Santa-Methode

Was macht Santa-Methode?

Multi-Agenten-Framework zur adversarischen Verifikation. Mach eine Liste, prüfe sie zweimal. Wenn es böse ist, repariere es, bis es brav ist.

Die Kernidee: Ein einzelner Agent, der seine eigene Ausgabe prüft, teilt dieselben Verzerrungen, Wissenslücken und systematischen Fehler, die die Ausgabe produziert haben. Zwei unabhängige Prüfer ohne gemeinsamen Kontext brechen dieses Fehlermuster auf.

Wann aktivieren

Rufe diesen Skill auf, wenn:

• Die Ausgabe veröffentlicht, bereitgestellt oder von Endbenutzern konsumiert wird
• Compliance-, regulatorische oder Markenauflagen eingehalten werden müssen
• Code ohne menschliche Überprüfung in die Produktion geht
• Inhaltsgenauigkeit wichtig ist (technische Dokumente, Schulungsmaterial, kundenorientierte Texte)
• Stapelgenerierung in großem Umfang, bei der Stichproben systematische Muster übersehen
• Halluzinationsrisiko erhöht ist (Behauptungen, Statistiken, API-Referenzen, rechtliche Formulierungen)

NICHT verwenden für interne Entwürfe, explorative Forschung oder Aufgaben mit deterministischer Verifikation (dafür Build-/Test-/Lint-Pipelines nutzen).

Architektur

┌─────────────┐
│  GENERATOR   │  Phase 1: Mach eine Liste
│  (Agent A)   │  Erstelle das Arbeitsergebnis
└──────┬───────┘
       │ Ausgabe
       ▼
┌──────────────────────────────┐
│    DOPPELTE UNABHÄNGIGE      │  Phase 2: Prüfe sie zweimal
│    PRÜFUNG                   │
│                              │
│  ┌───────────┐ ┌───────────┐ │  Zwei Agenten, gleiche Rubrik,
│  │ Prüfer B  │ │ Prüfer C  │ │  kein gemeinsamer Kontext
│  └─────┬─────┘ └─────┬─────┘ │
│        │              │       │
└────────┼──────────────┼───────┘
         │              │
         ▼              ▼
┌──────────────────────────────┐
│        URTEILS-GATE          │  Phase 3: Böse oder Brav
│                              │
│  B besteht UND C besteht → BRAV │  Beide müssen bestehen.
│  Sonst → BÖSE                │  Keine Ausnahmen.
└──────┬──────────────┬────────┘
       │              │
    BRAV           BÖSE
       │              │
       ▼              ▼
   [ AUSLIEFERN ]  ┌─────────────┐
                    │  FIX-ZYKLUS  │  Phase 4: Reparieren, bis brav
                    │              │
                    │ iteration++  │  Sammle alle Mängel.
                    │ wenn i > MAX:│  Behebe alle Probleme.
                    │   eskalieren │  Führe beide Prüfer erneut aus.
                    │ sonst:       │  Schleife bis Konvergenz.
                    │   gehe zu Ph.2│
                    └──────────────┘

Phasendetails

Phase 1: Mach eine Liste (Generieren)

Führe die primäre Aufgabe aus. Keine Änderungen an deinem normalen Generierungsablauf. Die Santa-Methode ist eine Post-Generierungs-Verifikationsschicht, keine Generierungsstrategie.

# Der Generator läuft normal
output = generieren(aufgabe_spezifikation)

Phase 2: Prüfe sie zweimal (Unabhängige Doppelprüfung)

Erzeuge zwei Prüfagenten parallel. Kritische Invarianten:

1. Kontextisolierung — Kein Prüfer sieht die Bewertung des anderen
2. Identische Rubrik — Beide erhalten dieselben Bewertungskriterien
3. Gleiche Eingaben — Beide erhalten die Originalspezifikation UND die generierte Ausgabe
4. Strukturierte Ausgabe — Jeder gibt ein typisiertes Urteil zurück, keinen Fließtext

PRUEFER_PROMPT = """
Du bist ein unabhängiger Qualitätsprüfer. Du hast KEINE andere Prüfung dieser Ausgabe gesehen.

## Aufgabenspezifikation
{aufgabe_spezifikation}

## Zu prüfende Ausgabe
{ausgabe}

## Bewertungsrubrik
{rubrik}

## Anweisungen
Bewerte die Ausgabe anhand JEDES Rubrik-Kriteriums. Für jedes:
- BESTANDEN: Kriterium vollständig erfüllt, keine Probleme
- DURCHGEFALLEN: Spezifisches Problem gefunden (nenne das genaue Problem)

Gib deine Bewertung als strukturiertes JSON zurück:
{
  "urteil": "BESTANDEN" | "DURCHGEFALLEN",
  "pruefungen": [
    {"kriterium": "...", "ergebnis": "BESTANDEN|DURCHGEFALLEN", "detail": "..."}
  ],
  "kritische_probleme": ["..."],   // Blockaden, die behoben werden müssen
  "verbesserungsvorschlaege": ["..."] // Nicht blockierende Verbesserungen
}

Sei streng. Deine Aufgabe ist es, Probleme zu finden, nicht zu genehmigen.
"""

# Prüfer parallel starten (Claude Code Subagenten)
pruf_b = Agent(prompt=PRUEFER_PROMPT.format(...), beschreibung="Santa Prüfer B")
pruf_c = Agent(prompt=PRUEFER_PROMPT.format(...), beschreibung="Santa Prüfer C")

# Beide laufen gleichzeitig — keiner sieht den anderen

Rubrik-Design

Die Rubrik ist die wichtigste Eingabe. Vage Rubriken erzeugen vage Prüfungen. Jedes Kriterium muss eine objektive Bestanden-/Durchgefallen-Bedingung haben.

Kriterium	Bestanden-Bedingung	Fehlersignal
Faktentreue	Alle Behauptungen anhand Quellen oder Allgemeinwissen überprüfbar	Erfundene Statistiken, falsche Versionsnummern, nicht existierende APIs
Halluzinationsfrei	Keine erfundenen Entitäten, Zitate, URLs oder Referenzen	Links zu nicht vorhandenen Seiten, zitierte Quellen ohne Beleg
Vollständigkeit	Jede Anforderung in der Spezifikation wird adressiert	Fehlende Abschnitte, übersprungene Randfälle, unvollständige Abdeckung
Compliance	Besteht alle projektspezifischen Einschränkungen	Verbotene Begriffe, Tonverstöße, regulatorische Nichtkonformität
Interne Konsistenz	Keine Widersprüche innerhalb der Ausgabe	Abschnitt A sagt X, Abschnitt B sagt nicht-X
Technische Korrektheit	Code kompiliert/läuft, Algorithmen sind korrekt	Syntaxfehler, Logikfehler, falsche Komplexitätsangaben

Domänenspezifische Rubrikerweiterungen

Content/Marketing:

• Einhaltung der Markenstimme
• SEO-Anforderungen erfüllt (Keyword-Dichte, Meta-Tags, Struktur)
• Keine Markenrechtsverletzung von Wettbewerbern
• Call-to-Action vorhanden und korrekt verlinkt

Code:

• Typsicherheit (keine any-Lecks, korrekte Nullbehandlung)
• Fehlerbehandlungsabdeckung
• Sicherheit (keine Secrets im Code, Eingabevalidierung, Injektionsprävention)
• Testabdeckung für neue Pfade

Compliance-sensitiv (reguliert, rechtlich, finanziell):

• Keine Ergebnisgarantien oder unbelegte Behauptungen
• Erforderliche Haftungsausschlüsse vorhanden
• Nur genehmigte Terminologie
• Rechtsraumspezifische Sprache

Phase 3: Böse oder Brav (Urteils-Gate)

def santa_urteil(pruf_b, pruf_c):
    """Beide Prüfer müssen bestehen. Keine Teilpunkte."""
    if pruf_b.urteil == "BESTANDEN" and pruf_c.urteil == "BESTANDEN":
        return "BRAV"  # Ausliefern

    # Mängel beider Prüfer zusammenführen, doppelte entfernen
    alle_probleme = deduplizieren(pruf_b.kritische_probleme + pruf_c.kritische_probleme)
    alle_vorschlaege = deduplizieren(pruf_b.verbesserungsvorschlaege + pruf_c.verbesserungsvorschlaege)

    return "BÖSE", alle_probleme, alle_vorschlaege

Warum beide bestehen müssen: Wenn nur ein Prüfer ein Problem findet, ist dieses Problem real. Der blinde Fleck des anderen Prüfers ist genau das Fehlermuster, das die Santa-Methode beseitigen soll.

Phase 4: Reparieren, bis brav (Konvergenzschleife)

MAX_ITERATIONEN = 3

for iteration in range(MAX_ITERATIONEN):
    urteil, probleme, vorschlaege = santa_urteil(pruf_b, pruf_c)

    if urteil == "BRAV":
        protokolliere_santa_ergebnis(ausgabe, iteration, "bestanden")
        return ausliefern(ausgabe)

    # Behebe alle kritischen Probleme (Vorschläge sind optional)
    ausgabe = fix_agent.ausfuehren(
        ausgabe=ausgabe,
        probleme=probleme,
        anweisung="Behebe NUR die markierten Probleme. Refaktoriere nicht und füge keine unangeforderten Änderungen hinzu."
    )

    # Führe BEIDE Prüfer ERNEUT auf der korrigierten Ausgabe aus (frische Agenten, keine Erinnerung an vorherige Runde)
    pruf_b = Agent(prompt=PRUEFER_PROMPT.format(ausgabe=ausgabe, ...))
    pruf_c = Agent(prompt=PRUEFER_PROMPT.format(ausgabe=ausgabe, ...))

# Iterationen erschöpft — eskalieren
protokolliere_santa_ergebnis(ausgabe, MAX_ITERATIONEN, "eskaliert")
eskaliere_an_mensch(ausgabe, probleme)

Kritisch: Jede Prüfrunde verwendet frische Agenten. Prüfer dürfen keine Erinnerung an vorherige Runden haben, da vorheriger Kontext einen Verankerungsfehler erzeugt.

Implementierungsmuster

Muster A: Claude Code Subagenten (Empfohlen)

Subagenten bieten echte Kontextisolierung. Jeder Prüfer ist ein separater Prozess ohne gemeinsamen Zustand.

# Verwendet in einer Claude Code-Sitzung das Agent-Tool, um Prüfer zu starten
# Beide Agenten laufen parallel für Geschwindigkeit

# Pseudocode für die Agent-Tool-Invocation
pruefer_b = Agent(
    beschreibung="Santa Prüfung B",
    prompt=f"Prüfe diese Ausgabe auf Qualität...\n\nRUBRIK:\n{rubrik}\n\nAUSGABE:\n{ausgabe}"
)
pruefer_c = Agent(
    beschreibung="Santa Prüfung C",
    prompt=f"Prüfe diese Ausgabe auf Qualität...\n\nRUBRIK:\n{rubrik}\n\nAUSGABE:\n{ausgabe}"
)

Muster B: Sequentiell Inline (Fallback)

Wenn Subagenten nicht verfügbar sind, simuliere Isolierung mit expliziten Kontextrücksetzungen:

1. Ausgabe generieren
2. Neuer Kontext: "Du bist Prüfer 1. Bewerte NUR anhand dieser Rubrik. Finde Probleme."
3. Ergebnisse wörtlich notieren
4. Kontext vollständig löschen
5. Neuer Kontext: "Du bist Prüfer 2. Bewerte NUR anhand dieser Rubrik. Finde Probleme."
6. Beide Prüfungen vergleichen, korrigieren, wiederholen

Das Subagenten-Muster ist strikt überlegen — Inline-Simulation birgt das Risiko von Kontextübertragung zwischen den Prüfern.

Muster C: Stichproben-Batch

Für große Stapel (100+ Elemente) ist eine vollständige Santa-Prüfung für jedes Element kostspielig. Verwende stratifizierte Stichproben:

1. Führe Santa auf einer Zufallsstichprobe durch (10-15 % des Stapels, mindestens 5 Elemente)
2. Kategorisiere Fehler nach Typ (Halluzination, Compliance, Vollständigkeit usw.)
3. Falls systematische Muster auftreten, wende gezielte Korrekturen auf den gesamten Stapel an
4. Wiederhole die Stichprobe und überprüfe den korrigierten Stapel erneut
5. Fahre fort, bis eine saubere Stichprobe besteht

import random

def santa_batch(elemente, rubrik, stichproben_rate=0.15):
    stichprobe = random.sample(elemente, max(5, int(len(elemente) * stichproben_rate)))

    for element in stichprobe:
        ergebnis = santa_voll(element, rubrik)
        if ergebnis.urteil == "BÖSE":
            muster = klassifiziere_fehler(ergebnis.probleme)
            elemente = batch_fix(elemente, muster)  # Korrigiere alle Elemente, die dem Muster entsprechen
            return santa_batch(elemente, rubrik)   # Erneute Stichprobe

    return elemente  # Saubere Stichprobe → Stapel ausliefern

Fehlermodi und Gegenmaßnahmen

Fehlermodus	Symptom	Gegenmaßnahme
Endlosschleife	Prüfer finden nach Korrekturen immer wieder neue Probleme	Max Iterationen (3). Eskalieren.
Abnickerei	Beide Prüfer geben alles durch	Adversarialer Prompt: "Deine Aufgabe ist es, Probleme zu finden, nicht zu genehmigen."
Subjektive Abweichung	Prüfer bemängeln Stilpräferenzen, keine Fehler	Strenge Rubrik mit objektiven Bestanden-/Durchgefallen-Kriterien
Korrekturregression	Korrektur von Problem A führt zu Problem B	Frische Prüfer in jeder Runde erkennen Regressionen
Übereinstimmungsfehler der Prüfer	Beide Prüfer übersehen dasselbe	Wird durch Unabhängigkeit gemindert, nicht beseitigt. Bei kritischer Ausgabe dritten Prüfer oder menschliche Stichprobe hinzufügen.
Kostenexplosion	Zu viele Iterationen bei großen Ausgaben	Batch-Stichprobenmuster. Budgetobergrenzen pro Verifikationszyklus.

Integration mit anderen Skills

Skill	Beziehung
Verifikationsschleife	Verwende für deterministische Prüfungen (Build, Lint, Test). Santa für semantische Prüfungen (Genauigkeit, Halluzinationen). Führe zuerst die Verifikationsschleife aus, dann Santa.
Evaluierungs-Harness	Ergebnisse der Santa-Methode speisen Evaluierungsmetriken. Verfolge pass@k über Santa-Läufe, um die Generatorqualität im Zeitverlauf zu messen.
Kontinuierliches Lernen v2	Santa-Ergebnisse werden zu Instinkten. Wiederholtes Scheitern am selben Kriterium → erlerntes Verhalten, das Muster zu vermeiden.
Strategischer Kompakt	Führe Santa VOR dem Kompaktieren aus. Verliere keinen Prüfungskontext während der Verifikation.

Metriken

Verfolge diese, um die Effektivität der Santa-Methode zu messen:

• Erstbestehungsrate: % der Ausgaben, die Santa in Runde 1 bestehen (Ziel: >70%)
• Mittlere Iterationen bis Konvergenz: Durchschnittliche Runden bis BRAV (Ziel: <1,5)
• Fehlertaxonomie: Verteilung der Fehlertypen (Halluzination vs. Vollständigkeit vs. Compliance)
• Prüferübereinstimmung: % der von beiden Prüfern vs. nur einem Prüfer markierten Probleme (niedrige Übereinstimmung = Rubrik muss geschärft werden)
• Entweichrate: Probleme, die nach der Auslieferung gefunden werden und die Santa hätte fangen sollen (Ziel: 0)

Kostenanalyse

Die Santa-Methode kostet pro Verifikationszyklus etwa das 2- bis 3-fache der Token-Kosten der reinen Generierung. Für die meisten hochriskanten Ausgaben ist dies ein Schnäppchen:

Kosten von Santa = (Generierungs-Token) + 2×(Prüf-Token pro Runde) × (durchschnittliche Runden)
Kosten von KEINEM Santa = (Reputationsschaden) + (Korrekturaufwand) + (Vertrauensverlust)

Bei Batch-Operationen reduziert das Stichprobenmuster die Kosten auf ~15-20 % der vollständigen Verifikation, während >90 % der systematischen Probleme erkannt werden.