Revisão de código com IA significa que um segundo modelo lê o código que um agente escreveu e aponta problemas. A armadilha com agentes é a velocidade: um agente muda dezenas de arquivos num turno, e ler tudo linha por linha devolve o tempo que o agente economizou para você. Uma etapa de revisão fecha essa lacuna; a saída do agente passa por um segundo par de olhos antes de você olhar.
Este post mostra como fazer a saída do agente ser revisada, como avaliar os achados e como manter o ciclo de revisão sob controle.
Por que revisar a saída do agente separadamente?
O agente que escreveu o código não enxerga as próprias suposições. Quando um agente marca uma mudança como “pronta”, muitas vezes deixa passar:
- Rollback ou limpeza que faltam nos caminhos de erro
- Casos de borda: entrada vazia, requisições concorrentes, timeouts
- Segurança: tokens reutilizáveis, entrada sem validação
- Imports sem uso, código morto, nomes inconsistentes
Um segundo modelo lendo o mesmo código com um contexto novo, olhando só o diff, percebe isso com mais facilidade.
O que uma boa revisão de código com IA observa
Achados só ajudam quando você consegue agir sobre eles. Um bom achado tem:
| Parte | Exemplo |
|---|---|
| Severidade | Alta, média, baixa |
| Local | src/auth/session.ts:88 |
| Problema | “Um novo token é emitido antes de o antigo ser revogado.” |
| Por que importa | “A reutilização de token não é detectada.” |
A severidade define a prioridade. O local leva você direto à linha. Comentários vagos do tipo “melhore o código” não servem para nada.
Quando revisar
Três abordagens:
- Automaticamente depois de cada turno. A revisão começa assim que o agente termina o turno, então os problemas são pegos enquanto o agente ainda tem o contexto.
- Antes do merge. Revise o diff inteiro antes de o branch entrar no branch principal.
- Sob demanda. Revise um commit ou a árvore de trabalho sobre a qual você está em dúvida.
Com agentes, a primeira economiza mais tempo, porque os problemas aparecem antes de se espalharem para o próximo turno.
Revisão de código automática no AgentVera
A revisão de código do AgentVera é ativada nas configurações do projeto e aparece na aba Reviews do painel direito:
- Ative a revisão automática nas configurações do projeto e escolha um modelo Claude.
- Escolha o que é revisado: os commits do turno ou todas as mudanças.
- Escolha se os achados voltam ao agente.
- Quando o agente termina o turno, a revisão roda; os achados são listados com severidade e links arquivo:linha.
Você também pode revisar na mão a árvore de trabalho, as mudanças em stage ou um único commit.
Limite o ciclo de retorno
Mandar os achados de volta ao agente automaticamente é tentador, mas um ciclo sem fim é arriscado: o agente corrige um problema e cria outro, a revisão encontra, e assim por diante. Por isso o AgentVera limita o retorno a no máximo duas rodadas seguidas. Depois disso, a decisão é sua.
Como avaliar os achados
Você não precisa aceitar todo achado. Uma ordem prática:
- Alta: riscos de segurança e de perda de dados. Corrija antes do merge.
- Média: caminhos de erro, testes que faltam. Geralmente é barato corrigir no mesmo turno.
- Baixa: estilo, imports sem uso. Limpe em lote ou com ferramentas automáticas.
Não hesite em rejeitar falsos positivos. O modelo revisor também pode errar; quem conhece melhor o contexto é você.
Combine a revisão com outras redes de segurança
Revisão sozinha não basta. Ela fica mais forte junto com:
- Testes: a revisão pega erros de lógica, os testes pegam erros de comportamento.
- Turnos: se uma revisão mostrar que um turno foi pelo caminho errado, desfaça-o com os turnos.
- Notificações: seja avisado no Telegram quando aparecer um achado importante.
- Fluxos: coloque um agente de revisão ou de testes depois do agente que constrói.
Um exemplo de relatório de revisão
Num turno, o agente adicionou um fluxo de refresh token e fez três commits. Quando o turno termina, a revisão produz:
| Severidade | Achado | Local |
|---|---|---|
| Alta | A reutilização do refresh token não é detectada; um novo token é emitido antes de o antigo ser revogado. | src/auth/session.ts:88 |
| Média | A transação do banco de dados não sofre rollback no caminho de erro. | src/auth/store.ts:41 |
| Baixa | Import sem uso. | src/auth/index.ts:3 |
O que fazer com isso?
- Envie o achado alto ao agente. É um problema de segurança e o agente ainda tem o contexto, então a correção é barata.
- Inclua o achado médio no mesmo turno. O comportamento no caminho de erro precisa de um teste; peça ao agente para escrever um.
- Deixe o achado baixo para um lote. Um linter ou a próxima rodada de limpeza resolve.
Quando o agente corrige, a revisão roda de novo. Se ainda houver achados abertos depois da segunda rodada, o ciclo automático para e a decisão é sua.
Escolhendo modelo e escopo para a revisão
A revisão também tem custo. Revisar cada turno com o modelo mais forte pode sair caro. Uma abordagem prática:
- Para turnos do dia a dia, escolha um modelo Claude mais rápido e mais barato.
- Antes do merge, considere revisar o diff inteiro na mão com um modelo mais forte.
- Limitar o escopo aos commits do turno mantém o diff revisado pequeno; revisar todas as mudanças também pega trabalho sem commit.
Leve a revisão de volta ao papel do agente
Se você vê os mesmos padrões nos achados de novo e de novo, passe-os para o papel do agente. Se a revisão sempre aponta testes de caminho de erro faltando, adicione uma linha como esta:
For every new function, write at least one error-path test next to the happy-path test.Aí o mesmo problema para de aparecer a cada turno; o agente o evita desde o início. Com o tempo, os relatórios ficam mais curtos e os achados que importam se destacam.
Ler as revisões junto com o histórico também ajuda. A busca em conversas do AgentVera faz busca de texto completo em todas as conversas do Claude e do Codex, então você encontra a sessão em que um problema foi discutido antes e a retoma num novo agente.
Checklist
- A revisão automática está ativada nas configurações do projeto?
- O escopo da revisão (commits do turno ou todas as mudanças) combina com seu trabalho?
- Os achados de severidade alta foram resolvidos antes do merge?
- O ciclo de retorno está limitado?
- Os testes rodaram independentemente da revisão?
Concluindo
A revisão de código com IA permite usar a velocidade dos agentes sem abrir mão da qualidade. Um segundo modelo lendo o código depois de cada turno pega os problemas enquanto o agente ainda tem o contexto, e achados com severidade e local dizem onde olhar primeiro.
No AgentVera você ativa a revisão por projeto e envia os achados ao agente com um clique. Use junto com as etapas de merge de git worktrees para agentes em paralelo, ou comece no plano gratuito.