code review
Code review na era da IA: livros para revisar melhor
Quando a IA escreve boa parte do código, o code review muda de papel. Veja o que revisar, onde pôr a atenção humana e três livros que ajudam.

Atualizado em · Equipe Estante Dev
Durante muito tempo, code review foi um ritual simples: alguém escreve o código, abre um pull request e um colega lê linha por linha antes do merge. Esse modelo pressupõe que escrever código é caro e lento, e que ler é relativamente barato. Com agentes de IA gerando boa parte das mudanças, essa conta virou. Hoje é fácil produzir muito mais código do que um time consegue ler com atenção.
Em 15 de outubro de 2026, um artigo de Addy Osmani, Morgan Westlee Lunt e Qing Wang no blog claude.dev, How the Claude Code team does code review, viralizou entre devs ao descrever como o time do Claude Code, na Anthropic, reorganizou a revisão para lidar com esse volume. Este guia resume as ideias centrais do artigo e indica três livros que ajudam a revisar melhor, com ou sem IA no fluxo.
O problema: volume demais para ler linha por linha
Segundo o artigo, o número de mudanças que chegam por dia ao monorepo da Anthropic passou de cerca de 2.500 em maio para mais de 30.000 em setembro de 2026. Mesmo que o seu time esteja longe dessa escala, o padrão é o mesmo: quando a geração de código fica barata, a revisão humana vira o gargalo.
O artigo lembra que o code review faz dois trabalhos:
- encontrar e corrigir problemas antes que cheguem à produção.
- construir contexto compartilhado sobre o código dentro do time.
E propõe uma troca de pergunta. Em vez de “um humano leu o código?”, a pergunta passa a ser “o que pode dar errado com esta mudança, e qual verificação, automática ou humana, é a certa para pegar isso?”.
A ideia central: camadas, não um único portão
Em vez de um portão único no fim do processo, o artigo descreve várias camadas de verificação, cada uma pegando alguns problemas e deixando passar outros, com a capacidade de reverter rápido por baixo de todas. O artigo lista sete camadas, nesta ordem:
- verificação antes do PR: o agente recebe algo que pode executar (testes, build, comparação de tela) e precisa mostrar o resultado, não só dizer que terminou. Depois, um subagente revisa o diff com contexto novo.
- revisão por IA em todo PR.
- revisão de segurança automática, que bloqueia o merge enquanto houver achado aberto.
- checagens automáticas: lint, tipos, testes em todas as plataformas e build.
- aprovação humana proporcional ao risco: mudanças de baixo risco (docs, texto, recursos internos, mudanças aditivas atrás de flag) não exigem aprovação humana depois que as revisões automáticas ficam verdes, as de risco médio pedem uma pessoa e as de alto risco pedem duas.
- fila de merge, feature flags e release gradual.
- detecção e rollback rápidos.
Dois princípios aparecem com força. O primeiro: a aprovação de uma IA nunca substitui um humano obrigatório. O segundo: quem pediu a mudança responde por ela (“whoever prompted the change is on the hook for it”). Em PR escrito por agente, quem conduziu o agente conta como um dos revisores obrigatórios. A IA muda quem lê cada linha, mas não muda quem responde pelo que foi para produção.
Outro ponto prático: quando o revisor automático aponta o mesmo problema várias vezes, o time corrige na origem, com uma regra de lint, ajustando uma skill ou atualizando arquivos de instrução como o CLAUDE.md, que descreve stack, convenções, objetivos e não objetivos do projeto.
Como o time mede se está funcionando
O artigo trata a atenção humana como o recurso escasso. O objetivo declarado é que a maioria dos PRs nos repositórios do Claude Code seja integrada com no máximo um humano no circuito (que pode ser o próprio autor), sem aumentar reverts nem incidentes. Para isso, o time acompanha aprovações humanas por PR (mediana e percentil 95), comentários humanos e quanto tempo um PR espera por uma pessoa. Taxas de revert e de incidente funcionam como trava de segurança: se subirem, o tempo humano não foi economizado, só mudou de lugar.
Essa é a parte mais transferível para qualquer time: não medir só a velocidade da revisão, e sim velocidade e estabilidade juntas.
Por que livros “antigos” ajudam nessa mudança
Nada disso funciona se o código for difícil de verificar. Revisão baseada em risco depende de mudanças pequenas, testes confiáveis e métricas de entrega bem escolhidas. São exatamente os temas de três clássicos.
Refactoring, de Martin Fowler
Refactoring ensina a mudar a estrutura do código sem mudar o comportamento, em passos pequenos e seguros, sempre apoiados por testes. Para quem revisa código gerado por IA, o livro oferece duas coisas:
- vocabulário para revisar: os “code smells” (método longo, duplicação, classe grande demais) ajudam a dar nome ao que incomoda num diff, em vez de um vago “não gostei”.
- disciplina de passos pequenos: um diff que mistura refatoração com mudança de comportamento é difícil de revisar, venha de uma pessoa ou de um agente. Separar as duas coisas é uma das regras mais úteis para pedir a uma IA.
Quando o artigo fala em uma skill que “simplifica o diff” antes do PR, a ideia conversa diretamente com o que Fowler descreve: deixar a mudança no menor tamanho que ainda faça sentido.
Working Effectively with Legacy Code, de Michael Feathers
Feathers define código legado como código sem testes. Por essa definição, muito código gerado às pressas, por gente ou por IA, já nasce legado. Working Effectively with Legacy Code mostra como colocar sob teste um código que não foi pensado para isso: encontrar “seams” (pontos de costura), quebrar dependências e escrever testes de caracterização, que registram o comportamento atual antes de qualquer mudança.
Na era da IA, isso importa por um motivo simples: o agente só consegue verificar o próprio trabalho se houver algo executável para conferir. O artigo destaca justamente que dar à IA uma forma de verificar o resultado é uma das práticas que mais melhoram a qualidade. Em bases antigas, o trabalho de Feathers é o que torna essa verificação possível. Os testes passam a funcionar como contrato: o revisor humano lê o contrato (o que está sendo garantido) e não precisa reler cada linha de implementação.
Accelerate, de Nicole Forsgren, Jez Humble e Gene Kim
Accelerate apresenta a pesquisa por trás das métricas DORA: frequência de deploy, lead time de mudanças, taxa de falha de mudanças e tempo de recuperação. A principal conclusão do livro é que velocidade e estabilidade não são opostas. Times de alto desempenho conseguem as duas.
É a mesma lógica do artigo: reduzir o tempo humano em revisão só vale se a taxa de revert e de incidentes não subir. O livro também ajuda a justificar as camadas de proteção citadas (integração contínua, lotes pequenos, deploy frequente e recuperação rápida) como práticas associadas a melhor desempenho, e não como burocracia.
Checklist para levar ao seu time
Um roteiro inicial, adaptado das ideias acima. Os critérios de risco são exemplos ilustrativos, e cada time precisa definir os seus.
- Classifique as mudanças por risco. Por exemplo: texto e estilo (baixo), lógica de negócio (médio), autenticação, pagamentos, dados pessoais e migrações (alto).
- Exija evidência, não afirmação. Todo PR, humano ou gerado por IA, mostra testes rodando, build verde ou captura de tela.
- Mantenha os PRs pequenos. Separe refatoração de mudança de comportamento, como em Refactoring.
- Trate testes como contrato. Revise primeiro o que os testes garantem. Em código sem testes, comece pelos testes de caracterização de Working Effectively with Legacy Code.
- Deixe claro quem responde pela mudança. Quem pediu ao agente é o autor, com tudo o que isso implica.
- Corrija problemas recorrentes na origem. Lint, templates e arquivos de instrução valem mais do que o mesmo comentário repetido em cada PR.
- Meça velocidade e estabilidade juntas. Tempo de espera por revisão ao lado de taxa de revert e de falha de mudanças, como em Accelerate.
E o segundo papel do code review?
O artigo lembra que a revisão também serve para espalhar conhecimento pelo time, e esse papel não desaparece só porque a máquina lê mais linhas. Se ninguém do time entende o que está indo para produção, o risco só foi adiado. O artigo admite que o time não tem processo formal para isso. Quem precisa entender uma parte do código pede ao Claude uma explicação daquele trecho, e os canais abertos no Slack ajudam a ver o que os outros estão construindo. Para quem lidera, livros como os três acima seguem úteis: eles dão ao time vocabulário comum para discutir código, algo que um explicador gerado sob demanda não substitui.
Como associado da Amazon, eu ganho com compras qualificadas.
Fontes
- Osmani, A., Lunt, M. W. e Wang, Q. How the Claude Code team does code review. claude.dev, 15 out. 2026. https://claude.dev/blog/solving-code-review-at-anthropic/
- Post de divulgação no X: https://x.com/addyosmani/status/2114604912520921136
- Fowler, M. Refactoring: Improving the Design of Existing Code. 2. ed. Addison-Wesley, 2018.
- Feathers, M. Working Effectively with Legacy Code. Prentice Hall, 2004.
- Forsgren, N., Humble, J. e Kim, G. Accelerate: The Science of Lean Software and DevOps. IT Revolution, 2018.