AI Engineering Academy · Lektion

Selbstkorrektur und reflektierendes Prompting

Implementieren Sie einen Reflexionsschritt, in dem der Agent seine eigene Ausgabe mit dem ursprünglichen Ziel abgleicht, Lücken oder Fehler identifiziert und vor einem erneuten Versuch einen korrigierten Plan erstellt.

Lektion 2 von 413 Schritte

Selbstkorrektur und reflektierendes Prompting ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist reflektierendes Prompting?

Reflektierendes Prompting ist eine Technik, bei der der Agent aufgefordert wird, seine eigene Ausgabe zu bewerten, bevor er sie finalisiert. Statt eine Antwort zu erzeugen und anschließend anzuhalten, überprüft der Agent seine Antwort anhand des ursprünglichen Ziels, erkennt Lücken oder Fehler und erstellt eine korrigierte Version. Dies ahmt nach, wie Menschen ihre eigene Arbeit Korrektur lesen, und verbessert die Ausgabequalität bei komplexen Aufgaben erheblich, ohne ein separates Critic-Modell zu benötigen.

Die Reflect-and-Revise-Schleife

Die grundlegende reflektierende Schleife besteht aus drei Schritten: eine erste Antwort Generate erzeugen, diese Antwort anhand klarer Kriterien Critique bewerten und sie auf Grundlage der Kritik Revise. Die Schleife kann ein- oder mehrmals durchlaufen werden. Jede Iteration verbessert die Antwort, bis die Kritik sie entweder als zufriedenstellend einstuft oder eine maximale Anzahl an Überarbeitungen erreicht ist. Der Kritikschritt ist selbst ein LLM-Aufruf mit einem spezialisierten Reflexions-Prompt.

async def reflect_and_revise(task: str, max_rounds: int = 2) -> str:
    response = await generate_initial(task)
    for round_num in range(max_rounds):
        critique = await critique_response(task, response)
        if critique.is_satisfactory:
            break
        response = await revise_response(task, response, critique.feedback)
    return response

Einen effektiven Kritik-Prompt verfassen

Der Kritik-Prompt muss konkrete Bewertungskriterien festlegen, statt das Modell lediglich aufzufordern, die Antwort zu „verbessern“. Listen Sie die zu überprüfenden Punkte konkret auf: Ist jede Aussage korrekt? Wurden alle Teile der Frage beantwortet? Fehlt ein Schritt? Gibt es unnötige Ausschmückungen? Ein Kritik-Prompt mit expliziten Checklistenpunkten erzeugt umsetzbares Feedback, das der Überarbeitungsschritt direkt verwenden kann.

CRITIQUE_PROMPT = '''
You are reviewing an AI-generated response to this task: {task}

Response to evaluate:
{response}

Check each criterion and provide specific feedback:
1. COMPLETENESS: Does it address all parts of the task?
2. ACCURACY: Are all factual claims correct?
3. CONCISENESS: Is there unnecessary padding or repetition?
4. FORMAT: Does it match the requested output format?
5. ACTIONABILITY: Can the user act on this response?

For each issue found, state exactly what to fix.
If the response is satisfactory on all criteria, say APPROVE.
'''

Die Kritikantwort parsen

Strukturieren Sie die Kritik als Pydantic-Modell, damit Sie programmgesteuert entscheiden können, ob eine Überarbeitung erforderlich ist. Das Feld is_satisfactory bestimmt, wann die Schleife beendet wird. Die Liste issues teilt dem Überarbeitungsschritt genau mit, was zu korrigieren ist. Mit dem Feld severity können Sie eine Überarbeitung bei geringfügigen stilistischen Problemen überspringen, während bei sachlichen Fehlern immer überarbeitet wird.

from pydantic import BaseModel
from typing import List, Literal

class Issue(BaseModel):
    criterion: str
    description: str
    severity: Literal['critical', 'moderate', 'minor']

class Critique(BaseModel):
    is_satisfactory: bool
    issues: List[Issue]
    overall_verdict: str

# is_satisfactory=True means no revision needed
# is_satisfactory=False means issues must be addressed

Der Überarbeitungs-Prompt

Der Überarbeitungs-Prompt erhält die ursprüngliche Aufgabe, die erste Antwort und das Kritik-Feedback. Fordern Sie das Modell auf, eine verbesserte Version zu erstellen, die jedes von der Kritik genannte Problem gezielt behebt und zugleich die korrekten Teile der ursprünglichen Antwort beibehält. Fügen Sie immer das Wort „only“ ein, um zu verhindern, dass das Modell unnötige Änderungen an Teilen vornimmt, die von der Kritik bereits bestätigt wurden.

