Code Review com Claude Code: Revise Codigo 10x Mais Rapido

Code review e o gargalo silencioso de quase todo time de desenvolvimento. Um PR fica aberto por horas -- as vezes dias -- esperando alguem disponivel para revisar. Quando finalmente acontece, o reviewer esta cansado, revisa superficialmente e aprova com um "LGTM" que nao significa nada.

O Claude Code muda essa dinamica. Ele analisa codigo com a profundidade de um senior que nao tem reunioes, nao esta cansado e nao tem pressa. Encontra bugs sutis, vulnerabilidades de seguranca, problemas de performance e violacoes de padrao -- em segundos, nao horas.

Neste guia, voce vai aprender a usar Claude Code como seu reviewer mais rigoroso. Desde o comando basico ate workflows completos de PR review com exemplos reais de antes e depois.

1. Por que code review com IA funciona

O review humano tem limitacoes inerentes que nao sao culpa do reviewer -- sao limitacoes cognitivas:

• Fadiga: depois de revisar 300 linhas, a atencao cai drasticamente. Estudos mostram que a eficacia de review cai 60% apos 60 minutos
• Vies de confirmacao: se o autor e confiavel, tendemos a revisar com menos rigor
• Conhecimento parcial: nem todo reviewer conhece todas as partes do codebase
• Pressao social: ninguem quer ser o "chato" que bloqueia um PR com 15 comentarios

O Claude Code nao tem nenhuma dessas limitacoes. Ele analisa cada linha com o mesmo rigor, conhece patterns de milhares de projetos, e nao se importa em apontar 50 problemas se existirem 50 problemas.

Isso nao significa que o review humano e dispensavel. Significa que a IA cuida da parte mecanica (bugs, patterns, seguranca) e o humano foca na parte estrategica (arquitetura, logica de negocio, trade-offs).

2. O comando /review na pratica

A forma mais direta de fazer code review com Claude Code e usar o comando /review. Ele analisa o codigo e retorna um relatorio estruturado.

O nivel de detalhe do review depende do prompt. Quanto mais contexto voce der, melhor o resultado:

• Sem contexto: "revise esse arquivo" -- review generico
• Com foco: "revise focando em seguranca" -- review direcionado
• Com contexto de negocio: "esse modulo lida com dados sensiveis de pacientes" -- review critico

Estrutura do relatorio de review

O Claude Code organiza o review em categorias de severidade:

3. Encontrando bugs antes da producao

O tipo mais valioso de review e aquele que encontra bugs que so apareceriam em producao. O Claude Code e especialmente bom em identificar:

Race conditions

// ANTES: bug sutil -- race condition
async function withdrawBalance(userId, amount) {
  const user = await db.getUser(userId);
  if (user.balance >= amount) {
    // Entre o check e o update, outro request pode mudar o saldo
    await db.updateBalance(userId, user.balance - amount);
    return { success: true };
  }
  return { success: false, error: 'Saldo insuficiente' };
}

// DEPOIS: correcao com operacao atomica
async function withdrawBalance(userId, amount) {
  const result = await db.query(
    `UPDATE users
     SET balance = balance - $1
     WHERE id = $2 AND balance >= $1
     RETURNING balance`,
    [amount, userId]
  );

  if (result.rowCount === 0) {
    return { success: false, error: 'Saldo insuficiente' };
  }
  return { success: true, newBalance: result.rows[0].balance };
}

O Claude Code identificou que o check-then-act nao e atomico e sugeriu uma operacao que faz check e update na mesma query, eliminando a race condition.

Off-by-one errors

// ANTES: bug na paginacao
function paginate(items, page, perPage) {
  const start = page * perPage;        // Pagina 1 comeca no indice perPage, nao 0
  const end = start + perPage;
  return items.slice(start, end);
}

// DEPOIS: corrigido
function paginate(items, page, perPage) {
  const start = (page - 1) * perPage;  // Pagina 1 comeca no indice 0
  const end = start + perPage;
  return items.slice(start, end);
}

