Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Meta-Prompting: Erstellen optimaler Prompts

Lektion 5 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Meta-Prompting: Erstellen optimaler Prompts
  2. Das Prinzip
  3. Generieren aus Spezifikationen
  4. Verbessern eines bestehenden Prompts
  5. Generieren von Varianten zum Vergleich
  6. Zusammenbau der Pipeline
  7. Was Meta-Prompting für Sie nicht tun wird
  8. Kernaussagen

Lektion aktualisiert am 3. November 2026 basierend auf der OpenAI-Dokumentation: Die Parameter temperature und top_p werden nur mit einem Reasoning-Effort von none akzeptiert, während Modelle der GPT-5.6-Serie standardmäßig mit medium reasonieren. Aufrufe, die diese Parameter setzen, müssen daher reasoning={"effort": "none"} (Responses API) oder reasoning_effort="none" (Chat Completions) angeben. Quellen: Using GPT-6 · GPT-5.6 Terra.

Meta-Prompting: Erstellen optimaler Prompts

Meta-Prompting beinhaltet die Verwendung eines LLMs, um Prompts zu generieren oder zu verbessern. Anstatt jede Anweisung manuell zu verfassen, beschreiben Sie die Aufgabe und bitten das Modell, den optimalen Prompt zu erstellen. Die Zeiteinsparungen sind sofort spürbar, doch der eigentliche Nutzen liegt anderswo: Diese Technik bringt Formulierungen ans Licht, die Sie womöglich nie in Betracht gezogen hätten, da Entwickler Prompts stets mit denselben Reflexen und blinden Flecken schreiben.

Das Prinzip

Ein guter Prompt ist ein Programm, das in natürlicher Sprache verfasst ist. Wie bei jedem anderen Programm auch ist es manchmal effizienter, ein solches Programm zu generieren, als es zeilenweise von Hand zu tippen – Sie schreiben Ihre Datenbank-Migrationen auch nicht Buchstabe für Buchstabe. Meta-Prompting nutzt die Tatsache, dass das Modell während des Trainings eine enorme Menge an Prompts und Diskussionen darüber gesehen hat, was sie effektiv macht. Im folgenden Beispiel wird ein System-Prompt für die Klassifizierung von Support-Tickets angefordert. Zwei Details verdienen Ihre Aufmerksamkeit: Die Spezifikation ist präzise bis hin zu den Kategorie-Werten, und die letzte Zeile fordert eine rohe Ausgabe ohne begleitenden Kommentar, wodurch das Ergebnis direkt vom Code verwendet werden kann.

from openai import OpenAI

client = OpenAI()

meta_prompt = """You are an expert in prompt engineering.

Generate an optimized system prompt for the following task:
- Objective: Classify customer support tickets
- Categories: bug, feature_request, question, billing
- Output: JSON with "category", "priority" (1-5), "summary"
- Constraints: Response in French, max 100 tokens

The prompt must include:
1. A clear role
2. The categories with classification criteria
3. The exact output format with an example
4. Edge cases (ambiguous ticket, out-of-category)

Return ONLY the system prompt, with no explanation."""

response = client.responses.create(
    model="gpt-5.6-sol",
    reasoning={"effort": "none"},  # temperature requires effort none
    input=meta_prompt,
    temperature=0.7
)

generated_prompt = response.output_text
print(generated_prompt)

Generieren aus Spezifikationen

Das erste Muster industrialisiert das, was Sie gerade manuell getan haben: Sie beschreiben Ihre Anforderungen als funktionale Einschränkungen, und das Modell erzeugt den entsprechenden Prompt. Durch das Einbetten des Meta-Prompts in eine Funktion erhalten Sie einen wiederverwendbaren Generator für jede Aufgabe in Ihrer Anwendung. Die Nebenwirkung ist erheblich: Prompts, die von fünf verschiedenen Entwicklern geschrieben wurden, hören auf, fünf verschiedene Stile zu haben, was die Code-Review erheblich vereinfacht.

def generate_prompt(objective: str, constraints: list[str],
                   output_format: str) -> str:
    """Generates a system prompt from specifications."""
    spec = f"""Generate a system prompt for this task:

Objective: {objective}

Constraints:
{chr(10).join(f'- {c}' for c in constraints)}

Expected output format:
{output_format}

Include a concrete input/output example.
Return only the prompt, with no commentary."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=spec,
        temperature=0.5
    )
    return response.output_text

Verbessern eines bestehenden Prompts

Das zweite Muster beginnt mit einem Prompt, der bereits im Einsatz ist, und einem beobachteten Defekt im Feld. Anstatt ihn vollständig neu zu schreiben – was riskiert, dass das bisher funktionierende kaputtgeht – stellen Sie den aktuellen Prompt zusammen mit einer präzisen Beschreibung des Problems bereit: „er antwortet manchmal auf Englisch” oder „er erfindet Bestellnummern, wenn die Referenz fehlt”. Die Anweisung „behalten Sie das Funktionierende bei” ist hier der entscheidende Teil. Ohne sie refaktoriert das Modell spontan das Ganze und reicht Ihnen einen völlig neuen Prompt, den Sie nicht mehr verstehen.

def improve_prompt(current_prompt: str, problem: str) -> str:
    """Improves an existing prompt based on feedback."""
    meta = f"""Here is a system prompt that has a problem:

