Meta-prompting: Gerar Prompts Ótimos
Nesta página
Lição atualizada em 3 de novembro de 2026 com base na documentação da OpenAI:
temperatureetop_psó são aceites com um esforço de raciocínio denone, enquanto os modelos GPT-5.6 raciocinam por predefinição (medium). As chamadas que definem estes parâmetros devem, portanto, especificarreasoning={"effort": "none"}(API de Respostas) oureasoning_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