Meta-prompting: Generarea de prompturi optime
Pe această pagină
Lecție actualizată la 3 noiembrie 2026 pe baza documentației OpenAI: parametrii
temperatureșitop_psunt acceptați doar cu un efort de raționament denone, în timp ce modelele GPT-5.6 raționează implicit (medium). Apelurile care setează acești parametri trebuie, prin urmare, să specificereasoning={"effort": "none"}(API-ul Responses) saureasoning_effort="none"(Chat Completions). Surse: Utilizarea GPT-6 · GPT-5.6 Terra.
Meta-prompting: Generarea de prompturi optime
Meta-prompting-ul implică utilizarea unui LLM pentru a genera sau îmbunătăți prompturi. În loc să scrieți manual fiecare instrucțiune, descrieți sarcina și cereți modelului să producă promptul optim. Economisirea de timp este imediată, dar beneficiul real se află în altă parte: această tehnică scoate la iveală formulări la care nu v-ați fi gândit niciodată, deoarece dezvoltatorii scriu întotdeauna prompturi cu aceleași reflexe și puncte moarte.
Principiul
Un prompt bun este un program scris în limbaj natural. Ca în cazul oricărui program, este uneori mai eficient să îl generați decât să îl tastați manual – nici migrările de bază de date nu le scrieți caracter cu caracter. Meta-prompting-ul se bazează pe faptul că, în timpul antrenamentului, modelul a întâlnit o cantitate vastă de prompturi și discuții despre ceea ce le face eficiente. Exemplul de mai jos solicită un prompt de sistem pentru clasificarea tichetelor de suport. Două detalii merită atenția dumneavoastră: specificația este precisă până la valorile categoriilor, iar ultima linie impune o ieșire brută, fără comentarii accompanying, asigurând că rezultatul este direct utilizabil de către cod.
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)
Generarea din specificații
Primul model industrializează ceea ce tocmai ați făcut manual: descrieți cerințele sub formă de constrângeri funcționale, iar modelul produce promptul corespunzător. Încapsulând meta-prompt-ul într-o funcție, obțineți un generator reutilizabil pentru fiecare sarcină din aplicația dumneavoastră. Efectul secundar este semnificativ: prompturile scrise de cinci dezvoltatori diferiți încetează să mai aibă cinci stiluri diferite, ceea ce simplifică considerabil revizuirea codului.
def generate_prompt(objective: str, constraints: list[str],
output_format: str) -> str:
"""Generează un prompt de sistem din specificații."""
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
Îmbunătățirea unui prompt existent
Al doilea model pornește de la un prompt deja aflat în producție și de la un defect observat în teren. În loc să îl rescrieți complet – ceea ce riscă să strice ceea ce funcționa perfect – furnizați promptul actual împreună cu o descriere precisă a problemei: „răspunde uneori în engleză“ sau „inventează numere de comandă atunci când lipsește referința“. Instrucțiunea „păstrați ce funcționează“ este partea decisivă aici. Fără ea, modelul va refactora spontan totul și vă va handing un prompt complet nou pe care nu îl mai înțelegeți.
def improve_prompt(current_prompt: str, problem: str) -> str:
"""Îmbunătățește un prompt existent pe baza feedback-ului."""
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
Generarea de variante pentru comparație
Al treilea model generează mai multe versiuni ale aceluiași prompt: obiectiv constant, dar formulări și structuri divergente. Aceasta este materia primă pentru testele A/B pe care le vom aborda în Lecția 15; fără variante, pur și simplu nu aveți nimic de comparat. Temperatura ridicată de aici nu este o scăpare: ea servește tocmai pentru a crea diversitate între versiuni, în timp ce o temperatură scăzută v-ar oferi trei reformulări aproape identice.
def generate_variants(base_prompt: str, n: int = 3) -> list[str]:
"""Generează n variante ale unui 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---")
Asamblarea pipeline-ului
Aceste trei blocuri de construcție se înlănțuie în mod natural: generați un prompt din obiectiv, produceți variante, apoi executați fiecare variantă pe un set de test reprezentativ pentru a le judeca pe baza dovezilor, nu a estimărilor.
def meta_prompt_pipeline(objective: str, tests: list[str]) -> str:
"""Pipeline complet de meta-prompting."""
# 1. Generează 3 variante
variants = generate_variants(
generate_prompt(objective, [], "free text"), n=3
)
# 2. Testează fiecare 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. Evaluează (adaptează la criteriile tale)
print("Compare the results and select the best variant.")
return variants, scores
Ce nu va face Meta-prompting-ul pentru dumneavoastră
Modelul are o tendință puternică spre supra-optimizare: promptul pe care îl returnează este adesea prea verbose sau prea calibrat pe exemplele pe care le-ați furnizat, determinându-l să se comporte slab în cazuri ușor diferite. Revizuirea umană este, prin urmare, obligatorie înainte de orice implementare, chiar și doar pentru a verifica dacă nu au fost inventate reguli de afaceri pe parcurs – un model care completează o specificație incompletă o face întotdeauna cu bună-credință și, uneori, incorect. Urmăriți, de asemenea, costul: fiecare iterație consumă tokeni, iar o buclă de îmbunătățire nelimitată poate rula mult timp fără a converge vreodată. Stabiliți numărul maxim de iterații în codul dumneavoastră, nu în disciplina personală.
Pentru a stăpâni această tehnică, luați o sarcină reală din domeniul dumneavoastră, scrieți specificația completă (obiectiv, constrângeri, format), generați trei variante, testați-le pe cinci cazuri din mediul de producție și apoi rafinați-o manual pe cea mai bună. Aproape întotdeauna această ultimă atingere manuală face diferența dintre un prompt decent și unul pe care sunteți gata să îl puneți în producție.
Puncte cheie
- Meta-prompting-ul utilizează LLM-ul ca generator de prompturi
- Trei modele: generare, îmbunătățire iterativă, variante
- Validați întotdeauna prompturile generate cu teste concrete
- Combinați generarea automată cu ajustarea manuală
- Stabiliți limite pentru a evita buclele de iterație costisitoare