Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Meta-prompting: Gerar Prompts Ótimos

Aula 5 de 16 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Meta-prompting: Gerar Prompts Ótimos
  2. O Princípio
  3. Gerar a Partir de Especificações
  4. Melhorar um Prompt Existente
  5. Gerar Variantes para Comparar
  6. Montar o Pipeline
  7. O Que o Meta-prompting Não Fará por Si
  8. Pontos-chave

Lição atualizada em 3 de novembro de 2026 com base na documentação da OpenAI: temperature e top_p só são aceites com um esforço de raciocínio de none, enquanto os modelos GPT-5.6 raciocinam por predefinição (medium). As chamadas que definem estes parâmetros devem, portanto, especificar reasoning={"effort": "none"} (API de Respostas) ou reasoning_effort="none" (Completions de Chat). Fontes: Utilizar o GPT-6 · GPT-5.6 Terra.

Meta-prompting: Gerar Prompts Ótimos

O meta-prompting consiste em utilizar um LLM para gerar ou melhorar prompts. Em vez de escrever manualmente todas as instruções, descreve a tarefa e pede ao modelo que produza o prompt ideal. A poupança de tempo é imediata, mas o verdadeiro benefício reside noutro lugar: esta técnica revela formulações que talvez nunca tivesse considerado, pois os programadores escrevem sempre prompts com os mesmos reflexos e pontos cegos.

O Princípio

Um bom prompt é um programa escrito em linguagem natural. Tal como em qualquer programa, é por vezes mais eficiente gerá-lo do que digitá-lo à mão — também não escreve as suas migrações de base de dados caractere a caractere. O meta-prompting aproveita o facto de que, durante o treino, o modelo encontrou uma vasta quantidade de prompts e discussões sobre o que os torna eficazes. O exemplo abaixo solicita um prompt de sistema para classificar tickets de suporte. Dois detalhes merecem a sua atenção: a especificação é precisa até aos valores das categorias, e a última linha exige uma saída bruta sem comentários acompanhantes, garantindo que o resultado é diretamente utilizável pelo código.

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)

Gerar a Partir de Especificações

O primeiro padrão industrializa o que acabou de fazer manualmente: descreve os seus requisitos como restrições funcionais e o modelo produz o prompt correspondente. Ao envolver o meta-prompt numa função, obtém um gerador reutilizável para todas as tarefas da sua aplicação. O efeito secundário é significativo: os prompts escritos por cinco programadores diferentes deixam de ter cinco estilos diferentes, o que simplifica consideravelmente a revisão de código.

def generate_prompt(objective: str, constraints: list[str],
                   output_format: str) -> str:
    """Gera um prompt de sistema a partir de especificações."""
    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

Melhorar um Prompt Existente

O segundo padrão parte de um prompt já em produção e de um defeito observado no terreno. Em vez de o reescrever inteiramente — o que corre o risco de quebrar o que funcionava perfeitamente —, fornece o prompt atual juntamente com uma descrição precisa do problema: “por vezes responde em inglês” ou “inventa números de encomenda quando a referência falta”. A instrução “manter o que funciona” é a parte decisiva aqui. Sem ela, o modelo refatora espontaneamente tudo e entrega-lhe um prompt totalmente novo que já não compreende.

def improve_prompt(current_prompt: str, problem: str) -> str:
    """Melhora um prompt existente com base em feedback."""
    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

Gerar Variantes para Comparar

O terceiro padrão gera múltiplas versões do mesmo prompt: objetivo constante, mas formulação e estruturas divergentes. Esta é a matéria-prima para os testes A/B que abordaremos na Lição 15; sem variantes, simplesmente não tem nada para comparar. A temperatura elevada aqui não é um descuido: serve precisamente para criar diversidade entre as versões, enquanto uma temperatura baixa lhe daria três reformulações quase idênticas.

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

Montar o Pipeline

Estes três blocos de construção encadeiam-se naturalmente: gere um prompt a partir do objetivo, produza variantes e, em seguida, execute cada variante num conjunto de testes representativo para as julgar com base em evidências e não em estimativas.

def meta_prompt_pipeline(objective: str, tests: list[str]) -> str:
    """Pipeline completo de meta-prompting."""

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

    # 2. Testar cada variante
    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. Avaliar (adaptar aos seus critérios)
    print("Compare os resultados e selecione a melhor variante.")
    return variants, scores

O Que o Meta-prompting Não Fará por Si

O modelo tem uma forte tendência para a sobre-otimização: o prompt que devolve é frequentemente demasiado verboso ou demasiado calibrado para os exemplos que forneceu, fazendo com que se comporte mal em casos ligeiramente diferentes. A revisão humana é, portanto, obrigatória antes de qualquer implementação, nem que seja para verificar que nenhuma regra de negócio foi inventada pelo caminho — um modelo que completa uma especificação incompleta fá-lo sempre de boa fé e, por vezes, incorretamente. Vigie também o custo: cada iteração consome tokens e um ciclo de melhoria ilimitado pode prolongar-se por muito tempo sem nunca convergir. Defina o número máximo de iterações no seu código, não na sua disciplina pessoal.

Para dominar esta técnica, pegue numa tarefa real do seu domínio, escreva a sua especificação completa (objetivo, restrições, formato), gere três variantes, teste-as em cinco casos do seu ambiente de produção e, em seguida, refine a melhor à mão. É quase sempre este toque manual final que faz a diferença entre um prompt decente e um que está pronto para colocar em produção.

Pontos-chave

  • O meta-prompting utiliza o LLM como gerador de prompts
  • Três padrões: geração, melhoria iterativa, variantes
  • Valide sempre os prompts gerados com testes concretos
  • Combine geração automática com ajuste manual
  • Estabeleça limites para evitar ciclos de iteração dispendiosos