Przejdź do głównej treści
Polski— Wybierz język
Menu

Meta-prompting: Generowanie optymalnych promptów

Lekcja 5 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Meta-prompting: Generowanie optymalnych promptów
  2. Zasada działania
  3. Generowanie na podstawie specyfikacji
  4. Ulepszanie istniejącego promptu
  5. Generowanie wariantów do porównania
  6. Składanie potoku (Pipeline)
  7. Czego meta-prompting za Ciebie nie zrobi
  8. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 r. na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane wyłącznie przy wysiłku rozumowania (reasoning effort) ustawionym na none, podczas gdy modele GPT-5.6 domyślnie przeprowadzają rozumowanie (medium). Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (Responses API) lub reasoning_effort="none" (Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.

Meta-prompting: Generowanie optymalnych promptów

Meta-prompting polega na wykorzystaniu dużego modelu językowego (LLM) do generowania lub ulepszania promptów. Zamiast ręcznie pisać każdą instrukcję, opisujesz zadanie i prosisz model o stworzenie optymalnego promptu. Oszczędność czasu jest natychmiastowa, ale prawdziwa korzyść leży gdzie indziej: technika ta wydobywa sformułowania, na które nigdy byś nie wpadł, ponieważ programiści zawsze piszą prompty, kierując się tymi samymi odruchami i ślepymi punktami.

Zasada działania

Dobry prompt to program napisany w języku naturalnym. Podobnie jak w przypadku każdego programu, czasem wydajniej jest go wygenerować niż wpisywać ręcznie – przecież nie piszesz migracji bazy danych znak po znaku. Meta-prompting wykorzystuje fakt, że podczas treningu model zetknął się z ogromną ilością promptów i dyskusji na temat tego, co czyni je skutecznymi. Poniższy przykład dotyczy żądania stworzenia promptu systemowego do klasyfikacji zgłoszeń wsparcia technicznego. Dwa szczegóły zasługują na Twoją uwagę: specyfikacja jest precyzyjna aż do wartości kategorii, a ostatni wiersz nakazuje surowe wyjście bez żadnych komentarzy, co zapewnia, że wynik jest bezpośrednio użyteczny dla kodu.

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)

Generowanie na podstawie specyfikacji

Pierwszy wzorzec uprzemysławia to, co właśnie zrobiłeś ręcznie: opisujesz swoje wymagania jako ograniczenia funkcjonalne, a model produkuje odpowiadający im prompt. Owijając meta-prompt w funkcję, otrzymujesz wielokrotnego użytku generator dla każdego zadania w Twojej aplikacji. Efekt uboczny jest znaczący: prompty pisane przez pięciu różnych programistów przestają mieć pięć różnych stylów, co considerably upraszcza przegląd kodu.

def generate_prompt(objective: str, constraints: list[str],
                   output_format: str) -> str:
    """Generuje prompt systemowy na podstawie specyfikacji."""
    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

Ulepszanie istniejącego promptu

Drugi wzorzec zaczyna się od promptu już znajdującego się w produkcji i zaobserwowanego błędu w środowisku rzeczywistym. Zamiast przepisywać go całkowicie – co ryzykuje zepsucie tego, co działało idealnie – dostarczasz bieżący prompt wraz z precyzyjnym opisem problemu: „czasami odpowiada po angielsku“ lub „wymyśla numery zamówień, gdy brak referencji“. Instrukcja „zachowaj to, co działa“ jest tutaj decydująca. Bez niej model spontanicznie przeprowadzi refaktoryzację całości i wręczy Ci zupełnie nowy prompt, którego już nie zrozumiesz.

def improve_prompt(current_prompt: str, problem: str) -> str:
    """Ulepsza istniejący prompt na podstawie opinii."""
    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

Generowanie wariantów do porównania

Trzeci wzorzec generuje wiele wersji tego samego promptu: stały cel, ale rozbieżne sformułowania i struktury. To surowiec do testów A/B, które omówimy w Lekcji 15; bez wariantów po prostu nie masz czego porównywać. Wysoka temperatura nie jest tu przeoczeniem: służy ona właśnie do stworzenia różnorodności między wersjami, podczas gdy niska temperatura dałaby Ci trzy niemal identyczne paraphrazy.

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

Składanie potoku (Pipeline)

Te trzy bloki konstrukcyjne naturalnie łączą się w łańcuch: wygeneruj prompt na podstawie celu, stwórz warianty, a następnie wykonaj każdy wariant na reprezentatywnym zestawie testowym, aby ocenić je na podstawie dowodów, a nie szacunków.

def meta_prompt_pipeline(objective: str, tests: list[str]) -> str:
    """Kompletny potok meta-promptingu."""

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

    # 2. Przetestuj każdy wariant
    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. Oceń (dostosuj do swoich kryteriów)
    print("Porównaj wyniki i wybierz najlepszy wariant.")
    return variants, scores

Czego meta-prompting za Ciebie nie zrobi

Model ma silną tendencję do nadmiernej optymalizacji: prompt, który zwraca, jest często zbyt rozwlekły lub zbyt wąsko skalibrowany do podanych przykładów, co powoduje, że zachowuje się źle w nieco innych przypadkach. Przegląd przez człowieka jest zatem obowiązkowy przed jakimkolwiek wdrożeniem, choćby po to, by sprawdzić, czy po drodze nie wymyślono żadnych reguł biznesowych – model uzupełniający niekompletną specyfikację zawsze robi to w dobrej wierze, a czasem błędnie. Zwróć też uwagę na koszt: każda iteracja zużywa tokeny, a nieograniczona pętla ulepszania może trwać długo, nigdy nie osiągając zbieżności. Ustaw maksymalną liczbę iteracji w swoim kodzie, a nie w swojej osobistej dyscyplinie.

Aby opanować tę technikę, weź rzeczywiste zadanie ze swojej domeny, napisz jego kompletną specyfikację (cel, ograniczenia, format), wygeneruj trzy warianty, przetestuj je na pięciu przypadkach ze swojego środowiska produkcyjnego, a następnie ręcznie dopracuj najlepszy z nich. Prawie zawsze to właśnie ten końcowy, ręczny szlif decyduje o różnicy między przyzwoitym promptem a takim, który jesteś gotowy wdrożyć do produkcji.

Kluczowe wnioski

  • Meta-prompting wykorzystuje LLM jako generator promptów
  • Trzy wzorce: generowanie, iteracyjne ulepszanie, warianty
  • Zawsze waliduj wygenerowane prompty za pomocą konkretnych testów
  • Łącz automatyczne generowanie z ręczną korektą
  • Ustawiaj limity, aby uniknąć kosztownych pętli iteracyjnych