Como automatizar a revisão de código com o Claude Code

Sua equipe envia mais rápido do que analisa.

Agentes de codificação de IA — Claude Code, Cursor, GitHub Copilot — geram pull requests mais rápido do que qualquer revisor humano pode lê-las. Um engenheiro sênior que costumava revisar três PRs antes do almoço agora enfrenta doze. O código parece limpo. Os testes passam. O linter está quieto.

Mas a página de checkout está quebrada.

Essa é a lacuna da revisão do código em 2025: a distância entre “o código está correto” e “o produto funciona”. A revisão de código tradicional, seja humana ou de inteligência artificial, lê as diferenças. Ele verifica a lógica, os padrões e a sintaxe. Ele não abre o aplicativo, clica no fluxo de finalização da compra, aplica um cupom e percebe que o total cai para menos quatro dólares.

A maioria das ferramentas de revisão de código de IA torna essa lacuna maior, não menor. Eles geram mais comentários, mais sugestões, mais ruído. Engenheiros do Reddit descrevem o padrão: “A análise de IA cria mais trabalho do que economiza, porque cada comentário precisa de um humano para verificar se é real”.

O problema não é que a revisão do código seja muito lenta. O problema é que a revisão do código está incompleta. Ele revisa o código. Ninguém analisa o produto.

Este guia mostra três níveis de automação de revisão de código:

1. Revisão manual — como a maioria das equipes faz isso hoje
2. Avaliação do Claude Code — análise automatizada de diferenças com /revisão e GitHub Actions
3. Revisão que prioriza o comportamento — Claude Code lê o código enquanto Sai testa o produto

Ao final, você saberá exatamente como configurar cada camada, quando usá-la e de onde vem a economia em tempo real.

‍

Claude Code é o agente de codificação de IA da Anthropic que é executado em seu terminal. Ele lê sua base de código, entende o contexto do projeto e pode revisar o código em um nível que vai muito além do simples linting.

O comando /review

A maneira mais rápida de obter uma revisão do Claude Code é a embutida /revisão comando:

# Review your current working changes
claude review

# Review a specific PR
claude review --pr 142

Claude Code analisa a diferença usando vários subagentes especializados:

• Revisor de lógica — verifica se há exatidão, casos extremos e regressões
• Revisor de segurança — verifica vulnerabilidades, exposição secreta e vetores de injeção
• Revisor de estilo — impõe convenções de nomenclatura, padrões e padrões de legibilidade
• Revisor de arquitetura — sinaliza problemas estruturais e violações de padrões

Cada subagente se concentra em seu domínio e reporta de forma independente. O resultado é uma revisão estruturada com descobertas categorizadas, níveis de gravidade e correções sugeridas.

Claude Code como uma ação do GitHub

Para uma análise automatizada de relações públicas em cada push, a Claude Code oferece uma ação no GitHub:

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          trigger: "review"

Uma vez configurado, Claude Code:

1. Recebe o webhook de relações públicas do GitHub
2. Clona o repositório e verifica a ramificação de relações públicas
3. Lê a diferença completa e o contexto circundante
4. Publica comentários em linha em linhas específicas
5. Adiciona um comentário resumido com a avaliação geral

Você também pode acionar avaliações manualmente comentando. Avaliação de @claude em qualquer PR.

O que a revisão de Claude Code faz bem

A revisão do Claude Code é genuinamente útil para:

• Detectando bugs lógicos que exigem a compreensão do contexto da base de código, não apenas das linhas alteradas
• Identificação da falta de tratamento de erros — ele lê o código ao redor e percebe quando uma função que pode ser lançada é chamada sem um try/catch
• Detectando regressões — ele entende o que o código fazia antes e sinaliza quando novas mudanças quebram o comportamento existente
• Reduzindo a fadiga dos revisores — ele lida com as verificações mecânicas para que os revisores humanos possam se concentrar nas decisões de arquitetura e produto

O que a revisão do Claude Code não pode fazer

