Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Meta-prompting: Generování optimálních promptů

Lekce 5 z 16 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Meta-prompting: Generování optimálních promptů
  2. Princip
  3. Generování ze specifikací
  4. Vylepšení existujícího promptu
  5. Generování variant k porovnání
  6. Sestavení pipeline
  7. Co meta-prompting za tebe neudělá
  8. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry temperature a top_p jsou akceptovány pouze při úsilí o uvažování (reasoning effort) nastaveném na none, zatímco modely řady GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovat reasoning={"effort": "none"} (Responses API) nebo reasoning_effort="none" (Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.

Meta-prompting: Generování optimálních promptů

Meta-prompting spočívá ve využití velkého jazykového modelu (LLM) k generování nebo vylepšování promptů. Místo ručního psaní každé instrukce popíšeš úkol a požádáš model, aby vytvořil optimální prompt. Úspora času je okamžitá, ale skutečný přínos spočívá jinde: tato technika odhaluje formulace, na které bys sám nikdy nepřišel, protože vývojáři vždy píší prompty se stejnými reflexy a slepými místy.

Princip

Dobrý prompt je program napsaný v přirozeném jazyce. Stejně jako u jakéhokoli programu je někdy efektivnější jej vygenerovat, než ho psát ručně – také nepíšeš migrace databáze znak po znaku. Meta-prompting využívá faktu, že model během tréninku zpracoval obrovské množství promptů a diskusí o tom, co je činí účinnými. Níže uvedený příklad požaduje systémový prompt pro klasifikaci tiketů podpory. Dva detaily si zaslouží tvou pozornost: specifikace je přesná až na hodnoty kategorií a poslední řádek vyžaduje surový výstup bez doprovodného komentáře, což zajišťuje, že výsledek lze přímo využít v kódu.

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)

Generování ze specifikací

První vzor industrializuje to, co jsi právě udělal ručně: popíšeš své požadavky jako funkční omezení a model vytvoří odpovídající prompt. Zabalením meta-promptu do funkce získáš znovu použitelný generátor pro každý úkol ve své aplikaci. Vedlejší efekt je významný: prompty psané pěti různými vývojáři přestanou mít pět různých stylů, což considerably zjednodušuje kontrolu kódu.

def generate_prompt(objective: str, constraints: list[str],
                   output_format: str) -> str:
    """Generuje systémový prompt ze specifikací."""
    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šení existujícího promptu

Druhý vzor vychází z promptu, který je již v produkci, a ze zaznamenané chyby v praxi. Místo jeho úplného přepsání – což riskuje rozbití toho, co fungovalo perfektně – poskytneš aktuální prompt spolu s přesným popisem problému: „někdy odpovídá anglicky“ nebo „vymýšlí čísla objednávek, když chybí reference“. Instrukce „zachovej to, co funguje“ je zde rozhodující. Bez ní by model spontánně refaktoroval celý obsah a předal ti zcela nový prompt, kterému už nebudeš rozumět.

def improve_prompt(current_prompt: str, problem: str) -> str:
    """Vylepší existující prompt na základě zpětné vazby."""
    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

Generování variant k porovnání

Třetí vzor generuje více verzí stejného promptu: cíl zůstává konstantní, ale formulace a struktury se liší. To je surový materiál pro A/B testování, kterým se budeme zabývat v lekci 15; bez variant nemáš co porovnávat. Vysoká hodnota parametru temperature zde není oversight: slouží přesně k vytvoření rozmanitosti mezi verzemi, zatímco nízká teplota by ti dala tři téměř totožné přeformulování.

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

Sestavení pipeline

Tyto tři stavební kameny se přirozeně řetězí: vygeneruj prompt z cíle, vytvoř varianty a poté spusť každou variantu na reprezentativní testovací sadě, abys je posoudil na základě důkazů, nikoli odhadů.

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

    # 1. Generování 3 variant
    variants = generate_variants(
        generate_prompt(objective, [], "free text"), n=3
    )

    # 2. Testování každé varianty
    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. Vyhodnocení (přizpůsob svým kritériím)
    print("Porovnej výsledky a vyber nejlepší variantu.")
    return variants, scores

Co meta-prompting za tebe neudělá

Model má silnou tendenci k přehnané optimalizaci: prompt, který vrátí, je často příliš upovídaný nebo příliš úzce kalibrovaný na příklady, které jsi poskytl, což způsobuje, že se chová špatně u mírně odlišných případů. Lidská revize je proto před jakýmkoli nasazením povinná, alespoň k ověření, že nebyla vymyšlena žádná obchodní pravidla – model doplňující neúplnou specifikaci tak činí vždy v dobré víře, někdy však chybně. Sleduj také náklady: každá iterace spotřebovává tokeny a neomezená smyčka vylepšování může běžet dlouho, aniž by kdy konvergovala. Nastav maximální počet iterací ve svém kódu, nikoli ve své osobní disciplíně.

Abys tuto techniku zvládl, vezmi si skutečný úkol ze své domény, napiš jeho kompletní specifikaci (cíl, omezení, formát), vygeneruj tři varianty, otestuj je na pěti případech z tvého produkčního prostředí a poté nejlepší ručně doladíš. Téměř vždy je to právě tento finální manuální zásah, který rozhoduje mezi slušným promptem a tím, který jsi připraven nasadit do produkce.

Klíčové poznatky

  • Meta-prompting využívá LLM jako generátor promptů
  • Tři vzory: generování, iterativní vylepšování, varianty
  • Vždy ověř vygenerované prompty pomocí konkrétních testů
  • Kombinuj automatické generování s manuálním doladěním
  • Nastav limity, abys předešel nákladným smyčkám iterací