Padrão autoFixable: como separei 41% dos comentários de review antes da IA olhar

A bolha da IA em code review vende uma narrativa simples: “conecte CodeRabbit / GitHub Copilot Reviewer / seu agente favorito no PR, e ele revisa tudo”. Rodei esse esquema por 4 meses e cheguei numa contagem estranha: 41% dos comentários da IA eram sobre coisa que o linter podia arrumar sozinho, antes do agente gastar 1 token sequer.

A IA estava certa nos 41%. A qualidade dela não estava em jogo. Simplesmente aquele serviço cabia ao ruff --fix, resolvido em 2 segundos por 0 centavos.

Depois que isolei o “mecânico” do “julgamento” e coloquei o linter na frente da IA, o tempo médio do meu PR (abertura → merge) caiu de 47min para 19min. E, mais importante para quem paga a conta: o custo da API de review desceu para cerca de 60% do valor anterior, porque o agente parou de ler diff que não precisava.

O erro conceitual: tratar IA como a única camada de review

O discurso padrão da comunidade é “review humano é caro, então joga IA em cima”. O problema é que isso pula uma etapa. Existem 3 camadas de review, e o custo por comentário muda muito entre elas:

Camada	Custo/comentário	O que resolve bem
Linter autofix (Biome/ESLint/Ruff)	~R$0, ~2s	Formatação, imports não usados, semicolon, ordem
IA (CodeRabbit / agente próprio)	tokens + latência	Bugs de contexto, nomes ruins, padrões locais
Humano	dinheiro real + atenção	Design, trade-offs, decisões de produto

Rodar tudo pela camada 2 é o mesmo erro que rodar tudo pela camada 3 há 5 anos. A gente ri hoje de “cada bug de vírgula vira comentário de review humano”, mas agora paga a mesma piada pra IA. Só que em dólar.

O padrão autoFixable é isto: marque com um rótulo (label / tag / atributo) tudo que o linter pode resolver, e não deixe passar pra camada 2.

O que conta como autoFixable em 2026

O ecossistema mudou muito rápido. Números atuais dos linters que uso:

Biome 2.x (JS/TS/JSX): 200+ regras nativas, sendo a maioria autofixable. Substitui ESLint + Prettier num binário Rust
ESLint (legacy JS/TS): ainda tem o maior ecossistema, cerca de 300+ regras core + centenas de plugins, mas Biome já cobre ~80% dos casos comuns
Ruff 0.11+ (Python): 900+ regras, com um selo de martelo indicando as autofixable (a maioria). Já substituiu flake8 + isort + black + pylint em vários projetos no último ano

Se você programa em JS/TS ou Python e não tem biome check --write ou ruff check --fix num pre-commit hook, você já está pagando comentário humano/IA por coisa que era pra ter sumido antes do PR abrir.

Meu fluxo: 2 gates antes da IA ver o diff

Fluxo autoFixable antes do review de IA

Gate 1: pre-commit hook (local, ~2s). Roda biome check --write (ou ruff check --fix no repo Python). Se o dev commitar sem rodar, o hook roda por ele. 90% das correções mecânicas somem aqui.

Gate 2: GitHub Action no push (~15s). Mesma coisa, mas garantida no servidor. Se sobrou algo, um bot commita direto no branch do PR com chore: auto-fix format and lint. Só depois disso o job de review de IA é acionado.

O trecho do Gate 2 em .github/workflows/autofix.yml:

name: autoFixable gate
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  autofix:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.head_ref }}
          token: ${{ secrets.GITHUB_TOKEN }}

      - uses: actions/setup-node@v4
        with: { node-version: '22' }

      - run: npx --yes @biomejs/biome check --write .

      - name: Commit autoFixable changes
        run: |
          git config user.name "autofixable-bot"
          git config user.email "autofixable-bot@users.noreply.github.com"
          git diff --quiet || (
            git add -A &&
            git commit -m "chore: autoFixable — biome check --write" &&
            git push
          )

  ai-review:
    needs: autofix
    runs-on: ubuntu-latest
    steps:
      - run: echo "só roda depois que o autofix limpou tudo"

O detalhe importante: needs: autofix. Sem isso, o agente vê o diff sujo e comenta sobre coisa que já ia sumir 8 segundos depois. Já rodei os dois em paralelo por engano e a IA fez 12 comentários de import não usado no mesmo PR, todos autoFixable. Prejuízo em tokens, ruído no PR, dev irritado.

Os números reais de 3 meses

Comparei 2 janelas iguais no meu time (4 devs, mesmo tipo de projeto Next.js + FastAPI):

Métrica	Abril–Maio (sem gate)	Junho–Julho (com gate)	Delta
PR aberto → merge (mediana)	47 min	19 min	-60%
Comentários de IA por PR	8,3	4,9	-41%
Custo mensal do agente de review	US$ 218	US$ 129	-41%
Comentários humanos por PR	3,1	2,8	-10%

O ponto que me deixou pensativo: comentário humano caiu bem menos que o de IA (-10% vs -41%). Faz sentido. O humano já ignorava a maior parte das picuinhas de formatação, foca em julgamento, é caro. A IA é barata e desatenta, então enche linguiça.

Se a sua chefia está considerando “colocar CodeRabbit em todo PR pra ver se ajuda”, mostre esse número. O ganho vem de deixar a IA fora do que o linter já resolveu. Ler mais diff só sobe a conta.

A parte polêmica que TabNews vai discutir

Vou dizer o que pouca gente escreve: estão aplicando review de IA no problema errado. Apontar no-unused-vars é serviço de compilador. O que rende para a IA é o espaço entre o linter (rígido demais pra entender contexto) e o humano (caro demais pra tudo): coisas como “esse endpoint quebra o contrato do arquivo X que você não abriu”, “esse nome é enganoso porque no domínio da sua equipe X significa Y”.

Quando você faz o linter comer os 41%, sobra pra IA justamente o trabalho onde ela ganha do linter. E aí cada dólar gasto rende mais.

Já escrevi sobre revisão de código IA passo a passo sem IA com tree-sitter, onde o argumento é parente: existem passos de análise estática que resolvem parte do que se atribui hoje à IA. Junte os dois posts e você tem o modelo mental completo: linter primeiro, análise sintática segundo, IA por último, humano só no julgamento.

Para quem quer o benchmark cross-agent de qual IA usar depois que o linter já tirou o lixo, escrevi em inglês o ChatGPT Codex vs Claude Code: 47 PRs Benchmarked. O custo de 3,4x entre os dois é mais preocupante quando você tá pagando pra ele ler diff mecânico.

Resumo

41% dos comentários que a IA fazia no meu PR eram autoFixable pelo linter, trabalho de US$0 sendo pago em tokens
Gate duplo (pre-commit + GitHub Action) tira o mecânico antes do review de IA acontecer
Tempo de PR caiu 47min → 19min, custo da API de review caiu 41%, comentário humano quase não mudou
O objetivo é reservar a IA para os problemas que ficam além do compilador. Menos diff pra IA ler = mais qualidade por dólar gasto.

ken imoto · WebRTC & Voice AI engineer · kenimoto.dev · TabNews