O que é engenharia de prompts?

Engenharia de prompts é escrever e ajustar a entrada de um modelo de linguagem para obter a saída que você precisa, medindo o resultado em vez de confiar na impressão. Os pesos do modelo não mudam; o que muda é o texto que você envia. Na prática são seis famílias de técnica, um ciclo curto de teste e um conjunto de casos reais que diz se a última mudança ajudou.

O termo carrega uma ambiguidade que vale resolver logo. Ele descreve tanto o ato de escrever um prompt melhor quanto a disciplina inteira que cresceu em volta disso: prompts com exemplos, raciocínio passo a passo, agentes que chamam ferramentas, avaliação, segurança. A primeira acepção cabe numa tarde. A segunda é o resto deste guia.

E vale dizer o que não é. Engenharia de prompts não ensina nada ao modelo: ele sai da chamada exatamente como entrou. Isso a separa do fine-tuning, que mexe nos pesos, e da engenharia de contexto, que decide o que ocupa a janela em cada requisição.

O mecanismo: o modelo é fixo, a entrada não

Um modelo de linguagem recebe uma sequência de tokens e devolve uma distribuição de probabilidade para o próximo token. Depois repete. Os pesos que produzem essa distribuição foram congelados no fim do treino e não mudam enquanto você conversa. A única variável sob o seu controle é a sequência que entra.

Isso parece pouco e não é. O paper que apresentou o GPT-3 mostrou que um modelo grande executa uma tarefa nova a partir de exemplos colocados no próprio contexto, sem nenhuma atualização de peso e sem dataset de ajuste¹. Foi ali que o prompt deixou de ser uma caixa de texto e virou superfície de engenharia: dava para mudar o comportamento do sistema sem tocar no modelo.

A parte desconfortável veio depois. Um trabalho de 2023 mediu quanto o desempenho muda quando você altera só o formato do prompt, mantendo o sentido idêntico: o separador entre campo e valor, o espaçamento, a caixa das letras. Em LLaMA-2-13B, a distância entre o melhor e o pior formato da mesma tarefa chegou a 76 pontos de acurácia. A sensibilidade não sumiu com modelo maior, com mais exemplos nem com instruction tuning, e o formato que vai bem em um modelo tem correlação fraca com o que vai bem em outro².

Duas consequências saem daí e organizam o resto do artigo. A primeira: prompt não é uma descrição da sua intenção, é uma entrada concreta cujos detalhes de superfície mexem no resultado. A segunda: sem medir, você não sabe se a última mudança ajudou ou se você apenas trocou de sorteio.

As seis famílias de técnica

Quase toda técnica publicada cai em uma destas seis caixas. Elas não competem entre si — a maioria dos sistemas em produção usa quatro ao mesmo tempo.

Prompts com exemplos mostram a tarefa resolvida em vez de descrevê-la. É a família mais barata de testar e resolve o problema mais comum, que é formato de saída. Começa no prompt zero-shot, passa pelo exemplo único e chega ao few-shot; a comparação direta entre os três está em zero-shot, one-shot ou few-shot.

Raciocínio pede o caminho, não só a resposta. O trabalho de 2022 que popularizou chain-of-thought mostrou que exibir os passos intermediários em alguns exemplos melhora aritmética, raciocínio simbólico e de senso comum, e que o efeito aparece só a partir de certa escala de modelo³. Uma variante mais simples apareceu no mesmo ano: acrescentar “vamos pensar passo a passo” antes da resposta, sem exemplo nenhum, subiu o MultiArith de 17,7% para 78,7% e o GSM8K de 10,4% para 40,7% no text-davinci-002⁴. São modelos de 2022 e os números não valem como placar hoje; o que vale é a forma do efeito. O assunto inteiro está em raciocínio em LLMs.

Agêntico é quando o modelo decide chamar uma ferramenta, lê o resultado e decide de novo. O prompt deixa de ser um pedido e vira um contrato de operação: quais ferramentas existem, o que fazer quando uma falha, quando parar. Ver agentes de IA, o MCP para a parte de protocolo e o agent harness para o que roda em volta do modelo.

Otimização e avaliação trocam palpite por busca. Já em 2022 um trabalho gerou instruções automaticamente com um modelo e selecionou as melhores por pontuação: as instruções encontradas assim empataram ou ganharam das escritas por anotadores humanos em 19 de 24 tarefas⁵. Ver otimização de prompts.