--- CURRENT PROMPT ---
{current_prompt}
--- END ---

Observed problem: {problem}

Rewrite this prompt to fix this problem.
Keep what works; modify only what is necessary.
Return only the improved prompt."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=meta,
        temperature=0.3
    )
    return response.output_text

Generieren von Varianten zum Vergleich

Das dritte Muster erzeugt mehrere Versionen desselben Prompts: gleiches Ziel, aber divergierende Formulierung und Struktur. Dies ist das Rohmaterial für die A/B-Tests, die wir in Lektion 15 behandeln werden; ohne Varianten haben Sie einfach nichts zum Vergleichen. Die hohe Temperatur hier ist kein Versehen: Sie dient genau dazu, Vielfalt zwischen den Versionen zu schaffen, während eine niedrige Temperatur Ihnen drei fast identische Umschreibungen liefern würde.

def generate_variants(base_prompt: str, n: int = 3) -> list[str]:
    """Generates n variants of a prompt."""
    meta = f"""Here is a system prompt:

{base_prompt}

Generate {n} variants of this prompt that:
- Keep the same objective
- Use different phrasing
- Vary the structure (lists vs. paragraphs, order of instructions)

Separate each variant with "---VARIANT---"."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=meta,
        temperature=0.9
    )
    return response.output_text.split("---VARIANT---")

Zusammenbau der Pipeline

Diese drei Bausteine schließen sich natürlich aneinander an: Generieren Sie einen Prompt aus dem Ziel, erzeugen Sie Varianten und führen Sie dann jede Variante auf einem repräsentativen Testdatensatz aus, um sie am Beweis zu beurteilen, nicht an Schätzungen.

def meta_prompt_pipeline(objective: str, tests: list[str]) -> str:
    """Complete meta-prompting pipeline."""

    # 1. Generate 3 variants
    variants = generate_variants(
        generate_prompt(objective, [], "free text"), n=3
    )

    # 2. Test each variant
    scores = []
    for i, prompt in enumerate(variants):
        results = []
        for test in tests:
            response = client.responses.create(
                model="gpt-5.6-terra",
                reasoning={"effort": "none"},  # temperature requires effort none
                instructions=prompt.strip(),
                input=test,
                temperature=0.2
            )
            results.append(response.output_text)
        scores.append((i, results))

    # 3. Evaluate (adapt to your criteria)
    print("Compare the results and select the best variant.")
    return variants, scores

Was Meta-Prompting für Sie nicht tun wird

Das Modell neigt stark zur Überoptimierung: Der zurückgegebene Prompt ist oft zu ausführlich oder zu eng auf die von Ihnen bereitgestellten Beispiele kalibriert, wodurch es sich bei leicht abweichenden Fällen schlecht verhält. Eine menschliche Prüfung ist daher vor jeder Bereitstellung zwingend erforderlich, um zumindest zu überprüfen, ob keine Geschäftsregeln erfunden wurden – ein Modell, das eine unvollständige Spezifikation vervollständigt, tut dies stets in gutem Glauben und manchmal auch falsch. Achten Sie auch auf die Kosten: Jede Iteration verbraucht Tokens, und ein ungebundener Verbesserungszyklus kann lange laufen, ohne jemals zu konvergieren. Setzen Sie die maximale Anzahl der Iterationen in Ihrem Code fest, nicht in Ihrer persönlichen Disziplin.

Um diese Technik zu meistern, nehmen Sie eine echte Aufgabe aus Ihrem Bereich, schreiben Sie ihre vollständige Spezifikation (Ziel, Einschränkungen, Format) auf, generieren Sie drei Varianten, testen Sie sie an fünf Fällen aus Ihrer Produktionsumgebung und verfeinern Sie dann die beste Variante manuell. Es ist fast immer dieser letzte manuelle Eingriff, der den Unterschied zwischen einem anständigen Prompt und einem ausmacht, den Sie bereit für die Produktion sind.

Kernaussagen

  • Meta-Prompting nutzt das LLM als Prompt-Generator
  • Drei Muster: Generierung, iterative Verbesserung, Varianten
  • Validieren Sie generierte Prompts stets mit konkreten Tests
  • Kombinieren Sie automatische Generierung mit manueller Anpassung
  • Setzen Sie Grenzen, um kostspielige Iterationszyklen zu vermeiden