Null pointer exceptions

// ANTES: crash se user.address for null
const city = user.address.city.toLowerCase();

// DEPOIS: safe access
const city = user.address?.city?.toLowerCase() ?? 'nao informado';

Esses bugs sao triviais quando voce os ve isolados. Mas em um PR com 500 linhas, perdidos entre logica de negocio, imports e configuracao, eles passam despercebidos pelo review humano com uma frequencia preocupante.

4. Review de seguranca automatizado

Vulnerabilidades de seguranca sao o tipo de problema mais caro de corrigir depois que chega em producao. O Claude Code identifica as mais comuns:

Vulnerabilidade	O que o Claude Code detecta
SQL Injection	Queries com concatenacao de string em vez de parametros
XSS	Inputs de usuario renderizados sem sanitizacao
IDOR	Acesso a recursos sem verificar ownership
Secrets expostos	API keys, tokens e senhas hardcoded
SSRF	URLs fornecidas pelo usuario sem validacao
Path traversal	File paths construidos com input do usuario

// ANTES: SQL injection
const users = await db.query(
  `SELECT * FROM users WHERE email = '${req.body.email}'`
);

// DEPOIS: query parametrizada
const users = await db.query(
  'SELECT * FROM users WHERE email = $1',
  [req.body.email]
);

// ANTES: IDOR -- qualquer usuario acessa qualquer pedido
app.get('/api/orders/:id', async (req, res) => {
  const order = await db.getOrder(req.params.id);
  res.json(order);
});

// DEPOIS: verificacao de ownership
app.get('/api/orders/:id', async (req, res) => {
  const order = await db.getOrder(req.params.id);
  if (!order || order.userId !== req.user.id) {
    return res.status(404).json({ error: 'Pedido nao encontrado' });
  }
  res.json(order);
});

5. Detectando problemas de performance

O Claude Code identifica padroes que causam lentidao, especialmente em escala:

N+1 queries

// ANTES: N+1 -- 1 query para pedidos + N queries para usuarios
const orders = await db.getOrders();
for (const order of orders) {
  order.user = await db.getUser(order.userId);  // Query por iteracao!
}

// DEPOIS: join ou batch loading
const orders = await db.query(`
  SELECT o.*, u.name as user_name, u.email as user_email
  FROM orders o
  JOIN users u ON u.id = o.user_id
  ORDER BY o.created_at DESC
`);

Memory leaks

// ANTES: event listener nunca removido (leak em SPA)
useEffect(() => {
  window.addEventListener('resize', handleResize);
}, []);

// DEPOIS: cleanup function
useEffect(() => {
  window.addEventListener('resize', handleResize);
  return () => window.removeEventListener('resize', handleResize);
}, []);

Operacoes bloqueantes

// ANTES: leitura sincrona bloqueia o event loop
const data = fs.readFileSync('/large-file.json', 'utf8');

// DEPOIS: leitura assincrona
const data = await fs.promises.readFile('/large-file.json', 'utf8');

6. Padroes e anti-patterns

Alem de bugs, o Claude Code identifica anti-patterns que prejudicam a manutencao do codigo a longo prazo:

Anti-patterns detectados automaticamente

• God functions: funcoes com mais de 50 linhas fazendo coisas demais
• Callback hell: promises aninhadas em vez de async/await
• Magic numbers: valores numericos sem nome ou contexto
• Copy-paste code: trechos duplicados que deveriam ser extraidos
• Barrel exports com side effects: index.ts que importa tudo e causa tree-shaking ruim
• Any abuse: TypeScript com any em vez de tipos adequados
• Console.log em producao: logs de debug que nao foram removidos
• Error swallowing: try/catch vazio ou que so faz console.log

O Claude Code nao apenas aponta o problema -- ele sugere a refatoracao concreta, com codigo pronto para aplicar.

7. Workflow de PR review completo