def build_revision_prompt(task: str, response: str, critique: Critique) -> str:
    issues_text = '\n'.join(
        f'- [{i.severity.upper()}] {i.criterion}: {i.description}'
        for i in critique.issues
    )
    return f'''
Original task: {task}

Your previous response:
{response}

Issues to fix:
{issues_text}

Write an improved response that fixes ONLY the issues listed above.
Do not change parts that were not flagged as problems.
'''

Selbstkorrektur bei der Codegenerierung

Selbstkorrektur ist besonders bei der Codegenerierung leistungsfähig. Führen Sie nach der Codegenerierung einen Linter oder Typechecker aus, geben Sie die Fehlerausgabe an das Modell zurück und fordern Sie es auf, die Fehler zu beheben. Diese ausführungsgestützte Reflexion ist zuverlässiger als eine rein sprachbasierte Kritik, weil das Feedback von einem objektiven Tool statt von der Einschätzung eines anderen LLM stammt.

import subprocess
import sys

async def self_correct_code(task: str, max_rounds: int = 3) -> str:
    code = await generate_code(task)
    for _ in range(max_rounds):
        # Write code to temp file and run mypy
        with open('/tmp/agent_code.py', 'w') as f:
            f.write(code)
        result = subprocess.run(
            [sys.executable, '-m', 'mypy', '/tmp/agent_code.py', '--ignore-missing-imports'],
            capture_output=True, text=True
        )
        if result.returncode == 0:
            break  # No type errors
        code = await fix_code(code, result.stdout + result.stderr)
    return code

Überkorrektur vermeiden

Ein häufiges Problem reflektierender Systeme ist die Überkorrektur: Das Modell verschlimmert das ursprüngliche Problem, während es versucht, etwas anderes zu beheben. Begrenzen Sie den Umfang der Überarbeitung: Der Überarbeitungs-Prompt sollte ausdrücklich sagen: „do not change anything that was not flagged.“ Vergleichen Sie die überarbeitete Antwort außerdem mithilfe einer Diff-Prüfung mit dem Original. Wenn die überarbeitete Version sich grundlegend unterscheidet, ist etwas schiefgelaufen und Sie sollten das Original beibehalten.

from difflib import SequenceMatcher

def safe_revision(original: str, revised: str, max_change_ratio: float = 0.7) -> str:
    similarity = SequenceMatcher(None, original, revised).ratio()
    if similarity < (1 - max_change_ratio):
        print(f'Revision changed too much (similarity: {similarity:.2f}). Keeping original.')
        return original
    return revised

Reflexion bei mehrstufigen Agent-Aufgaben

Fügen Sie bei einem mehrstufigen Agent einen Reflexionsprüfpunkt ein, nachdem eine Reihe von Schritten abgeschlossen wurde – beispielsweise nachdem alle Recherchen gesammelt, aber bevor der Abschlussbericht verfasst wurde. Der Agent überprüft die gesammelten Informationen, erkennt Lücken und entscheidet, ob weitere Informationen gesammelt werden müssen oder fortgefahren werden kann. Diese Reflexion während der Aufgabe verhindert, dass Agents mit unvollständigen oder widersprüchlichen Belegen zum Zusammenfassungsschritt übergehen.

async def research_with_reflection(question: str) -> str:
    # Phase 1: gather evidence
    evidence = await gather_evidence(question)

    # Reflection checkpoint
    assessment = await assess_evidence_completeness(question, evidence)
    if not assessment.is_complete:
        for gap in assessment.gaps:
            more_evidence = await targeted_search(gap.search_query)
            evidence.extend(more_evidence)

    # Phase 2: synthesize
    return await synthesize_answer(question, evidence)

Ergebnisse der Reflexion protokollieren

Protokollieren Sie jede Reflexionsrunde: die Bewertung der Kritik, welche Probleme erkannt wurden und ob die Überarbeitung diese tatsächlich behoben hat. Diese Daten zeigen, wie wirksam Ihre Reflexions-Prompts sind. Wenn die überarbeitete Antwort regelmäßig dieselben von der Kritik beanstandeten Probleme erneut einführt, ist Ihr Überarbeitungs-Prompt nicht spezifisch genug. Wenn die meisten Kritiken bereits in der ersten Runde „APPROVE“ lauten, ist die Qualität der ersten Generierung bereits hoch und der zusätzliche Aufwand der Reflexion möglicherweise nicht gerechtfertigt.

