Jeff Bruchado
Voltar para o Blog

Prompt Engineering Para Desenvolvedores em 2026: Guia Prático

Olá HaWkers, em 2026, saber escrever bons prompts para ferramentas de IA deixou de ser diferencial e se tornou habilidade básica. A diferença entre um desenvolvedor que usa IA bem e um que usa mal pode ser de 3-5x em produtividade.

Vamos explorar técnicas práticas para você extrair o máximo das ferramentas de IA.

Por Que Prompt Engineering Importa

O Impacto Real

// A diferença entre prompts bons e ruins

const promptComparison = {
  badPrompt: {
    input: 'Faz autenticação',
    result: 'Código genérico, provavelmente errado',
    iterations: '5-10 até funcionar',
    time: '30 minutos'
  },

  goodPrompt: {
    input: `
      Implemente autenticação JWT para a API Express existente.
      - Use a estrutura de middleware em src/middleware/
      - Siga o padrão de error handling de src/utils/errors.ts
      - Tokens devem expirar em 24h
      - Refresh tokens em 7 dias
      - Armazene refresh tokens no Redis (já configurado)
    `,
    result: 'Código alinhado com o projeto',
    iterations: '1-2',
    time: '5 minutos'
  },

  productivityGain: '6x mais rápido com bons prompts'
};

Princípios Fundamentais

1. Seja Específico

// RUIM: vago, deixa tudo para IA decidir
const badPrompt1 = "Cria um componente de formulário";

// BOM: específico sobre o que precisa
const goodPrompt1 = `
  Crie um componente React para formulário de cadastro de usuário.

  Campos:
  - Nome (obrigatório, min 2 caracteres)
  - Email (obrigatório, validação de email)
  - Senha (obrigatório, min 8 chars, 1 número, 1 especial)
  - Confirmação de senha

  Requisitos:
  - Use React Hook Form para gerenciamento
  - Validação com Zod
  - Exiba erros inline abaixo de cada campo
  - Botão submit desabilitado enquanto inválido
  - Mostre loading state durante submit
`;

2. Forneça Contexto

// RUIM: sem contexto do projeto
const badPrompt2 = "Adiciona paginação na lista";

// BOM: contexto completo
const goodPrompt2 = `
  Adicione paginação à lista de produtos em ProductList.tsx.

  Contexto do projeto:
  - Usamos TanStack Query para data fetching
  - API retorna: { data: Product[], total: number, page: number }
  - Endpoint: GET /api/products?page=1&limit=20
  - Design system: Tailwind + componentes em src/components/ui/

  Comportamento esperado:
  - 20 itens por página
  - Mostrar "Página X de Y"
  - Botões Anterior/Próximo
  - Desabilitar botões nos limites
  - Manter scroll position ao trocar página
`;

3. Mostre Exemplos

// RUIM: espera que IA adivinhe o padrão
const badPrompt3 = "Cria um hook para API";

// BOM: mostra padrão existente
const goodPrompt3 = `
  Crie um hook useProducts seguindo o padrão existente.

  Exemplo de hook existente (useUsers.ts):
  \`\`\`typescript
  export function useUsers(filters: UserFilters) {
    return useQuery({
      queryKey: ['users', filters],
      queryFn: () => api.users.list(filters),
      staleTime: 5 * 60 * 1000,
    });
  }

  export function useUser(id: string) {
    return useQuery({
      queryKey: ['user', id],
      queryFn: () => api.users.get(id),
      enabled: !!id,
    });
  }

  export function useCreateUser() {
    const queryClient = useQueryClient();
    return useMutation({
      mutationFn: api.users.create,
      onSuccess: () => {
        queryClient.invalidateQueries({ queryKey: ['users'] });
      },
    });
  }
  \`\`\`

  Crie hooks equivalentes para Products com:
  - useProducts(filters)
  - useProduct(id)
  - useCreateProduct()
  - useUpdateProduct()
  - useDeleteProduct()
`;

Técnicas Avançadas

Chain of Thought

// Peça para IA pensar passo a passo

const chainOfThoughtPrompt = `
  Preciso otimizar esta query SQL que está lenta.

  Query atual:
  \`\`\`sql
  SELECT * FROM orders o
  JOIN users u ON o.user_id = u.id
  JOIN products p ON o.product_id = p.id
  WHERE o.created_at > '2025-01-01'
  ORDER BY o.created_at DESC
  \`\`\`

  Tabelas:
  - orders: 10M rows
  - users: 500K rows
  - products: 50K rows

  Por favor:
  1. Primeiro, analise por que a query pode estar lenta
  2. Liste possíveis problemas (índices, joins, select *)
  3. Sugira otimizações em ordem de impacto
  4. Forneça a query otimizada final
  5. Explique quais índices criar
`;

// A IA vai pensar estruturadamente, não só chutar uma resposta

Few-Shot Learning

// Mostre exemplos do que você quer

