Meta-prompting: Generér optimale prompts
På denne side
Lektionen opdateret 3. november 2026 baseret på OpenAI-dokumentation:
temperatureogtop_paccepteres kun med en ræsonneringsindsats pånone, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificerereasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.
Meta-prompting: Generér optimale prompts
Meta-prompting indebærer at bruge en LLM til at generere eller forbedre prompts. I stedet for manuelt at skrive hver eneste instruktion beskriver du opgaven og beder modellen om at producere det optimale prompt. Tidsbesparelsen er øjeblikkelig, men den virkelige gevinst ligger et andet sted: Denne teknik frembringer formuleringer, du måske aldrig selv havde overvejet, fordi udviklere altid skriver prompts med de samme reflekser og blinde vinkler.
Princippet
Et godt prompt er et program skrevet på naturligt sprog. Som med ethvert program er det nogle gange mere effektivt at generere det end at taste det ind manuelt – du skriver heller ikke dine database-migrationer tegn for tegn. Meta-prompting udnytter det faktum, at modellen under træningen har stiftet bekendtskab med en enorm mængde prompts og diskussioner om, hvad der gør dem effektive. Eksemplet nedenfor anmoder om et system-prompt til klassificering af support-billetter. To detaljer fortjener din opmærksomhed: Specifikationen er præcis helt ned til kategoriværdierne, og den sidste linje kræver et rått output uden ledsagende kommentarer, hvilket sikrer, at resultatet kan bruges direkte af kode.
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)
Generér ud fra specifikationer
Det første mønster industrialiserer det, du lige har gjort manuelt: Du beskriver dine krav som funktionelle begrænsninger, og modellen producerer det tilsvarende prompt. Ved at pakke meta-promptet ind i en funktion får du en genanvendelig generator til enhver opgave i din applikation. Bieffekten er betydelig: Prompts skrevet af fem forskellige udviklere holder op med at have fem forskellige stilarter, hvilket forenkler code review considerably.
def generate_prompt(objective: str, constraints: list[str],
output_format: str) -> str:
"""Genererer et system-prompt ud fra specifikationer."""
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
Forbedr et eksisterende prompt
Det andet mønster tager udgangspunkt i et prompt, der allerede er i produktion, og en observeret fejl i felten. I stedet for at omskrive det fuldstændigt – hvilket risikerer at ødelægge det, der fungerede perfekt – giver du det nuværende prompt sammen med en præcis beskrivelse af problemet: „det svarer nogle gange på engelsk” eller „det opfinder ordrenumre, når referencen mangler”. Instruktionen „behold det, der virker” er den afgørende del her. Uden den vil modellen spontant refaktorere det hele og give dig et helt nyt prompt, som du ikke længere forstår.
def improve_prompt(current_prompt: str, problem: str) -> str:
"""Forbedrer et eksisterende prompt baseret på 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
Generér varianter til sammenligning
Det tredje mønster genererer flere versioner af samme prompt: Konstant mål, men divergerende formuleringer og strukturer. Dette er råmaterialet til den A/B-test, vi vil dække i lektion 15; uden varianter har du simpelthen intet at sammenligne. Den høje temperatur her er ikke en oversight: Den tjener netop til at skabe diversitet mellem versionerne, hvorimod en lav temperatur ville give dig tre næsten identiske omskrivninger.
def generate_variants(base_prompt: str, n: int = 3) -> list[str]:
"""Genererer n varianter af et 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---")
Saml pipeline’en
Disse tre byggesten kædes naturligt sammen: Generér et prompt ud fra målet, producér varianter, og udfør derefter hver variant på et repræsentativt testsæt for at bedømme dem på baggrund af evidens frem for estimater.
def meta_prompt_pipeline(objective: str, tests: list[str]) -> str:
"""Komplet meta-prompting pipeline."""
# 1. Generér 3 varianter
variants = generate_variants(
generate_prompt(objective, [], "free text"), n=3
)
# 2. Test hver 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. Evaluér (tilpas dine kriterier)
print("Sammenlign resultaterne og vælg den bedste variant.")
return variants, scores
Hvad meta-prompting ikke gør for dig
Modellen har en stærk tendens til overoptimering: Det prompt, den returnerer, er ofte for verbost eller for snævert kalibreret til de eksempler, du har angivet, hvilket får den til at opføre sig dårligt på lidt anderledes tilfælde. Menneskelig gennemgang er derfor obligatorisk før enhver udrulning, hvis bare for at verificere, at der ikke er blevet opfundet forretningsregler undervejs – en model, der fuldfører en ufuldstændig specifikation, gør det altid i god tro, og nogle gange forkert. Hold også øje med omkostningerne: Hver iteration forbruger tokens, og en ubegrænset forbedringsløkke kan køre længe uden nogensinde at konvergere. Sæt maksimum antal iterationer i din kode, ikke i din personlige disciplin.
For at mestre denne teknik skal du tage en rigtig opgave fra dit domæne, skrive dens komplette specifikation (mål, begrænsninger, format), generere tre varianter, teste dem på fem tilfælde fra dit produktionsmiljø og derefter finpudse den bedste i hånden. Det er næsten altid dette sidste manuelle touch, der gør forskellen mellem et anstændigt prompt og et, du er klar til at sætte i produktion.
Vigtige pointer
- Meta-prompting bruger LLM’en som en prompt-generator
- Tre mønstre: Generering, iterativ forbedring, varianter
- Valider altid genererede prompts med konkrete tests
- Kombinér automatisk generering med manuel justering
- Sæt grænser for at undgå dyre iterationsløkker