Prompt Engineering: Técnicas de Prompting Que Todo Desenvolvedor Deveria Conhecer

Se você está desenvolvendo com IA em 2026 e ainda não domina técnicas de prompting, você está deixando 70% da capacidade dos LLMs na mesa. Não estou exagerando - a diferença entre um prompt bem estruturado e um genérico pode ser a diferença entre uma resposta mediocre e uma solução de nível produção.

Depois de trabalhar com diversos projetos envolvendo LLMs, percebi que a maioria dos desenvolvedores subestima o poder de um bom prompt. Vamos mudar isso hoje.

Por Que Prompt Engineering Importa?

Antes de mergulharmos nas técnicas, entenda o seguinte: LLMs são máquinas de completar padrões. Eles não “entendem” no sentido humano - eles são extraordinariamente bons em continuar o padrão que você iniciou. Por isso, como você inicia esse padrão (seu prompt) determina completamente a qualidade da resposta.

Pense nisso como programação declarativa: você não diz como fazer, mas descreve o quê você quer de forma tão clara que o modelo consegue inferir o caminho correto.

1. Zero-Shot Prompting: A Base de Tudo

O que é: Você simplesmente pede o que quer, sem exemplos prévios.

1

Classifique o sentimento desta review: "O produto é bom mas a entrega atrasou"

Quando usar: Esta técnica funciona bem para tarefas simples e diretas, especialmente com modelos grandes e modernos como GPT-5+ e Claude 4.5+.

Evite usar em problemas complexos ou que exigem formato específico de saída.

Dica profissional: Adicione contexto de papel (role prompting):

1
2
3


Você é um especialista em análise de sentimentos para e-commerce brasileiro.
Classifique o sentimento desta review considerando o contexto cultural local:
"O produto é bom mas a entrega atrasou"

Funciona 3x melhor que o prompt básico.

2. Few-Shot Prompting: Ensine Por Exemplos

O que é: Como o nome diz, forneça exemplos antes de pedir a tarefa real.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


Extraia informações estruturadas de avaliações:

Review: "Bateria dura 2 dias, câmera excelente, mas esquenta muito"
Resultado: {"bateria": "positivo", "câmera": "positivo", "temperatura": "negativo"}

Review: "Rápido e bonito, mas a tela arranha fácil"
Resultado: {"desempenho": "positivo", "design": "positivo", "durabilidade": "negativo"}

Review: "Perfeito para jogos, som imersivo, entrega rápida"
Resultado:

Por que funciona: Você está estabelecendo o padrão exato que deseja.

O modelo aprende:

O formato de saída (JSON)
O nível de granularidade
Como lidar com aspectos mistos

Quantos exemplos dar?: Cerca de 2-3 para modelos grandes e de 5-8 para modelos menores. Lembre-se, mais exemplos ≠ automaticamente melhor (pode causar confusão).

3. Chain-of-Thought (CoT): A Técnica Que Muda Tudo

Esta é, sem dúvidas, a técnica mais impactante que descobri. CoT ensina o modelo a “pensar em voz alta”.

Prompt ruim:

1
2


Problema: João tem 3 maçãs. Maria tem o dobro de João mais 2. Pedro tem metade do total.
Quantas maçãs Pedro tem?

Prompt com CoT:

1
2
3
4


Problema: João tem 3 maçãs. Maria tem o dobro de João mais 2. Pedro tem metade do total.
Quantas maçãs Pedro tem?

Resolva passo a passo, explicando seu raciocínio.

Resultado:

1
2
3
4
5
6
7


1. João tem 3 maçãs
2. Maria tem (3 × 2) + 2 = 8 maçãs
3. Total = 3 + 8 = 11 maçãs
4. Pedro tem 11 ÷ 2 = 5.5, mas não podemos ter meia maçã

Vou reconsiderar: "metade do total" provavelmente significa metade do que Maria tem.
Pedro tem 8 ÷ 2 = 4 maçãs

Quando usar CoT: Esta técnica brilha em raciocínio matemático ou lógico, debugging de código, análise de requisitos complexos e, de forma geral, qualquer tarefa que se beneficie de decomposição em etapas menores.

Zero-Shot CoT (a versão mais simples e poderosa): Simplesmente adicione no final: "Vamos pensar passo a passo"

Sério. Essa frase mágica aumenta a taxa de acerto em problemas de raciocínio em até 40%.

4. Self-Consistency: Múltiplas Perspectivas

O conceito: Gere múltiplas respostas com CoT e escolha a mais comum.

Exemplo em código Python (com OpenAI API):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


from collections import Counter

def resolver_com_consistencia(problema, n=5):
    respostas = []
    for _ in range(n):
        resposta = chamar_llm(
            f"{problema}\n\nVamos pensar passo a passo.",
            temperature=0.7  # Importante: temperatura > 0 para variação
        )
        # Extrair resposta final
        respostas.append(extrair_resposta_final(resposta))
    
    # Votação por maioria
    return Counter(respostas).most_common(1)[0][0]

Trade-off: 5x mais chamadas de API, mas drasticamente mais confiável para decisões críticas.