Claude Code revisa o código. Ele não executa código. Isso significa que ele não pode:

• Abra um navegador e teste a interface de usuário real
• Verifique se uma alteração de CSS parece correta em diferentes tamanhos de tela
• Verifique se um fluxo de pagamento é concluído de ponta a ponta
• Observe que um botão agora está escondido atrás de outro elemento
• Reproduzir um bug a partir de uma captura de tela do usuário
• Acesse ferramentas com paredes de autenticação, como Sentry, Datadog ou painéis administrativos

Essa não é uma limitação específica do Claude Code — é a limitação fundamental da revisão baseada em diferenças. Nenhuma ferramenta que só lê código pode dizer se o produto funciona.

‍

The Gap: O que a análise de código de IA ainda perde

Aqui está um cenário real. Sua equipe usa a revisão do Claude Code em cada PR. Ele está configurado, em execução e detectando bugs reais. Então isso acontece:

PR #247: Atualize a lógica de cupons para descontos no carrinho

Claude Code analisa a diferença e descobre:

• Sem erros lógicos no cálculo do desconto
• Verificações nulas adequadas no objeto do cupom
• Os testes são aprovados para aplicar/remover o cupom
• Sem problemas de segurança

O PR é mesclado.

Duas horas depois, um usuário relata: “Eu apliquei um cupom de $5 no meu carrinho e removi um item. O total agora é negativo. Não consigo finalizar a compra.”

O que aconteceu? A lógica do cupom estava correta isoladamente. Mas a interação entre o aplicativo de cupom e a remoção do item do carrinho criou um estado que nenhum teste coberto e nenhum avaliador de diferenças — humano ou de inteligência artificial — detectaria apenas lendo o código.

Essa é a classe de bugs que cresce à medida que as bases de código se tornam mais complexas:

• Bugs de interação de estado — dois recursos que funcionam de forma independente, mas se separam
• Regressões visuais — mudanças de layout, elementos sobrepostos, designs responsivos quebrados
• Bugs dependentes do fluxo — problemas que só aparecem após uma sequência específica de ações do usuário
• Falhas específicas do ambiente — a encenação se comporta de forma diferente da local

Esses bugs compartilham uma característica: você só pode encontrá-los usando o produto.

‍

Sai é um agente de IA que é executado em um desktop na nuvem. Ele pode abrir navegadores, clicar em aplicativos, fazer capturas de tela, ler registros de erros e interagir com ferramentas como Sentry, Slack e GitHub, tudo isso enquanto é executado de forma autônoma.

Quando emparelhado com Claude Code, o ciclo de revisão muda fundamentalmente:

Análise tradicional da IA: O PR abre → A IA lê as diferenças → A IA publica comentários → Human verifica

Análise do Sai + Claude Code: PR abre → Claude Code lê diff → Sai abre o aplicativo → Sai testa os fluxos → Problemas com as capturas de tela de Sai → Claude Code corrige o código → Sai testa novamente → Relatório estruturado publicado

A principal diferença: o Claude Code revisa o código. Sai analisa o produto.

Como funciona o loop de 8 etapas

Etapa 1: acionar

O loop começa em uma das três fontes:

• Um GitHub PR é aberto ou atualizado (gatilho de webhook)
• Um usuário relata um bug (“o total do checkout é negativo após a aplicação de um cupom”)
• Um alerta do Sentry é acionado com um novo erro

A revisão tradicional começa com a diferença. Esse ciclo pode começar com a experiência do usuário.

Etapa 2: Claude Code analisa o código

O Claude Code lê o diferencial de relações públicas, entende o contexto da base de código e identifica possíveis problemas no nível do código — erros de lógica, casos extremos ausentes, questões de segurança.

Etapa 3: Sai abre a implantação prévia

Enquanto Claude Code lê o código, Sai abre o URL de visualização em um navegador real em seu desktop na nuvem. Ele faz login com uma conta de teste e navega até a área afetada.

Etapa 4: Sai testa os fluxos reais do usuário