const fewShotPrompt = `
  Converta estes testes Jest para Vitest.

  Exemplo de conversão:

  Jest:
  \`\`\`typescript
  import { render, screen } from '@testing-library/react';

  describe('Button', () => {
    it('renders correctly', () => {
      render(<Button>Click me</Button>);
      expect(screen.getByRole('button')).toHaveTextContent('Click me');
    });

    it('calls onClick when clicked', () => {
      const handleClick = jest.fn();
      render(<Button onClick={handleClick}>Click</Button>);
      screen.getByRole('button').click();
      expect(handleClick).toHaveBeenCalledTimes(1);
    });
  });
  \`\`\`

  Vitest:
  \`\`\`typescript
  import { render, screen } from '@testing-library/react';
  import { describe, it, expect, vi } from 'vitest';

  describe('Button', () => {
    it('renders correctly', () => {
      render(<Button>Click me</Button>);
      expect(screen.getByRole('button')).toHaveTextContent('Click me');
    });

    it('calls onClick when clicked', () => {
      const handleClick = vi.fn();
      render(<Button onClick={handleClick}>Click</Button>);
      screen.getByRole('button').click();
      expect(handleClick).toHaveBeenCalledTimes(1);
    });
  });
  \`\`\`

  Agora converta estes testes: [colar testes]
`;

Constraints (Restrições)

// Defina limites claros

const constraintsPrompt = `
  Refatore a função processOrder para melhor legibilidade.

  Restrições:
  - NÃO mude a assinatura da função
  - NÃO adicione dependências externas
  - NÃO mude o comportamento (testes devem continuar passando)
  - MANTENHA compatibilidade com Node 18
  - MÁXIMO 50 linhas de código

  Foco:
  - Extrair funções auxiliares se necessário
  - Nomes de variáveis mais claros
  - Remover código duplicado
  - Adicionar early returns onde fizer sentido
`;

Prompts Por Situação

Debug

const debugPrompt = `
  Estou recebendo este erro e preciso de ajuda para debugar.

  Erro:
  \`\`\`
  TypeError: Cannot read properties of undefined (reading 'map')
    at ProductList (ProductList.tsx:25:18)
    at renderWithHooks (react-dom.development.js:14985:18)
  \`\`\`

  Código relevante:
  \`\`\`typescript
  // ProductList.tsx
  function ProductList({ categoryId }: Props) {
    const { data } = useProducts(categoryId);

    return (
      <ul>
        {data.products.map(p => (  // linha 25
          <li key={p.id}>{p.name}</li>
        ))}
      </ul>
    );
  }
  \`\`\`

  O que já verifiquei:
  - A API está retornando dados corretamente (testei no Postman)
  - categoryId está definido (loguei e confirmei)

  O que pode estar causando isso e como corrigir?
`;

Code Review

const codeReviewPrompt = `
  Faça code review deste PR focando em:
  1. Bugs potenciais
  2. Problemas de segurança
  3. Performance
  4. Legibilidade
  5. Aderência aos padrões do projeto

  Padrões do projeto:
  - Usamos early returns
  - Errors são tratados com try/catch em boundaries
  - Validação de input com Zod
  - Tipos explícitos (sem 'any')

  Código para review:
  \`\`\`typescript
  [colar código]
  \`\`\`

  Para cada problema encontrado, indique:
  - Severidade (crítico/alto/médio/baixo)
  - Linha do código
  - Explicação do problema
  - Sugestão de correção
`;

Arquitetura

const architecturePrompt = `
  Preciso decidir a arquitetura para um novo sistema de notificações.

  Requisitos:
  - 100K usuários ativos
  - Notificações push, email e in-app
  - Prioridades diferentes (urgente, normal, baixa)
  - Retry automático para falhas
  - Analytics de entrega

  Stack atual:
  - Node.js/Express
  - PostgreSQL
  - Redis
  - AWS (podemos usar mais serviços)

  Por favor:
  1. Sugira 2-3 abordagens arquiteturais
  2. Liste prós e contras de cada uma
  3. Recomende uma com justificativa
  4. Esboce o diagrama de componentes
  5. Liste riscos e mitigações
`;

Prompts Para Ferramentas Específicas

GitHub Copilot

// Copilot funciona melhor com comentários estruturados

// Função: Valida CPF brasileiro
// Input: string com ou sem formatação
// Output: boolean indicando se é válido
// Regras: Verifica dígitos verificadores
function validateCPF(cpf: string): boolean {
  // Copilot vai completar baseado no comentário
}

// Para Copilot Chat
// Use @ para referenciar arquivos
// @workspace /explain como funciona a autenticação?
// @terminal qual comando para rodar testes?

Cursor

// Cursor funciona bem com Composer (Ctrl+I)

/*
Prompt para Composer:

Refatore o sistema de cache em src/cache/ para:
1. Usar Redis em vez de memory cache
2. Manter interface existente (não quebrar consumers)
3. Adicionar TTL configurável
4. Adicionar métricas de hit/miss
5. Implementar cache invalidation por padrão

Arquivos para modificar:
- src/cache/index.ts
- src/cache/providers/memory.ts → redis.ts
- src/config/cache.ts (criar)

Não modifique os testes ainda, vou fazer depois.
*/