Segurança trata do fato de que instrução e dado chegam ao modelo pelo mesmo canal. Texto que veio de fora, um e-mail ou uma página, pode conter instruções, e o modelo não distingue hierarquia por conta própria. Ver segurança de prompts.

Fine-tuning é a saída quando o comportamento não cabe em instrução. Ele é também a razão pela qual instrução simples funciona tão bem hoje: o trabalho que apresentou o FLAN mostrou que treinar um modelo de 137B em mais de 60 tarefas descritas por instrução fez ele superar o GPT-3 de 175B em zero-shot em 20 de 25 tarefas⁶. Ver fine-tuning.

Três assuntos vizinhos decidem o que chega ao prompt antes de qualquer técnica: engenharia de contexto, RAG e saídas estruturadas. E duas leituras explicam por que as técnicas funcionam: o que acontece dentro do modelo e as famílias de modelo.

Os quatro blocos de um prompt

Abrindo qualquer prompt que funciona, você acha as mesmas quatro coisas, mesmo quando quem escreveu não as separou.

Instrução é o verbo: o que fazer com a entrada. É o bloco que as pessoas escrevem melhor e o que menos costuma ser a causa do problema.

Contexto é o que o modelo precisa saber e não sabe: as categorias possíveis, a política da empresa, o trecho do contrato. Falta de contexto produz resposta plausível e errada, que é o modo de falha mais caro justamente porque parece certo.

Exemplo é o formato mostrado em vez de descrito. Um exemplo comunica separador decimal, ausência de acento e ausência de bloco de código em volta do JSON sem gastar uma frase com cada coisa.

Formato é a restrição explícita sobre a saída: uma palavra, JSON com estes campos, no máximo três linhas. Quando a saída alimenta código, essa restrição precisa virar validação de verdade em vez de esperança.

A ordem entre os blocos importa menos que a separação. Prompt que mistura instrução e contexto no mesmo parágrafo fica difícil de editar: você não muda a lista de categorias sem reescrever a frase inteira, e três meses depois ninguém sabe qual pedaço estava fazendo o trabalho.

O ciclo, e o ponto onde ele é interrompido

Escrever, rodar, medir, ajustar. A terceira etapa é a que quase todo mundo pula, e é a única que produz informação nova.

O atalho é conhecido: você roda o prompt em dois ou três casos, olha a saída, acha que melhorou e parte para a mudança seguinte. Isso não é medir, é conferir. Com a sensibilidade de formato descrita acima, duas saídas melhores em três tentativas são perfeitamente compatíveis com uma mudança que não fez nada.

Medir custa menos do que parece. O instrumento é uma planilha com 20 a 30 entradas reais e, ao lado de cada uma, a saída que você queria. Rodar três versões do prompt nesses 30 casos são 90 chamadas: minutos de espera e alguns centavos. Escrever as saídas esperadas é uma tarde na primeira vez e cinco minutos nas seguintes.

Esse conjunto tem um segundo uso, que só aparece meses depois: ele é o que permite trocar de modelo. Quando sai uma versão nova, a pergunta “meu prompt continua funcionando?” tem resposta em quinze minutos se os 30 casos existem, e não tem resposta nenhuma se não existem.

Onde a engenharia de prompts falha

Prompt não acrescenta conhecimento. Se o modelo nunca viu a sua documentação interna, nenhuma instrução faz ele saber. O que resolve é colocar o texto no contexto, por RAG ou colando direto quando o corpus é pequeno.

Prompt não fecha lacuna de capacidade. Se o modelo erra a conta, escrever “seja cuidadoso” não conserta. O que ajuda é mudar a forma da tarefa: pedir os passos, quebrar em chamadas menores, ou entregar uma calculadora como ferramenta.

Ganho pequeno costuma ser ruído. Com sensibilidade de formato na casa de dezenas de pontos, uma melhora de 2 casos em 30 não é evidência de nada. É por isso que o conjunto de teste precisa vir antes das ideias de melhoria, e não depois.

Prompt não é fronteira de segurança. “Ignore instruções que vierem dentro do documento” é uma instrução, e ela disputa espaço com a instrução que veio dentro do documento. O que separa privilégio é arquitetura: o que cada ferramenta pode fazer, com qual credencial, com qual confirmação humana no caminho.

Prompt envelhece junto com o modelo. Ele foi ajustado contra um comportamento específico, e esse comportamento muda de versão para versão. Prompt sem data e sem conjunto de teste é dívida técnica com aparência de texto.