Essa é a etapa crítica que nenhuma outra ferramenta de análise de IA executa. Diga:

• Adiciona itens ao carrinho de compras
• Aplica o código do cupom
• Modifica quantidades e remove itens
• Rendimentos para finalizar a compra
• Verifica se os totais, impostos e descontos são calculados corretamente
• Capturas de tela em cada etapa

Etapa 5: Sai gera etapas para reproduzir

Se algo quebrar, Sai produz um relatório de bug pronto para engenharia:

Etapas para reprodução:1. Adicione 3 laranjas a $2 cada. Total do carrinho: $6.002. Aplique o código de cupom SAVE5. Total do carrinho: $1.003. Retire uma laranja. Total do carrinho: -$1.004. Clique em finalizar compra. Erro: “Não é possível processar o total negativo”
Esperado: o total deve ser recalculado em $4,00 - $4,00 (limite) = $0,00Atual: O total mostra -$1,00 Capturas de tela: [before_coupon.png] [after_remove.png] Erros do console: NoneSentry: Nenhum novo erro registrado

Este não é um comentário vago sobre uma diferença. Este é um bilhete de controle de qualidade com evidências.

Etapa 6: Claude Code corrige o código

O Claude Code recebe as etapas de reprodução estruturada, as capturas de tela e o contexto de erro de Sai. Em vez de adivinhar o que pode estar errado, ele sabe exatamente:

• Qual página é afetada
• Qual sequência de operação aciona o bug
• Qual deve ser o comportamento esperado
• Qual é o comportamento real

Isso gera uma correção direcionada, não uma sugestão especulativa.

Etapa 7: Sai testa novamente a correção

Depois que o Claude Code corrige o código, Sai executa a mesma sequência de teste novamente:

• Aplicar cupom → remover item → verificar o total
• Verifique se o total não é mais negativo
• Capture capturas de tela antes/depois
• Verifique se há novos erros no Sentry

Etapa 8: relatório estruturado para Slack /GitHub

O resultado final é um relatório estruturado de controle de qualidade publicado no canal da sua equipe:

Sai QA Review: PR #247 — Coupon Discount Logic

Status: ✅ Fixed and verified

Issue found:
Cart total became negative when removing items after applying coupon.

Root cause:
Coupon discount was applied as fixed amount without 
recalculating against updated cart total.

Fix applied:
Added cap logic — discount cannot exceed current cart subtotal.

Verification:
- Before fix: Total = -$1.00 after removing item [screenshot]
- After fix: Total = $0.00, coupon capped correctly [screenshot]
- Sentry: No new errors
- Checkout flow: Completes successfully

Pré-requisitos

• Um repositório do GitHub com implantações de pré-visualização (Vercel, Netlify ou similar)
• Uma conta Claude Code (para análise de código)
• Uma conta Sai (para controle de qualidade visual e testes de navegador)

‍

Etapa 1: configurar o Claude Code GitHub Action

Adicione a ação de revisão do Claude Code ao seu repositório:

# .github/workflows/claude-review.yml
name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]
  issue_comment:
    types: [created]

jobs:
  review:
    if: |
      github.event_name == 'pull_request' ||
      contains(github.event.comment.body, '@claude')
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          trigger: "review"
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}

Isso oferece uma análise automatizada em nível de diferença em cada PR.

‍

Etapa 2: conectar o Sai ao seu repositório do GitHub

Em Sai, configure um fluxo de trabalho de webhook que seja acionado em eventos de relações públicas:

1. Abrir Sai → Configurações → Fluxos de trabalho
2. Crie um novo fluxo de trabalho de webhook
3. Selecione o GitHub como provedor
4. Escolha seu repositório
5. Defina o evento de gatilho como pull_request.opened

‍

Etapa 3: Definir fluxos de teste

Diga a Sai o que testar quando um PR toca áreas específicas:

When a PR modifies files in /src/checkout/:
1. Open preview deployment URL
2. Log in with test account
3. Add 3 items to cart
4. Apply coupon TESTCOUPON
5. Modify quantities
6. Remove one item
7. Proceed to checkout
8. Screenshot each step
9. Report any total that is negative or mismatched

