Einfach erklärt

Reflection Prompting lässt das LLM seine eigene Antwort kritisch prüfen und verbessern. Statt einer Antwort bekommst du eine überarbeitete, bessere Version.

Der Prozess:

Schritt 1: Generierung
User: "Schreibe eine Funktion, die Primzahlen findet."
LLM: [Erste Version der Funktion]

Schritt 2: Reflection
"Prüfe deine Antwort auf Fehler, Effizienz und Edge Cases."
LLM: "Ich sehe folgende Probleme:
      1. Keine Behandlung von n < 2
      2. Ineffizient für große Zahlen
      3. Keine Typprüfung"

Schritt 3: Verbesserung
"Korrigiere die identifizierten Probleme."
LLM: [Verbesserte Version]

Warum funktioniert das?

Aspekt	Ohne Reflection	Mit Reflection
Erste Idee	Wird ausgegeben	Wird geprüft
Fehler	Bleiben drin	Oft korrigiert
Vollständigkeit	Kann fehlen	Wird ergänzt
Qualität	Variabel	Konsistenter

Technischer Deep Dive

Einfaches Reflection-Pattern

def reflect_and_improve(prompt, model, max_iterations=2):
    # Erste Antwort
    response = model.generate(prompt)
    
    for i in range(max_iterations):
        # Reflection
        reflection_prompt = (
            "Hier ist deine Antwort:\n" + response + "\n\n" +
            "Prüfe kritisch:\n" +
            "1. Gibt es Fehler oder Ungenauigkeiten?\n" +
            "2. Fehlt etwas Wichtiges?\n" +
            "3. Kann etwas klarer formuliert werden?\n\n" +
            "Liste die Probleme auf."
        )
        
        critique = model.generate(reflection_prompt)
        
        # Keine Probleme gefunden?
        if "keine Probleme" in critique.lower():
            break
        
        # Verbesserung
        improve_prompt = (
            "Ursprüngliche Antwort:\n" + response + "\n\n" +
            "Identifizierte Probleme:\n" + critique + "\n\n" +
            "Erstelle eine verbesserte Version, die alle Probleme behebt."
        )
        
        response = model.generate(improve_prompt)
    
    return response

Strukturierte Reflection

REFLECTION_TEMPLATE = """
Analysiere deine Antwort nach folgenden Kriterien:

## Korrektheit
- Sind alle Fakten richtig?
- Gibt es logische Fehler?

## Vollständigkeit
- Wurden alle Aspekte der Frage behandelt?
- Fehlen wichtige Informationen?

## Klarheit
- Ist die Antwort verständlich?
- Gibt es Mehrdeutigkeiten?

## Für Code zusätzlich:
- Funktioniert der Code?
- Gibt es Edge Cases?
- Ist er effizient?

Bewerte jeden Bereich mit ✓ (gut) oder ✗ (Verbesserung nötig).
Beschreibe konkret, was verbessert werden muss.
"""

Reflexion für Code

def code_with_reflection(task, model):
    # Code generieren
    code = model.generate(f"Schreibe Python-Code: {task}")
    
    # Selbst-Review
    review_prompt = f"""
    Prüfe diesen Code als erfahrener Entwickler:
    
    ```python
    {code}

Checklist:

• Syntax korrekt?
• Logik korrekt?
• Edge Cases behandelt?
• Effizient?
• Lesbar?
• Fehlerbehandlung?

Für jedes Problem: Beschreibe es und zeige die Korrektur. """

review_result = model.generate(review_prompt)

Verbesserten Code generieren

if “Problem” in review_result or “Fehler” in review_result: improved = model.generate( “Ursprünglicher Code:\n” + code + “\n\n” + “Review:\n” + review_result + “\n\n” + “Schreibe den korrigierten Code:” ) return improved

return code

### Reflexion mit externem Feedback

```python
def reflect_with_execution(code, model):
    # Code ausführen
    try:
        result = exec(code)
        feedback = "Code läuft erfolgreich. Output: " + str(result)
    except Exception as e:
        feedback = "Fehler: " + type(e).__name__ + ": " + str(e)
    
    # Reflection mit echtem Feedback
    reflection = model.generate(
        "Code:\n" + code + "\n\n" +
        "Ausführungsergebnis:\n" + feedback + "\n\n" +
        "Analysiere das Ergebnis und verbessere den Code falls nötig."
    )
    
    return reflection

Wann Reflection nutzen?

Aufgabe	Reflection sinnvoll?	Warum
Code schreiben	✅ Ja	Fehler sind prüfbar
Mathe-Probleme	✅ Ja	Ergebnis verifizierbar
Fakten-Fragen	✅ Ja	Korrektheit prüfbar
Kreatives Schreiben	⚠️ Teilweise	”Besser” ist subjektiv
Einfache Fragen	❌ Nein	Overhead nicht wert

Kosten-Nutzen

Ohne Reflection:
1 API-Call × Tokens = Kosten

Mit 2 Iterationen:
3 API-Calls × Tokens = 3× Kosten

Lohnt sich wenn:
- Qualität kritisch ist
- Fehler teuer sind
- Aufgabe komplex ist