Prompt Engineering for Improved LLM Outputs

1. O que é Prompt Engineering e por que é Crucial?

Prompt engineering é a disciplina de projetar e refinar as entradas (prompts) fornecidas a um LLM para direcionar seu comportamento e garantir que a saída atenda aos seus requisitos. Não se trata apenas de fazer uma pergunta, mas de fornecer um conjunto cuidadosamente estruturado de instruções, exemplos e contexto.

Para entender a diferença entre um prompt simples e um prompt bem construído, e como isso se relaciona com o que aprendemos sobre a janela de contexto, assista ao clipe a seguir.

Como o vídeo destacou, técnicas específicas podem transformar um LLM de um gerador de texto genérico em um especialista focado em uma tarefa. Vamos formalizar a estrutura por trás dessas técnicas.

2. A Anatomia de um Prompt Eficaz

Para construir um agente, você não fará apenas uma pergunta. Você irá construir um "prompt de sistema" ou "instrução de desenvolvedor" que define o comportamento fundamental do agente. Este prompt é a sua principal ferramenta de controle.

Uma prática recomendada, especialmente para tarefas de desenvolvimento de software, é estruturar o prompt em seções claras. A documentação da OpenAI, voltada para desenvolvedores como você, oferece um excelente modelo.

Com base no que você leu, uma estrutura de prompt robusta para o seu agente poderia se parecer com isto:

# Identity
You are an expert C# and React developer agent. Your goal is to implement new features based on Jira tickets. You are precise, follow all architectural guidelines, and produce clean, production-ready code.




# Instructions
- You must analyze the user's request and the provided context files.
- You must generate code that adheres to the SOLID principles.
- Do not suggest changes outside the scope of the Jira ticket.
- Your final output should be a JSON object containing a list of file paths and their new content.




# Examples
... (Veremos exemplos disso na seção de Few-Shot Prompting) ...




# Context
<jira_ticket>
... (Aqui você injetará a descrição do ticket do Jira) ...
</jira_ticket>
<architecture_guidelines>
... (Aqui você injetará as regras de arquitetura relevantes) ...
</architecture_guidelines>
<existing_code file_path="Services/UserService.cs">
... (Aqui você injetará o código do arquivo existente) ...
</existing_code>

Esta abordagem estruturada ajuda a mitigar o problema "Lost in the Middle" da lição anterior, criando "sinalizações" claras para o modelo navegar no contexto. A ordem também é importante: colocar as instruções mais importantes (identidade e regras) no início dá a elas mais "peso" na atenção do modelo.

3. Técnicas Essenciais em Ação

Agora vamos nos aprofundar em duas das técnicas mais poderosas mencionadas no vídeo e no seu resultado de aprendizagem: Few-Shot Prompting e Chain-of-Thought Prompting.

Few-Shot Prompting: Mostre, não apenas Diga

Zero-Shot Prompting é quando você pede ao modelo para fazer algo sem fornecer nenhum exemplo. Isso funciona para tarefas simples, mas falha em tarefas complexas ou quando você precisa de um formato de saída muito específico.

Few-Shot Prompting resolve isso. A técnica consiste em incluir alguns exemplos ("shots") de pares de entrada/saída diretamente no prompt. Isso permite que o modelo aprenda o padrão por inferência, um processo chamado "in-context learning".

Quando usar? É ideal para tarefas como:

• Formatação de dados (ex: converter texto em JSON).
• Classificação (ex: analisar o sentimento de um comentário).
• Traduções de estilo (ex: converter um comentário de usuário em um título de bug formal).

Exemplo Prático para o seu Agente:
Imagine que, após analisar a tarefa, seu agente precisa chamar uma ferramenta interna para criar uma branch no Git. A ferramenta espera um JSON específico.

• Prompt Zero-Shot (propenso a erros):
  "Crie uma branch para o ticket JIRA-123 'Add User Login'. Baseie-se na branch 'develop'."
  O LLM pode gerar texto simples, um formato JSON errado, ou alucinar nomes de campos.

• Prompt Few-Shot (confiável):

  
  
  
  # Identity
  You are an assistant that converts Jira ticket information into a JSON request for the Git branching tool.
  
  
  
  
  # Examples
  ## Example 1
  User Request: Create a branch for ticket JIRA-101 'Fix Payment Gateway Bug' from 'main'.
  Output:
  {
    "repository": "backend-api",
    "base_branch": "main",
    "new_branch_name": "bugfix/JIRA-101-payment-gateway"
  }
  
  
  
  
  ## Example 2
  User Request: Branch for feature from ticket JIRA-105 'Implement User Profile Page' on 'develop'.
  Output:
  {
    "repository": "frontend-app",
    "base_branch": "develop",
    "new_branch_name": "feature/JIRA-105-user-profile"
  }
  
  
  
  
  # Task
  User Request: Create a branch for ticket JIRA-123 'Add User Login' from 'develop'.
  Output:
  