Caso de uso real: Validação de regras de negócio, extração de dados estruturados de contratos, análise de compliance.

5. Generate Knowledge Prompting: Contexto Antes da Pergunta

Faça o modelo gerar conhecimento relevante antes de responder.

Abordagem ingênua:

1

Por que o céu é azul à tarde mas vermelho ao entardecer?

Com Knowledge Generation:

1
2
3
4
5


Primeiro, explique os princípios físicos da dispersão da luz na atmosfera.

[Modelo gera explicação sobre Rayleigh scattering, comprimentos de onda, etc.]

Agora, usando esse conhecimento, explique: por que o céu é azul à tarde mas vermelho ao entardecer?

A segunda resposta é significativamente mais precisa e detalhada porque o modelo “ativou” o contexto relevante.

Uso prático em desenvolvimento:

1
2
3
4
5
6


Explique os princípios de transações ACID em bancos de dados.

[Resposta do modelo...]

Agora, analise este código SQL e identifique problemas de consistência:
[SEU CÓDIGO]

6. Prompt Chaining: Decomponha Tarefas Complexas

Problema: Um único prompt tentando fazer tudo resulta em respostas superficiais, perda de contexto e dificuldade de debug. A solução é usar uma cadeia de prompts especializados, onde cada um tem uma responsabilidade clara.

Exemplo - Sistema de Análise de Code Review:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


# Prompt 1: Extrair mudanças
prompt_1 = """
Analise este diff e liste as principais mudanças:
{diff}
"""

# Prompt 2: Avaliar impacto
prompt_2 = """
Baseado nestas mudanças:
{mudancas}

Avalie o impacto em:
1. Performance
2. Segurança
3. Manutenibilidade
"""

# Prompt 3: Sugerir melhorias
prompt_3 = """
Dadas estas mudanças e estes impactos:
{mudancas}
{impactos}

Sugira 3 melhorias concretas com exemplos de código.
"""

Vantagens: Cada etapa é validável individualmente, fica fácil identificar onde falhou, você pode cachear etapas intermediárias para economizar chamadas de API, e ainda permite paralelização quando as etapas são independentes.

7. Tree of Thoughts (ToT): Exploração de Soluções

ToT é como CoT, mas com múltiplos caminhos de raciocínio que são avaliados.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


Problema: Otimizar este algoritmo de busca

[Modelo explora 3 abordagens]

Abordagem 1: Índice hash
Prós: ...
Contras: ...
Viabilidade: 7/10

Abordagem 2: Árvore B+
Prós: ...
Contras: ...
Viabilidade: 9/10

Abordagem 3: Cache em memória
Prós: ...
Contras: ...
Viabilidade: 6/10

Escolha justificada: Abordagem 2

Quando usar: Ideal para decisões arquiteturais, problemas com múltiplas soluções válidas, e especialmente quando o custo de escolher a implementação errada é alto.

Implementação simples:

1
2
3
4
5
6
7


Gere 3 possíveis abordagens para [PROBLEMA].
Para cada abordagem, avalie:
1. Complexidade de implementação (1-10)
2. Performance esperada (1-10)
3. Risco (1-10)

Recomende a melhor opção com justificativa.

8. ReAct: Raciocínio + Ação

ReAct combina pensamento e ação em ciclos iterativos. É a base de ferramentas como LangChain Agents.

Padrão:

1
2
3
4
5


Thought: [O que preciso fazer]
Action: [Ferramenta/função a chamar]
Observation: [Resultado da ação]
Thought: [O que aprendi]
...

Exemplo real - Debug de API:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


Thought: Preciso verificar por que a API retorna 500
Action: ler_logs(last=50)
Observation: "Database connection timeout em 2026-04-07 10:23:15"

Thought: Problema de conexão com banco. Preciso verificar se o DB está acessível
Action: executar_comando("pg_isready -h db.prod")
Observation: "db.prod:5432 - no response"

Thought: O banco não está respondendo. Vou verificar o status do container
Action: executar_comando("docker ps | grep postgres")
Observation: "container postgres-prod exited (1) 2 hours ago"

Thought: Container do banco caiu. Preciso reiniciá-lo
Action: executar_comando("docker restart postgres-prod")
Observation: "postgres-prod restarted successfully"

Final Answer: A API estava retornando 500 porque o container do PostgreSQL havia caído.
Solução aplicada: restart do container.
Ação preventiva necessária: investigar por que o container caiu.

9. RAG (Retrieval Augmented Generation): Conhecimento Externo

O problema fundamental dos LLMs: Conhecimento desatualizado e limitado ao treino.

RAG resolve isso:

Retrieve: Busque informações relevantes em sua base de dados/documentos
Augment: Injete essas informações no contexto
Generate: Modelo responde baseado no contexto aumentado

Exemplo - Sistema de Suporte:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


def responder_ticket(pergunta_usuario):
    # 1. Retrieve
    docs_relevantes = buscar_documentacao(pergunta_usuario, top_k=3)
    tickets_similares = buscar_historico(pergunta_usuario, top_k=2)
    
    # 2. Augment
    contexto = f"""
    Documentação relevante:
    {docs_relevantes}
    
    Tickets similares resolvidos:
    {tickets_similares}
    
    Pergunta do usuário:
    {pergunta_usuario}
    """
    
    # 3. Generate
    return llm(f"""
    Baseado APENAS nas informações acima, responda a pergunta do usuário.
    Se as informações não forem suficientes, diga explicitamente.
    {contexto}
    """)