Claude (API/Console)

// Claude é bom para raciocínio complexo

const claudePrompt = `
  <context>
  Sou tech lead de um time de 5 pessoas.
  Temos um monolito Node.js com 200K linhas de código.
  Performance está degradando e precisamos decidir o caminho.
  </context>

  <question>
  Devemos migrar para microserviços ou otimizar o monolito?
  </question>

  <constraints>
  - Time pequeno (5 devs)
  - Budget limitado para infra
  - Não podemos parar features por mais de 1 sprint
  - Precisamos de resultado em 6 meses
  </constraints>

  Por favor analise ambas opções considerando nosso contexto
  específico, não genérico. Inclua:
  - Riscos reais para nosso cenário
  - Esforço estimado (em sprints)
  - Impacto em produtividade durante migração
  - Recomendação final com justificativa
`;

Anti-Patterns

O Que NÃO Fazer

// Erros comuns em prompts

const antiPatterns = {
  vague: {
    bad: "Melhora esse código",
    why: "IA não sabe o que 'melhor' significa pra você",
    fix: "Especifique: legibilidade? performance? segurança?"
  },

  noContext: {
    bad: "Adiciona validação",
    why: "Validação de quê? Onde? Com qual lib?",
    fix: "Dê contexto do projeto e requisitos específicos"
  },

  tooLong: {
    bad: "[5 páginas de requisitos]",
    why: "IA perde foco em prompts muito longos",
    fix: "Divida em tarefas menores e específicas"
  },

  assuming: {
    bad: "Usa o padrão normal",
    why: "IA não sabe qual é 'seu' padrão",
    fix: "Mostre exemplo do padrão que você usa"
  },

  noExamples: {
    bad: "Converte pra nosso estilo",
    why: "IA não conhece seu estilo",
    fix: "Inclua exemplo de código no estilo desejado"
  }
};

Iteração Eficiente

// Como iterar quando o resultado não é bom

const iterationStrategy = {
  step1: {
    action: 'Não descarte, refine',
    example: `
      Bom começo, mas:
      - O error handling está muito verboso
      - Prefiro early returns a else aninhados
      - Adicione tipos explícitos nos parâmetros

      Ajuste mantendo a lógica geral.
    `
  },

  step2: {
    action: 'Seja específico sobre o problema',
    example: `
      A função validateEmail tem um bug:
      - Aceita "test@" como válido (não deveria)
      - Não aceita "test+tag@gmail.com" (deveria)

      Corrija apenas a regex, mantenha o resto.
    `
  },

  step3: {
    action: 'Peça explicação se não entender',
    example: `
      Por que você usou reduce aqui em vez de map + filter?
      Qual a vantagem de performance ou legibilidade?
    `
  }
};

Construindo Prompts Reutilizáveis

Templates

// Crie templates para tarefas comuns

const promptTemplates = {
  newComponent: `
    Crie um componente React [NOME] com:

    Props:
    [LISTA DE PROPS]

    Comportamento:
    [DESCRIÇÃO]

    Estilo:
    - Use Tailwind
    - Siga padrões de src/components/ui/

    Testes:
    - Inclua testes básicos de renderização
    - Teste interações principais
  `,

  apiEndpoint: `
    Crie endpoint [MÉTODO] [ROTA] que:

    Request:
    [BODY/PARAMS]

    Response:
    [FORMATO]

    Validação:
    - Use Zod para validar input
    - Retorne erros no formato padrão

    Segurança:
    - [AUTENTICAÇÃO NECESSÁRIA?]
    - [RATE LIMITING?]
  `,

  bugFix: `
    Bug: [DESCRIÇÃO]

    Como reproduzir:
    [PASSOS]

    Comportamento esperado:
    [O QUE DEVERIA ACONTECER]

    Comportamento atual:
    [O QUE ESTÁ ACONTECENDO]

    Código relevante:
    \`\`\`
    [CÓDIGO]
    \`\`\`

    Encontre a causa raiz e sugira correção.
  `
};

Conclusão

Prompt engineering em 2026 não é sobre "hackear" a IA - é sobre comunicação clara. Os mesmos princípios que fazem você um bom comunicador com humanos (clareza, contexto, exemplos) fazem você eficiente com IA.

Resumo das melhores práticas:

  1. Seja específico: Diga exatamente o que quer
  2. Dê contexto: Projeto, padrões, constraints
  3. Mostre exemplos: Do estilo que você quer
  4. Itere: Refine em vez de recomeçar
  5. Questione: Entenda o "porquê" das respostas

A IA é uma ferramenta poderosa, mas a qualidade do output depende da qualidade do input. Invista tempo aprendendo a se comunicar bem com ela.

Para entender mais sobre o impacto da IA no desenvolvimento, leia: Agentes de IA em 2026.

Bora pra cima! 🦅

Comentários (0)

Esse artigo ainda não possui comentários 😢. Seja o primeiro! 🚀🦅

Adicionar comentário