Com os exemplos, o modelo aprende o padrão de nomenclatura type/JIRA-ID-description, o nome do repositório correto e a estrutura exata do JSON, tornando a saída muito mais previsível.

Para se aprofundar, você pode consultar o seguinte guia.

Chain-of-Thought (CoT) Prompting: Forçando o Raciocínio

Para tarefas que exigem lógica, planejamento ou múltiplos passos de raciocínio, o LLM muitas vezes erra ao tentar "pular" para a conclusão. Chain-of-Thought (CoT) Prompting combate isso, instruindo o modelo a detalhar seu processo de raciocínio passo a passo.

Isso pode ser feito de duas maneiras:

1. Zero-Shot CoT: Simplesmente adicione a frase "Let's think step by step." ou "Pense passo a passo." ao final do seu prompt.
2. Few-Shot CoT: Forneça um ou mais exemplos que não apenas mostrem a resposta final, mas também o raciocínio para chegar a ela.

O diagrama a seguir ilustra o poder do Few-Shot CoT.

Quando usar? É essencial para o seu projeto, especialmente para:

• Analisar um ticket do Jira e decompor a tarefa.
• Decidir quais arquivos em um grande codebase precisam ser modificados.
• Determinar se uma migração de banco de dados é necessária.

Exemplo Prático para o seu Agente:
Sua tarefa é analisar uma descrição do Jira para planejar as modificações.

• Prompt Padrão (arriscado):
  "Ticket: 'Usuários devem poder resetar sua senha. Adicione um botão na tela de login que envia um email com um link de reset.' Quais arquivos eu preciso mudar no nosso backend C# e frontend React?"
  O modelo pode listar arquivos genéricos como Login.js e UserController.cs, mas pode esquecer a camada de serviço, o envio de email, ou a nova rota da API.

• Prompt com Chain-of-Thought (robusto):

  Ticket: 'Usuários devem poder resetar sua senha. Adicione um botão na tela de login que envia um email com um link de reset.'
  
  Analise este ticket para criar um plano de implementação. Pense passo a passo:
  1.  **Análise de Requisitos da Interface (Frontend):** Que componentes de UI precisam ser criados ou modificados?
  2.  **Análise de Lógica de Negócio (Backend):** Quais novas endpoints de API são necessárias? Que serviços serão envolvidos (autenticação, notificação por email)?
  3.  **Análise de Dados (Banco de Dados):** É necessário armazenar o token de reset de senha? Se sim, em que tabela?
  4.  **Plano de Arquivos:** Com base na análise acima, liste os arquivos específicos a serem criados ou modificados para o backend (C#) e frontend (React).
  

Este prompt CoT força o modelo a seguir um processo de análise estruturado, muito parecido com o que um desenvolvedor sênior faria, aumentando drasticamente a qualidade e a completude do plano resultante.

Para mais detalhes sobre esta técnica poderosa, consulte o guia correspondente.

4. O Panorama das Técnicas

Few-shot e Chain-of-Thought são apenas duas de muitas técnicas. À medida que avançarmos no curso, especialmente quando falarmos sobre agentes que usam ferramentas (como chamar a API do GitHub), combinaremos essas técnicas com outras.

Conclusão

Parabéns! Você agora tem um framework prático para se comunicar de forma eficaz com LLMs. Em vez de tratá-los como caixas-pretas imprevisíveis, você pode usar a engenharia de prompts para guiá-los em direção a resultados confiáveis e de alta qualidade.

Principais Pontos:

• Prompt Engineering é Controle: É a principal maneira de instruir e restringir o comportamento de um LLM para uma tarefa específica.
• A Estrutura é Fundamental: Usar uma estrutura clara com Identity, Instructions, Examples e Context, formatada com Markdown, melhora drasticamente a compreensão do modelo.
• Few-Shot para Formato e Estilo: Quando precisar de saídas em um formato específico, forneça exemplos. "Mostre, não apenas diga."
• Chain-of-Thought para Complexidade: Para tarefas que exigem raciocínio, como planejamento e análise, force o modelo a "pensar passo a passo" para evitar erros e aumentar a precisão.

Estas técnicas são os verdadeiros blocos de construção para o "cérebro" do seu agente. Cada instrução que você der ao agente, desde a análise inicial do ticket até a geração final do código, será encapsulada em um prompt cuidadosamente construído usando esses princípios.

Na Próxima Lição:

Agora que sabemos como dar instruções eficazes a um LLM, o próximo passo é transformá-lo de um seguidor de instruções em um executor autônomo. Na próxima aula, vamos definir o que é um agente de IA e explorar o ciclo perceive-plan-act (perceber-planejar-agir) que o diferencia de um simples chatbot.