Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Meta-prompting: Generovanie optimálnych promptov

Lekcia 5 z 16 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Meta-prompting: Generovanie optimálnych promptov
  2. Princíp
  3. Generovanie zo špecifikácií
  4. Vylepšenie existujúceho promptu
  5. Generovanie variantov na porovnanie
  6. Zostavenie pipeline
  7. Čo meta-prompting pre teba neurobí
  8. Kľúčové poznatky

Lekcia aktualizovaná 3. novembra 2026 na základe dokumentácie OpenAI: parametre temperature a top_p sú akceptované iba pri úsilí o usudzovanie (reasoning effort) nastavenom na none, zatiaľ čo modely GPT-5.6 štandardne usudzujú (medium). Volania, ktoré nastavujú tieto parametre, preto musia špecifikovať reasoning={"effort": "none"} (Responses API) alebo reasoning_effort="none" (Chat Completions). Zdroje: Používanie GPT-6 · GPT-5.6 Terra.

Meta-prompting: Generovanie optimálnych promptov

Meta-prompting zahŕňa využitie veľkého jazykového modelu (LLM) na generovanie alebo vylepšovanie promptov. Namiesto ručného písania každej inštrukcie opíšeš úlohu a požiadaš model, aby vytvoril optimálny prompt. Úspora času je okamžitá, no skutočný prínos spočíva inde: táto technika odhaľuje formulácie, na ktoré by si nikdy neprišiel, pretože vývojári vždy píšu prompty s rovnakými reflexmi a slepými miestami.

Princíp

Dobrý prompt je program napísaný v prirodzenom jazyku. Ako pri každom programe, niekedy je efektívnejšie ho vygenerovať, než ho písať ručne – ani migrácie databázy nepíšeš znak po znaku. Meta-prompting využíva fakt, že model počas trénovania narazil na obrovské množstvo promptov a diskusií o tom, čo ich robí účinnými. Nasledujúci príklad požaduje systémový prompt na klasifikáciu ticketov podpory. Dva detaily si zaslúžia tvoju pozornosť: špecifikácia je presná až po hodnoty kategórií a posledný riadok vyžaduje surový výstup bez sprievodného komentára, čo zabezpečuje, že výsledok je priamo použiteľný kódom.

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)

Generovanie zo špecifikácií

Prvý vzor industrializuje to, čo si práve urobil ručne: svoje požiadavky opíšeš ako funkčné obmedzenia a model vyprodukuje zodpovedajúci prompt. Zabalením meta-promptu do funkcie získaš opakovane použiteľný generátor pre každú úlohu vo svojej aplikácii. Vedľajší efekt je významný: prompty napísané piatimi rôznymi vývojármi prestanú mať päť rôznych štýlov, čo výrazne zjednodušuje kontrolu kódu.

def generate_prompt(objective: str, constraints: list[str],
                   output_format: str) -> str:
    """Generuje systémový prompt zo špecifikácií."""
    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

Vylepšenie existujúceho promptu

Druhý vzor vychádza z promptu, ktorý je už v produkcii, a zo zistenej chyby v praxi. Namiesto jeho úplného prepísania – čo riskuje rozbitie toho, čo fungovalo perfektne – poskytneš aktuálny prompt spolu s presným opisom problému: „niekedy odpovedá po anglicky“ alebo „vymýšľa čísla objednávok, keď chýba referencia“. Inštrukcia „zachovaj to, čo funguje“ je tu rozhodujúca. Bez nej model spontánne refaktoringuje celú vec a odovzdá ti úplne nový prompt, ktorému už nerozumieš.

def improve_prompt(current_prompt: str, problem: str) -> str:
    """Vylepší existujúci prompt na základe spätnej väzby."""
    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

Generovanie variantov na porovnanie

Tretí vzor generuje viacero verzií toho istého promptu: cieľ zostáva konštantný, ale formulácie a štruktúry sa líšia. Toto je surový materiál pre A/B testovanie, ktorému sa budeme venovať v lekcii 15; bez variantov jednoducho nemáš čo porovnávať. Vysoká hodnota temperature tu nie je prehliadnutím: slúži presne na vytvorenie diverzity medzi verziami, zatiaľ čo nízka teplota by ti dala tri takmer identické preformulovania.

def generate_variants(base_prompt: str, n: int = 3) -> list[str]:
    """Generuje n variantov promptu."""
    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---")

Zostavenie pipeline

Tieto tri stavebné kamene sa prirodzene spájajú: vygeneruj prompt z cieľa, vytvor varianty a následne každý variant spusti na reprezentatívnej testovacej množine, aby si ich posúdil na základe dôkazov, nie odhadov.

def meta_prompt_pipeline(objective: str, tests: list[str]) -> str:
    """Kompletná pipeline meta-promptingu."""

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

    # 2. Otestuj každý 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. Vyhodnotenie (prispôsob svojim kritériám)
    print("Porovnajte výsledky a vyberte najlepší variant.")
    return variants, scores

Čo meta-prompting pre teba neurobí

Model má silnú tendenciu k preoptimalizácii: prompt, ktorý vráti, je často príliš rozvláčny alebo príliš úzko kalibrovaný na príklady, ktoré si mu poskytol, čo spôsobuje, že sa správa zle pri mierne odlišných prípadoch. Ľudská kontrola je preto pred nasadením povinná, aspoň na overenie, že neboli vymyslené žiadne business pravidlá – model dopĺňajúci neúplnú špecifikáciu to vždy robí v dobrej viere a niekedy nesprávne. Sleduj aj náklady: každá iterácia spotrebúva tokeny a neobmedzená slučka vylepšovania môže bežať dlho bez toho, aby niekedy konvergovala. Maximálny počet iterácií nastav v kóde, nie vo svojej osobnej disciplíne.

Aby si túto techniku zvládol, vezmi si reálnu úlohu zo svojej domény, napíš jej kompletnú špecifikáciu (cieľ, obmedzenia, formát), vygeneruj tri varianty, otestuj ich na piatich prípadoch z tvojej produkcie a následne ten najlepší ručne dolad. Takmer vždy je to práve tento finálny manuálny zásah, ktorý robí rozdiel medzi priemerným promptom a tým, ktorý si pripravený nasadiť do produkcie.

Kľúčové poznatky

  • Meta-prompting využíva LLM ako generátor promptov
  • Tri vzory: generovanie, iteratívne vylepšovanie, varianty
  • Vždy validuj vygenerované prompty pomocou konkrétnych testov
  • Kombinuj automatické generovanie s manuálnym doladením
  • Nastav limity, aby si sa vyhol nákladným iteračným slučkám