‍

Etapa 4: configurar os relatórios

Escolha para onde Sai envia os resultados:

• Comentário do GitHub PR — em linha com a revisão do código
• Canal do Slack — para visibilidade da equipe
• Bilhete linear — para bloqueadores que precisam ser rastreados

‍

Etapa 5: executar e iterar

Os primeiros PRs calibrarão o sistema. Sai aprende quais fluxos são importantes, qual é a aparência de “correto” e onde ocorrem falsos positivos. Depois de uma semana, você terá um pipeline de análise que detecta automaticamente os problemas no nível do código e do produto.

‍

Cinco cenários do mundo real

Cenário 1: Bug de checkout de comércio eletrônico

Acionador: O PR atualiza a lógica de processamento de pagamentos.

Claude Code encontra: Falta o tratamento de erros de cartões recusados.

Sai descobre: Depois de um cartão recusado, o botão “Fazer pedido” permanece desativado mesmo quando o usuário insere um cartão válido. O botão giratório de carregamento nunca se apaga.

Resultado: O Claude Code corrige o tratamento de erros. Sai verifica se o botão é reativado após a inserção bem-sucedida do cartão. Um relatório publicado no Slack.

Cenário 2: Quebra do design responsivo do painel

Acionador: O PR refatora o layout da grade do painel.

Claude Code encontra: Sem problemas de lógica. As alterações de CSS parecem corretas.

Sai descobre: Na janela de visualização do tablet (768px), a barra lateral se sobrepõe à área de conteúdo principal. Dois widgets de gráfico estão completamente escondidos atrás do painel de navegação.

Resultado: Sai captura a tela da sobreposição em três pontos de interrupção. O Claude Code ajusta os valores do ponto de interrupção da grade. Sai testa novamente e confirma que o layout está limpo em todos os tamanhos.

Cenário 3: regressão do fluxo de autenticação

Acionador: O PR atualiza a integração OAuth para o Google Sign-In.

Claude Code encontra: A lógica de atualização do token parece correta. Os escopos estão configurados corretamente.

Sai descobre: Depois de fazer login com o Google, o redirecionamento chega a uma página 404 porque o URL de retorno de chamada foi atualizado no código, mas não na configuração do Google Cloud Console.

Resultado: Sai captura a tela do 404. A equipe atualiza o Google Cloud Console. Sai testa novamente o fluxo completo do OAuth — login, redirecionamento, criação da sessão — e confirma que ele funciona de ponta a ponta.

Cenário 4: Reproduzir um relatório de bug do usuário a partir de uma captura de tela

Acionador: Um usuário publica uma captura de tela no Slack: “Esta página parece quebrada”.

Claude Code sozinho: Não é possível processar uma captura de tela. Precisa de contexto de código.

Eu disse: Abre a mesma página, identifica o layout quebrado e clica nele para reproduzir o estado exato. Gera etapas para reproduzir com três capturas de tela anotadas. Entrega ao Claude Code os caminhos do arquivo, o URL da página e o comportamento esperado versus o comportamento real.

Resultado: O Claude Code identifica um conflito de índice z em um PR recém-mesclado. Corrige isso. Sai verifica se a página é renderizada corretamente.

Cenário 5: a alteração da API interrompe o front-end silenciosamente

Acionador: O backend PR muda a forma de resposta de /api/pedidos — renomeações quantida_total para Montante total.

Claude Code encontra: A alteração da API é consistente com a nova convenção de nomenclatura. Os testes de back-end são aprovados.

Sai descobre: A página de histórico de pedidos do front-end mostra “$NaN” para cada total de pedidos. O código do front-end ainda faz referência quantida_total.

Resultado: Sai captura a tela do histórico de pedidos quebrados. O Claude Code encontra a referência do frontend e a atualiza. Sai testa novamente a página do histórico de pedidos com dados reais.