Skip to content

artubss/SKILLS-CLAUDE-CODE / skills/skills/development/code-review-checklist

code-review-checklist

Unverified

Lista de verificação abrangente para conduzir revisões de código minuciosas, cobrindo funcionalidade, segurança, desempenho e manutenibilidade

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


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!

receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 318kUpdated Claude CodeCodexUnverifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 318kUpdated Claude CodeCodexUnverifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 318kUpdated Claude CodeCodexUnverifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 318kUpdated Claude CodeCodexUnverifiedInstall