Salt la conținutul principal
Română— Alege o limbă
Meniu

Meta-prompting: Generarea de prompturi optime

Lecția 5 din 16 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Meta-prompting: Generarea de prompturi optime
  2. Principiul
  3. Generarea din specificații
  4. Îmbunătățirea unui prompt existent
  5. Generarea de variante pentru comparație
  6. Asamblarea pipeline-ului
  7. Ce nu va face Meta-prompting-ul pentru dumneavoastră
  8. Puncte cheie

Lecție actualizată la 3 noiembrie 2026 pe baza documentației OpenAI: parametrii temperature și top_p sunt acceptați doar cu un efort de raționament de none, în timp ce modelele GPT-5.6 raționează implicit (medium). Apelurile care setează acești parametri trebuie, prin urmare, să specifice reasoning={"effort": "none"} (API-ul Responses) sau reasoning_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