import structlog

log = structlog.get_logger()

def log_reflection_round(task_id: str, round_num: int, critique: Critique, action: str):
    log.info(
        'reflection_round',
        task_id=task_id,
        round=round_num,
        is_satisfactory=critique.is_satisfactory,
        issue_count=len(critique.issues),
        critical_issues=sum(1 for i in critique.issues if i.severity == 'critical'),
        action=action  # 'approved', 'revised', 'max_rounds_reached'
    )

Wann Sie Reflexion einsetzen sollten

Reflexion verursacht zusätzliche Latenz und Kosten – eine Reflect-and-Revise-Schleife mit zwei Runden verdreifacht mindestens die Anzahl der LLM-Aufrufe für diese Aufgabe. Setzen Sie Reflexion gezielt ein: immer bei Ausgaben mit hohen Anforderungen (ausführbarer Code, Antworten auf folgenschwere geschäftliche Fragen), optional bei Antworten für Benutzer und niemals bei internen Zwischenschritten, die unmittelbar von einem Tool überprüft werden. Die Kosten lohnen sich, wenn Qualität wichtiger ist als Geschwindigkeit.

# Reflection decision matrix:
# Task type:              Use reflection?
# SQL query generation    YES (run+verify)
# Final report writing    YES (review before delivery)
# Tool argument prep      NO  (tool result verifies it)
# Short factual answer    MAYBE (if accuracy is critical)
# Internal agent thought  NO   (intermediate, not final)
# Code generation         YES  (run linter/tests)

USE_REFLECTION = {'report', 'code', 'email', 'analysis'}

Die Wirksamkeit von Reflexion messen

Überprüfen Sie anhand von A/B-Tests, ob Reflexion Ihre Ausgaben tatsächlich verbessert: Verarbeiten Sie zufällig 50 % der Aufgaben mit Reflexion und 50 % ohne und bewerten Sie anschließend beide Gruppen mit Ihrem LLM-Judge. Wenn die reflektierende Gruppe deutlich besser abschneidet und die Verbesserung die zusätzliche Latenz und die zusätzlichen Kosten übersteigt, lohnt sich Reflexion. Sind die Bewertungen ähnlich, ist die Qualität Ihrer ersten Generierung bereits ausreichend hoch und Reflexion verursacht zusätzlichen Aufwand ohne Nutzen.

async def reflection_ab_test(tasks: list) -> dict:
    import random
    results = {'with_reflection': [], 'without_reflection': []}
    for task in tasks:
        if random.random() < 0.5:
            response = await reflect_and_revise(task, max_rounds=2)
            group = 'with_reflection'
        else:
            response = await generate_initial(task)
            group = 'without_reflection'
        score = await judge(task, response)
        results[group].append(score.overall)
    return {
        'mean_with': sum(results['with_reflection']) / len(results['with_reflection']),
        'mean_without': sum(results['without_reflection']) / len(results['without_reflection'])
    }

Kurzer Check

Testen Sie Ihr Verständnis von Selbstkorrektur und reflektierendem Prompting in Agents.

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: Reflect-and-Revise-Schleifen verbessern die Ausgabequalität, indem der Agent seine eigenen Antworten kritisiert und korrigiert. Konkrete Kritikrubriken erzeugen umsetzbares Feedback statt vager Verbesserungsvorschläge, und ausführungsgestützte Reflexion mit objektiven Tools wie Lintern ist besonders bei der Codegenerierung leistungsfähig. Als Nächstes implementieren wir Checkpointing für Agents und die Wiederaufnahme von Aufgaben.

Kostenlos starten

Lerne Python mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
30
Lektionen
120

Häufig gestellte Fragen

Ist die Lektion „Selbstkorrektur und reflektierendes Prompting“ kostenlos?

Ja — der vollständige Text von „Selbstkorrektur und reflektierendes Prompting“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Selbstkorrektur und reflektierendes Prompting“?

Implementieren Sie einen Reflexionsschritt, in dem der Agent seine eigene Ausgabe mit dem ursprünglichen Ziel abgleicht, Lücken oder Fehler identifiziert und vor einem erneuten Versuch einen korrigie… Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Engineering Academy zu starten?

Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Selbstkorrektur und reflektierendes Prompting“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?

Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Fehlermodi von Agenten klassifizieren
  2. Selbstkorrektur und reflektierendes Prompting
  3. Checkpoints und Fortsetzen von Aufgaben
  4. Eskalation mit Human-in-the-Loop
← Zurück zu AI Engineering Academy