Code Review Checklist

Lista de Verificação para Revisão de Código

Visão Geral

Fornece uma lista de verificação sistemática para conduzir revisões de código minuciosas. Esta habilidade ajuda revisores a garantir qualidade de código, capturar bugs, identificar problemas de segurança e manter consistência em toda a base de código.

Quando Usar Esta Habilidade

• Use ao revisar pull requests
• Use ao conduzir auditorias de código
• Use ao estabelecer padrões de revisão de código para um time
• Use ao treinar novos desenvolvedores em práticas de revisão de código
• Use quando quiser garantir que nada seja perdido nas revisões
• Use ao criar documentação de revisão de código

Como Funciona

Etapa 1: Entenda o Contexto

Antes de revisar o código, vou ajudar você a entender:

• Qual problema este código resolve?
• Quais são os requisitos?
• Quais arquivos foram alterados e por quê?
• Existem issues ou tickets relacionados?
• Qual é a estratégia de testes?

Etapa 2: Revise a Funcionalidade

Verifique se o código funciona corretamente:

• Ele resolve o problema declarado?
• Casos extremos são tratados?
• O tratamento de erros é apropriado?
• Existem erros lógicos?
• Ele corresponde aos requisitos?

Etapa 3: Revise a Qualidade do Código

Avalie a manutenibilidade do código:

• O código é legível e claro?
• Os nomes são descritivos?
• Está adequadamente estruturado?
• As funções/métodos são focadas?
• Há complexidade desnecessária?

Etapa 4: Revise a Segurança

Verifique se há problemas de segurança:

• As entradas são validadas?
• Os dados sensíveis estão protegidos?
• Existem riscos de SQL injection?
• A autenticação/autorização está correta?
• As dependências são seguras?

Etapa 5: Revise o Desempenho

Procure por problemas de desempenho:

• Existem loops desnecessários?
• O acesso ao banco de dados está otimizado?
• Existem vazamentos de memória?
• O cache é usado adequadamente?
• Existem problemas de consulta N+1?

Etapa 6: Revise os Testes

Verifique a cobertura de testes:

• Existem testes para o novo código?
• Os testes cobrem casos extremos?
• Os testes são significativos?
• Todos os testes passam?
• A cobertura de testes é adequada?

Exemplos

Exemplo 1: Lista de Verificação de Revisão de Funcionalidade

## Revisão de Funcionalidade

### Requisitos
- [ ] O código resolve o problema declarado
- [ ] Todos os critérios de aceitação são atendidos
- [ ] Casos extremos são tratados
- [ ] Casos de erro são tratados
- [ ] Entrada do usuário é validada

### Lógica
- [ ] Sem erros lógicos ou bugs
- [ ] Condições estão corretas (sem erros off-by-one)
- [ ] Loops terminam corretamente
- [ ] Recursão possui casos base apropriados
- [ ] Gerenciamento de estado está correto

### Tratamento de Erros
- [ ] Erros são capturados apropriadamente
- [ ] Mensagens de erro são claras e úteis
- [ ] Erros não expõem informações sensíveis
- [ ] Operações falhadas são revertidas
- [ ] Logging é apropriado

### Exemplos de Problemas a Capturar:

