# Como revisar código gerado por IA: checklist e fluxo de trabalho

> Para revisar código gerado por IA, leia o diff inteiro contra a branch de onde ele partiu, confira se ele faz só o que você pediu, rode os testes você mesmo e olhe com atenção dependências, segurança e testes apagados. Devolva ao agente feedback preciso, por linha, em vez de corrigir na mão. No Tallos, cada workspace tem um diff onde você anota linhas e devolve tudo num lote.

- Canonical: https://runtallos.com/pt/aprenda/revisar-codigo-gerado-por-ia
- English: https://runtallos.com/learn/review-ai-generated-code.md
- Atualizado em: 2026-09-29
- Section: Aprenda

## Em resumo

- Revise o diff inteiro, não o resumo do agente
- Checklist de 10 pontos: escopo, testes, dependências, segurança e mais
- Notas por linha devolvidas ao agente num lote só
- Nada entra sem você fazer commit, push ou abrir um PR

## Por que código gerado por IA pede uma revisão diferente?

Código gerado por IA pede uma revisão mais rigorosa porque chega rápido, parece seguro de si e foi escrito por algo a quem você não vai conseguir perguntar amanhã o que quis dizer. [Agentes de IA para programação](https://runtallos.com/pt/o-que-sao-agentes-de-ia-para-programacao) editam muitos arquivos numa execução, às vezes mexem no que você não pediu e descrevem o trabalho em resumos mais otimistas que o diff. A regra é simples: **revise o diff, não o resumo.**

A boa notícia é que o trabalho de um agente é fácil de isolar. Quando cada tarefa roda no seu git worktree, como um [workspace](https://runtallos.com/pt/recursos/workspaces-paralelos) do Tallos, o diff contém exatamente o que aquele agente fez e nada mais.

## O que conferir ao revisar código gerado por IA?

Use este checklist em todo diff de agente. Escopo e testes vêm primeiro porque pegam cedo os erros mais caros.

| # | O que conferir | Sinais de alerta |
| --- | --- | --- |
| 1 | **Escopo:** o diff faz o que você pediu e nada mais | Arquivos sem relação, reformatação de arquivos inteiros, renomeações que você não pediu |
| 2 | **Correção:** lógica e casos de borda | Só o caminho feliz; vazio, nulo e erro ignorados |
| 3 | **Testes:** o comportamento novo tem teste e a suíte passa quando você roda | Testes apagados ou pulados, asserções enfraquecidas, snapshots atualizados em massa |
| 4 | **Dependências:** cada pacote novo é necessário e existe de verdade | Pacotes que você não conhece, versões atualizadas sem motivo, lockfile mexido demais |
| 5 | **Segurança:** entrada, autenticação e segredos | Chaves no código, validações desligadas, SQL montado com string, `eval`, CORS liberado |
| 6 | **Dados:** migrações e valores padrão | Migrações destrutivas, padrões alterados, sem rollback |
| 7 | **Config e CI:** build, lint, hooks | Etapas de CI removidas, regras de lint desligadas, `--no-verify` |
| 8 | **Contratos:** APIs públicas e tipos | Assinaturas alteradas, campos removidos, quebra de compatibilidade silenciosa |
| 9 | **Performance:** caminhos críticos | Query dentro de loop, chamada de rede por item, listas sem limite |
| 10 | **Legibilidade:** código que você vai manter | Helpers duplicados, código morto, comentários que descrevem outra implementação |

_Checklist de revisão de código de IA_

> **Rode você mesmo** — O agente dizer que os testes passam não é o mesmo que os testes passarem. Rode a suíte no terminal do workspace e abra a interface num navegador quando a mudança for visual.

## Como revisar e anotar o diff de um agente no Tallos?

1. **Abra as mudanças do workspace** — Quando o agente terminar, clique em **Revisar mudanças** ou abra Source Control na barra lateral direita do workspace. O diff compara o workspace com a branch de onde ele partiu e junta arquivos em stage, fora do stage e não rastreados.
2. **Meça o escopo primeiro** — Passe o olho na árvore de arquivos ao lado dos trechos e no indicador de linhas adicionadas e removidas em Source Control. Passe o mouse sobre ele para ver a divisão entre código, testes e arquivos gerados. Tarefa pequena com diff grande é a primeira pergunta para o agente.
3. **Percorra cada mudança** — Leia cada trecho com o checklist na cabeça. `F7` e `Shift+F7` pulam para a próxima e a anterior. Imagens têm diff lado a lado, deslizante e sobreposto; arquivos HTML abrem numa prévia ao lado do diff.
4. **Rode os testes e experimente** — Abra um terminal no mesmo workspace e rode os testes. Em mudanças de interface, abra a página no [navegador integrado](https://runtallos.com/pt/recursos/navegador-integrado), ao lado do diff.
5. **Deixe notas em linhas específicas** — Passe o mouse numa linha e clique no **+** da margem, aperte `c` ou use **Adicionar nota de revisão** (`Cmd+Shift+A` no macOS, `Ctrl+Shift+A` no Windows). Escreva o que está errado e o que você espera, e salve com `Cmd+Enter`.
6. **Devolva todas as notas num lote** — Clique em **Enviar notas para** e escolha o agente que vai revisar a mudança, ou inicie um agente novo pelo mesmo menu. O Tallos monta um único prompt com cada nota ancorada na sua linha.
7. **Revise de novo e decida** — As notas continuam fixadas depois da revisão, então você confere cada correção e marca como resolvida. Com o diff certo, faça commit (use **Gerar com IA** para a mensagem, se quiser), push e **Criar PR**. Se não valer a pena, exclua o workspace.

> Revise cada diff de agente com notas por linha que o agente lê de verdade. Baixe o Tallos. → https://runtallos.com/signup

## Como escrever notas de revisão que um agente de IA consegue executar?

Escreva notas que o agente execute sem adivinhar: aponte a linha, diga o que está errado e diga como é o pronto. Mande em lote, porque uma passada de revisão coerente funciona melhor que uma sequência de comentários soltos que puxam o agente para lá e para cá.

**Nota vaga**
- “Isso está errado.”
- “Dá uma limpada aqui.”
- “Coloca testes.”

**Nota executável**
- “Retorna 200 com token inválido; deveria retornar 401.”
- “Mova este loop de retry para `withRetry` em `api.ts`; não duplique.”
- “Adicione um teste para carrinho vazio; `total` deve ser 0.”

## Como revisar quando vários agentes tentaram a mesma tarefa?

Revise primeiro o menor diff correto, não o primeiro que terminou. Quando dois ou três agentes trabalharam na mesma tarefa em workspaces separados, compare escopo e resultado dos testes lado a lado, fique com um e exclua o resto. Onde as tentativas discordam, você achou a parte difícil da tarefa.

As squads fazem parte disso por você. Na [squad construir e revisar](https://runtallos.com/pt/squads/construir-e-revisar), um agente revisor confere o trabalho de quem constrói e devolve mudanças até aprovar; na [melhor de três](https://runtallos.com/pt/squads/melhor-de-tres), o líder compara as tentativas e marca uma como **Recomendado**. A decisão final continua sua, com **Aceitar** ou **Descartar**, e você continua lendo o diff. Mais na [revisão de diff](https://runtallos.com/pt/recursos/revisao-de-diff).

## Solução de problemas: e se a revisão parecer errada?

- **O diff parece desatualizado.** Clique em atualizar na barra do diff; um comando `git` externo pode ter rodado entre as atualizações.
- **Arquivos demais para ler.** Peça ao agente para dividir a mudança, ou descarte e recomece com uma tarefa mais estreita.
- **Um hook de commit falha.** O Tallos mostra a saída do hook. Corrija você mesmo ou use **Corrigir com IA**, que entrega a falha a um agente sem pular o hook.
- **O agente ignorou uma nota.** Notas ainda não resolvidas entram no próximo lote quando você envia de novo. Deixe a nota mais específica.

## Perguntas frequentes

### Posso confiar no resumo que o agente faz das mudanças?

Não. Trate o resumo como uma afirmação e o diff como a prova. Leia cada arquivo alterado e rode os testes você mesmo.

### Qual o problema mais comum em código gerado por IA?

Mudança fora do escopo: alterações em arquivos ou comportamentos que você não pediu. Confira o escopo antes de tudo, depois testes e dependências.

### Como devolvo comentários de revisão para o Claude Code ou o Codex no Tallos?

Deixe notas nas linhas do diff do workspace, clique em Enviar notas para e escolha o agente. O Tallos envia todas as notas num único prompt, cada uma ancorada na sua linha.

### Corrijo os erros da IA na mão ou devolvo para o agente?

Devolva quando a correção passar de uma ou duas linhas; o agente mantém o contexto e suas notas viram instrução. Ajustes do tamanho de um typo saem mais rápido na mão.

### O Tallos faz merge do código do agente sozinho?

Não. O trabalho fica na branch do workspace até você fazer commit, push e abrir um pull request, ou fazer o merge você mesmo.

### Um agente pode revisar o código de outro agente?

Pode. A squad construir e revisar junta quem constrói com um agente revisor que devolve mudanças até aprovar, e você aceita ou descarta o resultado final.

---

**Rode seus agentes em paralelo com o Tallos** — Claude Code, Codex, Gemini e mais de 30 agentes — cada um no seu workspace, com squads, chat, terminais e revisão num só app. Usa as assinaturas que você já tem.

https://runtallos.com/signup (macOS 13+ · Windows 10+)