Dicas para RAG efetivo:

Sempre instrua para citar fontes
Instrua para admitir quando não sabe
Use embedding semântico para busca (não apenas keyword)
Teste diferentes valores de top_k (normalmente 3-7 é ideal)

10. Meta Prompting: O Modelo Cria Seus Próprios Prompts

No nível mais avançado: Você usa o LLM para criar prompts melhores.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


Seu trabalho é criar prompts ótimos para extração de dados.

Tarefa: Extrair informações de currículos em PDF
Dados necessários: nome, email, experiências, skills, educação

Crie um prompt que:
1. Seja robusto a diferentes formatos de currículo
2. Lide com informações ausentes
3. Normalize dados (ex: datas em formatos diferentes)
4. Retorne JSON estruturado

Prompt otimizado:

Resultado: Um prompt frequentemente melhor do que você escreveria manualmente.

Iteração automática:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


def otimizar_prompt(prompt_inicial, casos_teste, n_iteracoes=3):
    melhor_prompt = prompt_inicial
    melhor_score = avaliar_prompt(prompt_inicial, casos_teste)
    
    for i in range(n_iteracoes):
        prompt_otimizado = llm(f"""
        Este prompt tem score {melhor_score} de 100:
        {melhor_prompt}
        
        Casos onde falhou:
        {analisar_falhas(melhor_prompt, casos_teste)}
        
        Crie uma versão melhorada corrigindo esses problemas.
        """)
        
        score = avaliar_prompt(prompt_otimizado, casos_teste)
        if score > melhor_score:
            melhor_prompt = prompt_otimizado
            melhor_score = score
    
    return melhor_prompt

Comparação de Técnicas: Quando Usar Cada Uma

Técnica	Complexidade	Custo (API)	Melhor Para	Evitar Para
Zero-Shot	Baixa	Baixo	Tarefas simples, modelos grandes	Tarefas especializadas
Few-Shot	Média	Médio	Formatação específica, extração estruturada	Quando exemplos são difíceis de criar
Chain-of-Thought	Média	Médio	Raciocínio, matemática, lógica	Tarefas puramente criativas
Self-Consistency	Alta	Alto (5x)	Decisões críticas, alta precisão necessária	Tarefas simples, respostas subjetivas
Knowledge Gen	Média	Médio	Perguntas que precisam de contexto técnico	Fatos diretos
Prompt Chaining	Alta	Alto	Pipelines complexos, processos com etapas	Tarefas atômicas
Tree of Thoughts	Muito Alta	Muito Alto	Decisões arquiteturais, múltiplas soluções	Problemas com solução óbvia
ReAct	Alta	Alto	Agentes, automação, debugging	Perguntas simples
RAG	Alta	Médio-Alto	Conhecimento específico do domínio	Quando o conhecimento do modelo já basta
Meta Prompting	Muito Alta	Alto	Otimização de sistemas, produção	Prototipação rápida

Princípios Universais: O Que Sempre Funciona

Independente da técnica:

1. Seja Específico

❌ “Melhore este código”
✅ “Refatore esta função para reduzir complexidade ciclomática abaixo de 10, mantendo a mesma interface pública”

2. Dê Contexto

Sempre inclua:

Papel: “Você é um engenheiro de dados sênior”
Objetivo: “O objetivo é migrar este pipeline sem downtime”
Restrições: “Não podemos alterar o schema do banco”

3. Defina o Formato

1
2
3
4
5
6
7


Responda em JSON com a seguinte estrutura:
{
  "problema": "descrição",
  "solucao": "código",
  "testes": ["teste1", "teste2"],
  "riscos": ["risco1"]
}

4. Mostre, Não Apenas Diga

Em vez de “use boas práticas”, mostre:

1
2
3
4
5


Use este estilo de código:
[EXEMPLO DE CÓDIGO BOM]

Evite este estilo:
[EXEMPLO DE CÓDIGO RUIM]

5. Itere Baseado em Evidências

Teste diferentes temperaturas (0.1 para consistência, 0.8 para criatividade)
A/B teste variações de prompt
Meça objetivamente (não confie em intuição)

Conclusão: Do Conhecimento à Maestria

Conhecer estas técnicas é o primeiro passo. Maestria vem de aplicar a técnica certa no momento certo.

Minha recomendação para começar:

Semana 1: Domine Zero-Shot e Few-Shot em seus casos de uso reais
Semana 2: Adicione Chain-of-Thought sempre que tiver raciocínio
Semana 3: Implemente Prompt Chaining para seu pipeline mais complexo
Semana 4: Experimente RAG se você tem base de conhecimento

Depois disso, você estará no top 10% dos desenvolvedores usando IA.

E lembre-se: LLMs são ferramentas, não mágica. Eles amplificam sua expertise, mas não substituem entender profundamente o domínio do problema.