**❌ Ruim - Validação ausente:**
\`\`\`javascript
function createUser(email, password) {
  // Sem validação!
  return db.users.create({ email, password });
}
\`\`\`

**✅ Bom - Validação apropriada:**
\`\`\`javascript
function createUser(email, password) {
  if (!email || !isValidEmail(email)) {
    throw new Error('Endereço de email inválido');
  }
  if (!password || password.length < 8) {
    throw new Error('Senha deve ter pelo menos 8 caracteres');
  }
  return db.users.create({ email, password });
}
\`\`\`

Exemplo 2: Lista de Verificação de Revisão de Segurança

## Revisão de Segurança

### Validação de Entrada
- [ ] Todas as entradas do usuário são validadas
- [ ] SQL injection é prevenido (use consultas parametrizadas)
- [ ] XSS é prevenido (escape output)
- [ ] Proteção CSRF está em vigor
- [ ] Upload de arquivos é validado (tipo, tamanho, conteúdo)

### Autenticação & Autorização
- [ ] Autenticação é exigida quando necessário
- [ ] Verificações de autorização estão presentes
- [ ] Senhas são criptografadas (nunca armazenadas em texto plano)
- [ ] Sessões são gerenciadas com segurança
- [ ] Tokens expiram apropriadamente

### Proteção de Dados
- [ ] Dados sensíveis são criptografados
- [ ] Chaves de API não estão hardcoded
- [ ] Variáveis de ambiente são usadas para secrets
- [ ] Dados pessoais seguem regulamentações de privacidade
- [ ] Credenciais de banco de dados estão seguras

### Dependências
- [ ] Sem dependências vulneráveis conhecidas
- [ ] Dependências estão atualizadas
- [ ] Dependências desnecessárias são removidas
- [ ] Versões de dependências estão fixadas

### Exemplos de Problemas a Capturar:

**❌ Ruim - Risco de SQL injection:**
\`\`\`javascript
const query = \`SELECT * FROM users WHERE email = '\${email}'\`;
db.query(query);
\`\`\`

**✅ Bom - Consulta parametrizada:**
\`\`\`javascript
const query = 'SELECT * FROM users WHERE email = $1';
db.query(query, [email]);
\`\`\`

**❌ Ruim - Secret hardcoded:**
\`\`\`javascript
const API_KEY = 'sk_live_abc123xyz';
\`\`\`

**✅ Bom - Variável de ambiente:**
\`\`\`javascript
const API_KEY = process.env.API_KEY;
if (!API_KEY) {
  throw new Error('A variável de ambiente API_KEY é obrigatória');
}
\`\`\`

Exemplo 3: Lista de Verificação de Revisão de Qualidade de Código

## Revisão de Qualidade de Código

### Legibilidade
- [ ] Código é fácil de entender
- [ ] Nomes de variáveis são descritivos
- [ ] Nomes de funções explicam o que fazem
- [ ] Lógica complexa possui comentários
- [ ] Números mágicos são substituídos por constantes

### Estrutura
- [ ] Funções são pequenas e focadas
- [ ] Código segue princípio DRY (Don't Repeat Yourself)
- [ ] Separação adequada de responsabilidades
- [ ] Estilo de código consistente
- [ ] Sem código morto ou comentado

### Manutenibilidade
- [ ] Código é modular e reutilizável
- [ ] Dependências são mínimas
- [ ] Mudanças são retrocompatíveis
- [ ] Mudanças disruptivas estão documentadas
- [ ] Débito técnico é anotado

### Exemplos de Problemas a Capturar:

**❌ Ruim - Nomes pouco claros:**
\`\`\`javascript
function calc(a, b, c) {
  return a * b + c;
}
\`\`\`

**✅ Bom - Nomes descritivos:**
\`\`\`javascript
function calculateTotalPrice(quantity, unitPrice, tax) {
  return quantity * unitPrice + tax;
}
\`\`\`

**❌ Ruim - Função fazendo muita coisa:**
\`\`\`javascript
function processOrder(order) {
  // Validar pedido
  if (!order.items) throw new Error('Sem itens');
  
  // Calcular total
  let total = 0;
  for (let item of order.items) {
    total += item.price * item.quantity;
  }
  
  // Aplicar desconto
  if (order.coupon) {
    total *= 0.9;
  }
  
  // Processar pagamento
  const payment = stripe.charge(total);
  
  // Enviar email
  sendEmail(order.email, 'Pedido confirmado');
  
  // Atualizar inventário
  updateInventory(order.items);
  
  return { orderId: order.id, total };
}
\`\`\`

**✅ Bom - Responsabilidades separadas:**
\`\`\`javascript
function processOrder(order) {
  validateOrder(order);
  const total = calculateOrderTotal(order);
  const payment = processPayment(total);
  sendOrderConfirmation(order.email);
  updateInventory(order.items);
  
  return { orderId: order.id, total };
}
\`\`\`

Boas Práticas

✅ Faça Isto

• Revise Mudanças Pequenas - PRs menores são mais fáceis de revisar minuciosamente
• Verifique Testes Primeiro - Certifique-se que testes passam e cobrem código novo
• Execute o Código - Teste localmente quando possível
• Faça Perguntas - Não assuma, peça esclarecimentos
• Seja Construtivo - Sugira melhorias, não apenas critique
• Foque em Problemas Importantes - Não seja excessivamente crítico com problemas menores de estilo
• Use Ferramentas Automatizadas - Linters, formatadores, scanners de segurança
• Revise Documentação - Verifique se documentação está atualizada
• Considere Desempenho - Pense em escala e eficiência
• Verifique Regressões - Garanta que funcionalidade existente ainda funciona

❌ Não Faça Isto

• Não Aprove Sem Ler - Realmente revise o código
• Não Seja Vago - Forneça feedback específico com exemplos
• Não Ignore Segurança - Problemas de segurança são críticos
• Não Pule Testes - Código sem testes causará problemas
• Não Seja Rude - Seja respeitoso e profissional
• Não Aprovação Automática - Cada revisão deve agregar valor
• Não Revise Quando Cansado - Você perderá problemas importantes
• Não Esqueça Contexto - Entenda o quadro maior

Lista de Verificação Completa para Revisão

Antes da Revisão

• Leia a descrição do PR e issues relacionadas
• Entenda qual problema está sendo resolvido
• Verifique se testes passam em CI/CD
• Baixe o branch e execute localmente

Funcionalidade

• Código resolve o problema declarado
• Casos extremos são tratados
• Tratamento de erros é apropriado
• Entrada do usuário é validada
• Sem erros lógicos

Segurança

• Sem vulnerabilidades de SQL injection
• Sem vulnerabilidades de XSS
• Autenticação/autorização está correta
• Dados sensíveis estão protegidos
• Sem secrets hardcoded

Desempenho

• Sem consultas de banco de dados desnecessárias
• Sem problemas de consulta N+1
• Algoritmos eficientes usados
• Sem vazamentos de memória
• Cache usado apropriadamente

Qualidade de Código

• Código é legível e claro
• Nomes são descritivos
• Funções são focadas e pequenas
• Sem duplicação de código
• Segue convenções do projeto

Testes

• Código novo possui testes
• Testes cobrem casos extremos
• Testes são significativos
• Todos os testes passam
• Cobertura de testes é adequada

Documentação

• Comentários de código explicam por quê, não o quê
• Documentação de API está atualizada
• README é atualizado se necessário
• Mudanças disruptivas estão documentadas
• Guia de migração fornecido se necessário

Git

• Mensagens de commit são claras
• Sem conflitos de merge
• Branch está atualizado com main
• Sem arquivos desnecessários commitados
• .gitignore está adequadamente configurado

Armadilhas Comuns

Problema: Casos Extremos Ausentes

Sintomas: Código funciona no caminho feliz mas falha em casos extremos Solução: Faça perguntas "E se...?"

• E se a entrada for null?
• E se o array estiver vazio?
• E se o usuário não estiver autenticado?
• E se a requisição de rede falhar?

Problema: Vulnerabilidades de Segurança

Sintomas: Código expõe riscos de segurança Solução: Use lista de verificação de segurança

• Execute scanners de segurança (npm audit, Snyk)
• Verifique OWASP Top 10
• Valide todas as entradas
• Use consultas parametrizadas
• Nunca confie em entrada do usuário

Problema: Cobertura de Testes Inadequada

Sintomas: Código novo não possui testes ou testes inadequados Solução: Exija testes para todo código novo

• Testes unitários para funções
• Testes de integração para features
• Testes de casos extremos
• Testes de casos de erro

Problema: Código Pouco Claro

Sintomas: Revisor não consegue entender o que código faz Solução: Solicite melhorias

• Melhores nomes de variáveis
• Comentários explicativos
• Funções menores
• Estrutura clara

Modelos de Comentários de Revisão

Solicitando Mudanças

**Problema:** [Descreva o problema]

**Código atual:**
\`\`\`javascript
// Mostre código problemático
\`\`\`

**Sugestão de correção:**
\`\`\`javascript
// Mostre código melhorado
\`\`\`

**Por quê:** [Explique por que isto é melhor]

Fazendo Perguntas

**Pergunta:** [Sua pergunta]

**Contexto:** [Por que você está perguntando]

**Sugestão:** [Se você tiver uma]

Elogiando Código Bom

**Legal!** [O que você gostou]

Isto é ótimo porque [explique por quê]

Habilidades Relacionadas

• @requesting-code-review - Prepare código para revisão
• @receiving-code-review - Lide com feedback de revisão
• @systematic-debugging - Debug de problemas encontrados na revisão
• @test-driven-development - Garanta que código possui testes

Recursos Adicionais

• Guias de Revisão de Código do Google
• OWASP Top 10
• Boas Práticas de Revisão de Código
• Como Revisar Código

Dica Profissional: Use um modelo de lista de verificação para cada revisão a fim de garantir consistência e minuciosidade. Personalize-o conforme as necessidades específicas do seu time!