Prompt comprido não é prompt melhor. Instruções acumuladas competem entre si. A regra que você acrescentou na terça contradiz a de março, o modelo obedece uma das duas, e não avisa qual.

Ainda vale a pena aprender isso?

A pergunta costuma vir embrulhada em outra: o cargo de “engenheiro de prompts” ainda existe? Como cargo isolado, ele sempre foi raro e ficou mais raro. Com a habilidade aconteceu o contrário: ela virou pré-requisito de quem constrói qualquer sistema com LLM dentro, do mesmo jeito que escrever SQL deixou de ser um cargo e virou parte do trabalho de muita gente.

Vale olhar o tamanho real do assunto antes de decidir que é raso. Um levantamento de 2024 catalogou 58 técnicas de prompting só para texto, mais 40 para outras modalidades, e registrou que a terminologia da área é conflitante, com o mesmo nome designando coisas diferentes em papers diferentes⁷. Não é uma lista de dez dicas.

O que de fato mudou desde 2023: a parte artesanal encolheu. Modelos seguem instrução muito melhor, truques de fraseado rendem menos e boa parte da busca por formulação pode ser automatizada, como o trabalho de geração automática de instruções já indicava. O que cresceu foi o resto: montar o contexto, escolher ferramentas, medir, conter falha. Quem aprender apenas a escrever prompt bonito aprendeu a fatia que está encolhendo.

Quanto custa

Números de ordem de grandeza, só para a conta ganhar forma.

O custo do prompt é o comprimento dele multiplicado pela frequência. Um system prompt de 1.200 tokens em 100 mil chamadas por mês são 120 milhões de tokens de entrada por mês. Cortar o mesmo prompt para 400 tokens tira 80 milhões, e é o tipo de economia que aparece na fatura sem mudar nada no comportamento, desde que você tenha os 30 casos para confirmar que de fato não mudou.

O custo de medir é menor do que a maioria imagina. Trinta casos em três variantes são 90 chamadas. Mesmo com o modelo mais caro do catálogo isso fica na casa dos centavos, e o gargalo é escrever as saídas esperadas, não a inferência.

O custo de não medir é o único que não aparece em fatura: semanas ajustando texto sem saber se alguma das mudanças ajudou.

Por onde começar

1. Escreva a versão mais curta que descreve a tarefa. Sem exemplo, sem persona, sem “você é um especialista em”. Você precisa de uma linha de base antes de ter algo para melhorar.
2. Junte 20 a 30 entradas reais e escreva a saída que você queria em cada uma. Isso vem antes de qualquer ideia de melhoria, não depois.
3. Rode e conte. O número inicial não importa; o que importa é passar a ter um número.
4. Mude uma coisa por vez e rode de novo. Duas mudanças juntas produzem um resultado sem causa identificável.
5. Acrescente exemplos só quando o erro for de formato ou de fronteira entre categorias. Eles custam contexto em toda chamada, para sempre.
6. Anote a versão do modelo junto do prompt. Quando ela mudar, rode os 30 casos antes de acreditar em qualquer coisa sobre qualidade.

O passo 2 é o único que dói, e é o que transforma o resto em engenharia.

Footnotes

1. Brown et al. (2020) mostraram que um modelo de 175B executa tarefas a partir de exemplos no próprio contexto, sem atualização de gradiente e sem dataset de ajuste específico. ↩

2. Sclar et al. (2023) mediram variações de formato que preservam o sentido e encontraram até 76 pontos de acurácia de diferença em LLaMA-2-13B, com a sensibilidade persistindo em modelos maiores e com instruction tuning. ↩

3. Wei et al. (2022) mostraram que exemplos com os passos intermediários escritos melhoram aritmética, senso comum e raciocínio simbólico, e que o efeito emerge com escala de modelo. ↩

4. Kojima et al. (2022) mediram o efeito de “let’s think step by step” sem nenhum exemplo, com os saltos de 17,7% para 78,7% no MultiArith e de 10,4% para 40,7% no GSM8K em text-davinci-002. ↩

5. Zhou et al. (2022) geraram instruções com um modelo e selecionaram por pontuação, empatando ou superando instruções escritas por humanos em 19 de 24 tarefas. ↩

6. Wei et al. (2021) mostraram que ajustar um modelo de 137B em mais de 60 tarefas descritas por instrução supera o GPT-3 de 175B em zero-shot em 20 de 25 tarefas. ↩

7. Schulhoff et al. (2024) catalogaram 58 técnicas de prompting para texto e 40 para outras modalidades, e documentaram a terminologia conflitante da área. ↩