Santa-Methode

Was macht Santa-Methode?

Mehrstufiges, gegnerisches Verifikations-Framework. Mach eine Liste, prüf sie zweimal. Wenn es unartig ist, reparier es, bis es artig ist.

Die Kerneinsicht: Ein einzelner Agent, der seine eigene Ausgabe überprüft, teilt dieselben Verzerrungen, Wissenslücken und systematischen Fehler, die die Ausgabe erzeugt haben. Zwei unabhängige Prüfer ohne gemeinsamen Kontext durchbrechen dieses Fehlermuster.

Wann aktivieren

Dieses Skill einladen, wenn:

• Ausgabe veröffentlicht, bereitgestellt oder von Endnutzern konsumiert wird
• Compliance-, regulatorische oder Markenauflagen durchgesetzt werden müssen
• Code ohne menschliche Überprüfung in die Produktion ausgeliefert wird
• Inhaltsgenauigkeit wichtig ist (technische Dokumente, Schulungsmaterial, kundenorientierte Texte)
• Batch-Generierung in großem Maßstab, wo Stichproben systemische Muster übersehen
• Halluzinationsrisiko erhöht ist (Behauptungen, Statistiken, API-Referenzen, Rechtssprache)

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

Architektur

┌─────────────┐
│  GENERATOR   │  Phase 1: Mach eine Liste
│  (Agent A)   │  Das Arbeitsergebnis erstellen
└──────┬───────┘
       │ Ausgabe
       ▼
┌──────────────────────────────┐
│     DOPPELTE UNABHÄNGIGE PRÜFUNG |  Phase 2: Prüf es zweimal
│                                │
│  ┌───────────┐ ┌───────────┐  │  Zwei Agenten, gleiche Bewertungskriterien,
│  │ Prüfer B  │ │ Prüfer C  │  │  kein gemeinsamer Kontext
│  └─────┬─────┘ └─────┬─────┘  │
│        │              │        │
└────────┼──────────────┼────────┘
         │              │
         ▼              ▼
┌──────────────────────────────┐
│        URTEILS-GATTER         │  Phase 3: Unartig oder Artig
│                                │
│  B bestanden UND C bestanden → ARTIG  │  Beide müssen bestehen.
│  Sonst → UNARTIG               │  Keine Ausnahmen.
└──────┬──────────────┬─────────┘
       │              │
    ARTIG           UNARTIG
       │              │
       ▼              ▼
   [ AUSLIEFERN ]  ┌─────────────┐
                    │  KORREKTURZYKLUS │  Phase 4: Reparieren bis artig
                    │              │
                    │ iteration++  │  Alle Beanstandungen sammeln.
                    │ if i > MAX:  │  Alle Probleme beheben.
                    │   eskalieren │  Beide Prüfer erneut ausführen.
                    │ else:        │  Schleife bis Konvergenz.
                    │   goto Ph.2  │
                    └──────────────┘

Phasendetails

Phase 1: Mach eine Liste (Generieren)

Die Hauptaufgabe ausführen. Keine Änderungen an Ihrem normalen Generierungs-Workflow. Die Santa-Methode ist eine Post-Generierungs-Verifikationsschicht, keine Generierungsstrategie.

# Der Generator läuft wie gewohnt
output = generate(task_spec)

Phase 2: Prüf es zweimal (Unabhängige Doppelprüfung)

Zwei Prüfagenten parallel starten. Kritische Invarianten:

1. Kontextisolierung – kein Prüfer sieht die Bewertung des anderen
2. Identische Bewertungsmatrix – beide erhalten dieselben Bewertungskriterien
3. Gleiche Eingaben – beide erhalten die ursprüngliche Spezifikation UND die generierte Ausgabe
4. Strukturierte Ausgabe – jeder gibt ein typisiertes Urteil zurück, keinen Fließtext

PRÜFER_PROMPT = """
Sie sind ein unabhängiger Qualitätsprüfer. Sie haben KEINE andere Prüfung dieser Ausgabe gesehen.

## Aufgabenspezifikation
{task_spec}

## Zu prüfende Ausgabe
{output}

## Bewertungsmatrix
{rubric}

## Anweisungen
Bewerten Sie die Ausgabe anhand JEDES Kriteriums der Matrix. Für jedes:
- BESTANDEN: Kriterium vollständig erfüllt, keine Probleme
- NICHT BESTANDEN: spezifisches Problem gefunden (das genaue Problem angeben)

Geben Sie Ihre Bewertung als strukturiertes JSON zurück:
{
  "urteil": "BESTANDEN" | "NICHT BESTANDEN",
  "prüfungen": [
    {"kriterium": "...", "ergebnis": "BESTANDEN|NICHT BESTANDEN", "detail": "..."}
  ],
  "kritische_probleme": ["..."],   // Blocker, die behoben werden müssen
  "verbesserungsvorschläge": ["..."]  // Nicht-blockierende Verbesserungen
}

Seien Sie gründlich. Ihre Aufgabe ist es, Probleme zu finden, nicht zu genehmigen.
"""