O cenario mais poderoso e integrar o Claude Code no seu workflow de pull requests. Aqui esta o processo recomendado:

Passo 1: review automatico no branch

Passo 2: corrigir problemas criticos

Passo 3: gerar descricao do PR

Esse workflow de 3 passos leva menos de 5 minutos e cobre o que levaria 1-2 horas de review humano. O reviewer humano depois foca no que importa: logica de negocio e decisoes de arquitetura.

8. Exemplos antes e depois

Exemplo 1: API endpoint fragil

// ANTES
app.post('/api/transfer', async (req, res) => {
  const { from, to, amount } = req.body;
  const sender = await db.getUser(from);
  sender.balance -= amount;
  await db.saveUser(sender);
  const receiver = await db.getUser(to);
  receiver.balance += amount;
  await db.saveUser(receiver);
  res.json({ ok: true });
});

Problemas encontrados pelo Claude Code:

• Sem validacao de input (amount pode ser negativo)
• Sem verificacao de saldo suficiente
• Sem transacao -- se o segundo save falhar, o dinheiro sumiu
• Sem autenticacao -- qualquer um pode transferir de qualquer conta
• Sem rate limiting

// DEPOIS
app.post('/api/transfer', authenticate, rateLimit({ max: 10, window: '1m' }),
  async (req, res) => {
    const { to, amount } = req.body;
    const from = req.user.id; // Do token de autenticacao

    // Validacao
    if (!to || !amount || amount <= 0 || amount > 100000) {
      return res.status(400).json({ error: 'Dados invalidos' });
    }

    // Transacao atomica
    const result = await db.transaction(async (trx) => {
      const sender = await trx.query(
        'UPDATE users SET balance = balance - $1 WHERE id = $2 AND balance >= $1 RETURNING balance',
        [amount, from]
      );
      if (sender.rowCount === 0) throw new Error('Saldo insuficiente');

      await trx.query(
        'UPDATE users SET balance = balance + $1 WHERE id = $2',
        [amount, to]
      );

      await trx.query(
        'INSERT INTO transfers (from_id, to_id, amount) VALUES ($1, $2, $3)',
        [from, to, amount]
      );

      return sender.rows[0].balance;
    });

    res.json({ ok: true, newBalance: result });
});

Exemplo 2: componente React com problemas

// ANTES
function UserList() {
  const [users, setUsers] = useState([]);

  useEffect(() => {
    fetch('/api/users').then(r => r.json()).then(setUsers);
  });  // Sem dependency array -- loop infinito!

  return users.map(u =>
    <div onClick={() => deleteUser(u.id)}>{u.name}</div>
  );
}

// DEPOIS
function UserList() {
  const [users, setUsers] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    let cancelled = false;
    async function fetchUsers() {
      try {
        const res = await fetch('/api/users');
        if (!res.ok) throw new Error('Falha ao carregar');
        const data = await res.json();
        if (!cancelled) setUsers(data);
      } catch (err) {
        if (!cancelled) setError(err.message);
      } finally {
        if (!cancelled) setLoading(false);
      }
    }
    fetchUsers();
    return () => { cancelled = true; };
  }, []);  // Dependency array correto

  if (loading) return <p>Carregando...</p>;
  if (error) return <p>Erro: {error}</p>;

  return (
    <ul role="list">
      {users.map(u => (
        <li key={u.id}>
          {u.name}
          <button onClick={() => deleteUser(u.id)}>Remover</button>
        </li>
      ))}
    </ul>
  );
}

9. Skills de review prontas

O pacote de skills Dev inclui skills especializadas para code review:

Skill	O que faz
/review	Review completo com categorias de severidade
/review-security	Foco em vulnerabilidades: SQLi, XSS, IDOR, SSRF
/review-performance	Detecta N+1, leaks, operacoes bloqueantes
/review-pr	Analisa diff do branch e gera relatorio de PR
/refactor	Identifica anti-patterns e sugere refatoracao
/simplify	Simplifica codigo complexo mantendo funcionalidade