# Prüfer parallel starten (Claude Code Subagenten)
pruefung_b = Agent(prompt=PRÜFER_PROMPT.format(...), description="Santa Prüfer B")
pruefung_c = Agent(prompt=PRÜFER_PROMPT.format(...), description="Santa Prüfer C")

# Beide laufen gleichzeitig – keiner sieht den anderen

Bewertungsmatrix Design

Die Matrix ist der wichtigste Input. Vage Matrizen liefern vage Prüfungen. Jedes Kriterium muss eine objektive Bestanden/Nicht Bestanden-Bedingung haben.

Kriterium	Bestanden-Bedingung	Fehlersignal
Faktentreue	Alle Behauptungen anhand Quellenmaterial oder Allgemeinwissen überprüfbar	Erfundene Statistiken, falsche Versionsnummern, nicht existierende APIs
Halluzinationsfrei	Keine erfundenen Entitäten, Zitate, URLs oder Referenzen	Links zu nicht existierenden Seiten, zugeschriebene Zitate ohne Quelle
Vollständigkeit	Jede Anforderung der Spezifikation wird behandelt	Fehlende Abschnitte, übersprungene Randfälle, unvollständige Abdeckung
Compliance	Besteht alle projektspezifischen Einschränkungen	Verwendung verbotener Begriffe, Tonfallverstöß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 Matrix-Erweiterungen

Inhalte/Marketing:

• Einhaltung der Markenstimme
• SEO-Anforderungen erfüllt (Keyword-Dichte, Meta-Tags, Struktur)
• Kein Missbrauch von Wettbewerbsmarken
• CTA vorhanden und korrekt verlinkt

Code:

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

Compliance-sensitiv (reguliert, rechtlich, finanziell):

• Keine Ergebnisgarantien oder unbegründete Behauptungen
• Erforderliche Haftungsausschlüsse vorhanden
• Nur genehmigte Terminologie
• Gerichtsbarkeitsgerechte Sprache

Phase 3: Unartig oder Artig (Urteils-Gatter)

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

    # Beanstandungen beider Prüfer zusammenführen, deduplizieren
    alle_probleme = dedupe(pruefung_b.kritische_probleme + pruefung_c.kritische_probleme)
    alle_vorschlaege = dedupe(pruefung_b.verbesserungsvorschläge + pruefung_c.verbesserungsvorschläge)

    return "UNARTIG", alle_probleme, alle_vorschlaege

Warum beide bestehen müssen: Wenn nur ein Prüfer ein Problem entdeckt, 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 artig (Konvergenzschleife)

MAX_ITERATIONEN = 3

for iteration in range(MAX_ITERATIONEN):
    urteil, probleme, vorschlaege = santa_urteil(pruefung_b, pruefung_c)

    if urteil == "ARTIG":
        log_santa_ergebnis(ausgabe, iteration, "bestanden")
        return ausliefern(ausgabe)

    # Alle kritischen Probleme beheben (Vorschläge sind optional)
    ausgabe = korrektur_agent.ausführen(
        ausgabe=ausgabe,
        probleme=probleme,
        anweisung="Beheben Sie NUR die markierten Probleme. Keine Refaktorisierung oder unangeforderten Änderungen."
    )

    # BEIDE Prüfer auf der korrigierten Ausgabe erneut ausführen (frische Agenten, keine Erinnerung an vorherige Runde)
    pruefung_b = Agent(prompt=PRÜFER_PROMPT.format(ausgabe=ausgabe, ...))
    pruefung_c = Agent(prompt=PRÜFER_PROMPT.format(ausgabe=ausgabe, ...))

# Iterationen erschöpft – eskalieren
log_santa_ergebnis(ausgabe, MAX_ITERATIONEN, "eskaliert")
eskalieren_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 Verankerungs-Bias erzeugt.

Implementierungsmuster

Muster A: Claude Code Subagenten (Empfohlen)

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

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

# Pseudocode für Agent-Tool-Aufruf
pruefer_b = Agent(
    description="Santa Prüfung B",
    prompt=f"Überprüfen Sie diese Ausgabe auf Qualität...\n\nMATRIX:\n{rubric}\n\nAUSGABE:\n{ausgabe}"
)
pruefer_c = Agent(
    description="Santa Prüfung C",
    prompt=f"Überprüfen Sie diese Ausgabe auf Qualität...\n\nMATRIX:\n{rubric}\n\nAUSGABE:\n{ausgabe}"
)

Muster B: Sequentiell inline (Fallback)

Wenn keine Subagenten verfügbar sind, Isolierung durch explizite Kontextzurücksetzungen simulieren:

1. Ausgabe generieren
2. Neuer Kontext: "Sie sind Prüfer 1. Bewerten Sie NUR anhand dieser Matrix. Finden Sie Probleme."
3. Ergebnisse wörtlich notieren
4. Kontext vollständig löschen
5. Neuer Kontext: "Sie sind Prüfer 2. Bewerten Sie NUR anhand dieser Matrix. Finden Sie Probleme."
6. Beide Prüfungen vergleichen, korrigieren, wiederholen

Das Subagenten-Muster ist klar überlegen – die Inline-Simulation birgt das Risiko von Kontextüberläufen zwischen den Prüfern.

Muster C: Batch-Stichproben

Für große Batches (100+ Elemente) ist eine vollständige Santa-Prüfung jedes Elements kostspielig. Verwenden Sie geschichtete Stichproben:

1. Santa auf einer Zufallsstichprobe ausführen (10-15% des Batches, mindestens 5 Elemente)
2. Fehler nach Typ kategorisieren (Halluzination, Compliance, Vollständigkeit usw.)
3. Wenn sich systematische Muster abzeichnen, gezielte Korrekturen auf den gesamten Batch anwenden
4. Den korrigierten Batch erneut beproben und verifizieren
5. Fortfahren, bis eine saubere Stichprobe besteht

import random

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

    for element in stichprobe:
        ergebnis = santa_voll(element, matrix)
        if ergebnis.urteil == "UNARTIG":
            muster = fehlerklassifizieren(ergebnis.probleme)
            elemente = batch_korrigieren(elemente, muster)  # Alle Elemente mit passendem Muster korrigieren
            return santa_batch(elemente, matrix)   # Erneut beproben

    return elemente  # Saubere Stichprobe → Batch ausliefern

Fehlermodi und Gegenmaßnahmen

Fehlermodus	Symptom	Gegenmaßnahme
Endlosschleife	Prüfer finden nach Korrekturen ständig neue Probleme	Max Iterationen (3). Eskalieren.
Abnickmechanik	Beide Prüfer geben alles durch	Gegnerischer Prompt: "Ihre Aufgabe ist es, Probleme zu finden, nicht zu genehmigen."
Subjektive Abweichung	Prüfer beanstanden Stilpräferenzen, keine Fehler	Strenge Matrix mit objektiven Bestanden/Nicht Bestanden-Kriterien
Korrekturregression	Behebung von Problem A führt zu Problem B	Frische Prüfer in jeder Runde erkennen Regressionen
Prüfer-Übereinstimmungs-Bias	Beide Prüfer übersehen dasselbe	Durch Unabhängigkeit gemildert, nicht beseitigt. Bei kritischer Ausgabe einen dritten Prüfer oder menschliche Stichprobenprüfung hinzufügen.
Kostenexplosion	Zu viele Iterationen bei großen Ausgaben	Batch-Stichprobenmuster. Budgetobergrenzen pro Verifikationszyklus.

Integration mit anderen Skills

Skill	Beziehung
Verifikationsschleife	Für deterministische Prüfungen verwenden (Build, Lint, Test). Santa für semantische Prüfungen (Genauigkeit, Halluzinationen). Zuerst Verifikationsschleife ausführen, dann Santa.
Eval-Harness	Santa-Method-Ergebnisse speisen Eval-Metriken. Überwachen Sie pass@k über Santa-Läufe, um die Generatorqualität im Zeitverlauf zu messen.
Kontinuierliches Lernen v2	Santa-Ergebnisse werden zu Instinkten. Wiederholte Fehler beim selben Kriterium → gelerntes Verhalten, das Muster zu vermeiden.
Strategisches Kompaktieren	Santa VOR dem Kompaktieren ausführen. Verlieren Sie während der Verifikation nicht den Prüfkontext.

Metriken

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

• Erstbestehensrate: % der Ausgaben, die Santa in Runde 1 bestehen (Ziel: >70%)
• Mittlere Iterationen bis zur Konvergenz: durchschnittliche Runden bis ARTIG (Ziel: <1,5)
• Fehlertaxonomie: Verteilung der Fehlertypen (Halluzination vs. Vollständigkeit vs. Compliance)
• Prüferübereinstimmung: % der von beiden Prüfern vs. nur einem gemeldeten Probleme (niedrige Übereinstimmung = Matrix muss verschärft werden)
• Entweichungsrate: nach der Auslieferung gefundene Probleme, die Santa hätte abfangen sollen (Ziel: 0)

Kostenanalyse

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

Kosten von Santa = (Generierungs-Token) + 2×(Prüf-Token pro Runde) × (durchschnittliche Runden)
Kosten von NICHT 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.