Shopping cart

Subtotal $0.00

View cartCheckout

Building better devs

TnewsTnews
  • Home
  • Programação
  • Seus TODOs Antigos Estão Quebrando Agentes de IA, e o Google Provou
Programação

Seus TODOs Antigos Estão Quebrando Agentes de IA, e o Google Provou

Email : 12

Um TODO esquecido destruiu 77% dos seus tokens

Você já parou pra pensar que aquele TODO(fix later) que você deixou no código em 2022 pode estar custando dinheiro real em 2026? Não estou exagerando. O Google analisou mais de 913 mil sessões de agentes de IA e descobriu algo perturbador: comentários velhos no código fazem os agentes perderem o foco, consumirem mais tokens e demorarem o dobro para completar tarefas simples.

O fenômeno tem nome: Agent Distraction. E se você usa Copilot, Claude Code, Gemini Code Assist ou qualquer agente de IA para programar, isso afeta diretamente o seu dia a dia.

O que o Google encontrou em 913 mil sessões

Sam Saccone (Senior Staff Software Engineer) e Madhuri Garikapati (Senior Staff Data Scientist) publicaram os resultados em 6 de novembro de 2026 no Google Developers Blog. A pesquisa usou distributed traces coletados de milhares de engenheiros internos, somando centenas de milhões de passos de agentes.

Os números são claros:

Métrica Valor
——— ——-
Sessões analisadas 913.000+
Sessões expostas a TODOs inline 13% (~1 em cada 7)
Encontros que geraram ação do agente 6%
Ações completamente não solicitadas 83%

Traduzindo: em 13% das sessões, o agente encontrou pelo menos um TODO(b/12345) ou FIXME referenciando um bug tracker. Em 6% desses encontros, o agente decidiu por conta própria agir sobre aquele TODO. E em 83% dessas vezes, o desenvolvedor nem tinha pedido nada relacionado.

O agente simplesmente viu o TODO e pensou: “parece importante, vou resolver isso.”

O custo real de um agente distraído

Quando um agente se distrai, o impacto não é sutil. O Google mediu o overhead por sessão distraída:

Overhead Aumento
———- ———
Passos por sessão +70%
Tokens consumidos +77%
Tempo de espera do dev +105%

Leia de novo: 105% mais tempo de espera. O desenvolvedor fica ali esperando o agente terminar uma tarefa que ele nem pediu. Se você paga por token (como na API do Claude ou do GPT), aquele TODO de 2019 está literalmente consumindo seu orçamento.

Um engenheiro da comunidade resumiu bem: isso é “comportamento de dev júnior em velocidade de máquina.” O agente vê um comentário misleading, decide investigar, e gasta ciclos em algo irrelevante. A diferença é que um junior faz isso uma vez por hora. O agente faz 40 vezes.

Por que a IA não consegue ignorar TODOs (e humanos sim)

Aqui entra a parte interessante. Quando eu leio um código cheio de TODOs velhos, meu cérebro automaticamente filtra. Eu sei que TODO(b/54321): migrate to v2 provavelmente é de 2020 e ninguém vai migrar nada. Eu passo direto.

A IA não tem esse filtro. Pra ela, cada referência não resolvida é uma instrução potencial. O Google descreve assim:

“Obsolete specs, long resolved bugs, and lagging documentation no longer rest in long forgotten corners of the codebase, but rather are unintentionally ingested as context.”

O agente lê o arquivo, encontra o TODO, faz uma pesquisa no bug tracker, descobre que o bug está aberto (ou pior, fechado mas o TODO ficou lá), e decide agir. Tudo isso acontece na fase de planejamento, antes de escrever uma única linha de código útil.

O paradoxo do modelo mais inteligente

E aqui vem o dado mais contraintuitivo da pesquisa: modelos mais capazes se distraem mais. Se o seu codebase está cheio de TODOs velhos, trocar para um modelo mais avançado piora o problema. O modelo mais inteligente é mais obediente, mais meticuloso, e por isso persegue cada referência encontrada com mais determinação.

Então aquele upgrade pro Claude Opus ou pro GPT-6 que você fez pensando em ganhar produtividade? Se o código está sujo, você está pagando mais para o agente se distrair melhor.

Anatomia de uma distração: o que acontece por dentro

O Google quebrou as distrações em duas categorias:

Categoria 1: Perseguindo tickets fechados (41%)

De todas as vezes que um agente se distraiu:

  • 32% foram bugs já corrigidos e verificados
  • 9% foram bugs marcados como obsoletos ou won’t-fix
  • 2% foram bugs duplicados ou com acesso restrito

Ou seja, em 41% dos casos, o agente gastou tokens e tempo investigando algo que já estava resolvido. O TODO simplesmente nunca foi removido do código.

Categoria 2: Scope creep (57%)

Nos outros 57% dos casos, o bug referenciado estava genuinamente aberto, mas fora do escopo do que o desenvolvedor pediu. O agente encontrou o TODO, decidiu que parecia relevante, e expandiu o trabalho:

  • 61% das vezes, o agente apenas investigou (leu código, buscou contexto, leu documentação)
  • 39% das vezes, o agente fez edições no código que ninguém pediu

Essa segunda parte é perigosa. Imagine pedir pro agente refatorar uma função, e ele decide, por conta própria, corrigir um bug não relacionado que encontrou num TODO. Agora você tem mudanças no PR que não entende, não pediu, e precisa revisar.

Como o Google resolveu internamente

O Google não ficou só na teoria. Eles construíram agentes especializados pra limpar o próprio codebase:


# Padrão que o Google buscou no codebase inteiro
grep -rn "TODO(b/[0-9]*)" --include="*.java" --include="*.py" --include="*.go" .

Mas encontrar é fácil. O difícil é saber quais TODOs são realmente obsoletos. Pra isso, os agentes de limpeza faziam:

  1. Análise do bug tracker: o bug referenciado ainda está aberto?
  2. Análise do histórico git: o código ao redor do TODO mudou significativamente desde que foi escrito?
  3. Análise de dependências: a feature mencionada no TODO já existe?
  4. Proposta de remoção: gerava um CL (changelist, o equivalente do Google a um PR) removendo o TODO obsoleto

O resultado? Em 6 meses, o sistema removeu milhares de referências obsoletas com mais de 95% de aprovação dos revisores humanos. Quase todos os TODOs que ele sugeriu remover eram de fato lixo.

O Agent-Janitor: a ferramenta da comunidade

A pesquisa do Google inspirou a comunidade a criar ferramentas open source. A mais popular é o Agent-Janitor, que automatiza a limpeza de TODOs e reportou uma redução de 41% nos passos por sessão em codebases limpos.

O conceito é simples: antes de soltar um agente de IA no seu código, limpe o terreno. Remova os TODOs que não fazem mais sentido, atualize a documentação inline, delete código morto.

Checklist prático: como proteger seu codebase

Se você usa agentes de IA no desenvolvimento (e em 2026, quem não usa?), aqui vai um checklist:

1. Audite seus TODOs agora


# Encontre todos os TODOs com referências a bugs
grep -rn "TODO\|FIXME\|HACK\|XXX" --include="*.ts" --include="*.py" --include="*.go" --include="*.java" . | wc -l

# Filtre por referências a bug trackers
grep -rn "TODO(b/\|TODO(#\|FIXME(JIRA-\|TODO(ISSUE-" . --include="*.ts" --include="*.py"

2. Cruze com o bug tracker

Pra cada TODO com referência a um ticket, verifique:

  • O ticket ainda existe?
  • Está aberto ou fechado?
  • Se fechado, o TODO pode ser removido?
  • Se aberto, ainda é relevante pro código onde está?

3. Adicione checks no CI/CD


# Exemplo para GitHub Actions
- name: Check stale TODOs
  run: |
    STALE=$(grep -rn "TODO(b/" --include="*.py" . | wc -l)
    if [ "$STALE" -gt 0 ]; then
      echo "::warning::Found $STALE TODO references to bug tracker"
    fi

4. Estabeleça uma política de TODOs

TODOs sem data de expiração são TODOs que vivem pra sempre. Considere adotar um formato como:


# TODO(2026-12-31, @usuario): Migrar para API v3 quando disponível
# Se a data passar sem ação, o CI falha ou alerta

5. Limpe antes de agentar

Antes de pedir para um agente de IA trabalhar num módulo grande, faça uma passada rápida removendo TODOs obsoletos, comentários desatualizados, e imports não usados. Cinco minutos de limpeza podem economizar centenas de tokens e dezenas de minutos de espera.

O que isso muda na prática

A pesquisa do Google muda a conversa sobre produtividade com IA de um jeito inesperado. Até agora, a discussão girava em torno de “qual modelo é melhor” ou “qual IDE tem o melhor agente.” Mas o gargalo real pode ser algo muito mais mundano: a higiene do seu codebase.

Pense nisso: empresas gastam fortunas em modelos de ponta, licenças de ferramentas de IA, e infraestrutura GPU. Aí o agente perde 77% mais tokens porque alguém deixou um FIXME: check null pointer em 2021 e nunca voltou pra resolver.

É como comprar um carro esportivo e dirigir numa estrada cheia de buracos. O motor é incrível, mas o terreno não deixa ele performar.

Comparando agentes: quem se distrai mais?

A pesquisa do Google não nomeou modelos específicos, mas a comunidade rapidamente fez os próprios testes. Desenvolvedores no Reddit e no Hacker News reportaram resultados consistentes com a descoberta do “paradoxo do modelo inteligente”:

Comportamento Modelos menores Modelos maiores
————— —————– —————–
Ignora TODOs Mais frequente Menos frequente
Investiga bugs referenciados Raro Comum
Faz edições não solicitadas Quase nunca Em ~39% das distrações
Custo por distração Baixo (poucos tokens) Alto (investigação profunda)

Isso cria um dilema real. Você quer o modelo mais capaz pra escrever código melhor, mas o modelo mais capaz também é o mais propenso a sair do trilho quando encontra lixo no codebase. A solução não é usar um modelo pior. É limpar o código.

O efeito cascata em monorepos

Em monorepos grandes (como os do Google, Meta, e cada vez mais startups), o problema se multiplica. Um agente trabalhando num módulo A pode ler imports do módulo B, encontrar um TODO no módulo C, e decidir investigar. O raio de explosão de uma distração num monorepo é enorme.

O Google reportou que as piores distrações aconteciam justamente em sessões que tocavam múltiplos pacotes. O agente lia código de contexto para entender dependências, encontrava TODOs em bibliotecas internas, e embarcava numa jornada lateral que nada tinha a ver com a tarefa original.

Quanto custa em dinheiro?

Vamos fazer uma conta rápida. Suponha que você usa a API do Claude Sonnet a US$ 3 por milhão de tokens de input e US$ 15 por milhão de tokens de output. Uma sessão média consome uns 50 mil tokens. Com a distração, vai pra 88.500 tokens (+77%).

Se sua equipe de 10 devs roda 20 sessões por dia cada, e 13% delas sofrem distração:

  • Sessões distraídas por dia: 200 × 0.13 = 26
  • Tokens extras por sessão: ~38.500
  • Tokens desperdiçados por dia: ~1 milhão
  • Custo mensal extra: entre US$ 60 e US$ 300 dependendo do mix input/output

Não é uma fortuna, mas é dinheiro jogado fora. E isso sem contar o custo de oportunidade: 105% mais tempo de espera significa devs parados esperando o agente terminar de perseguir fantasmas.

A era da “higiene agêntica”

O Google está chamando isso de agentic-era codebase hygiene. A ideia é que manter o código limpo não é mais só sobre legibilidade humana. É sobre eficiência de IA. Cada comentário desatualizado, cada spec antiga, cada referência a um bug de 3 anos atrás é ruído que o agente vai processar, classificar, e possivelmente agir sobre.

As recomendações do Google se resumem a três ferramentas:

  1. Presubmit analyzers: bloqueiam novos TODOs sem formato válido
  2. Corpus scanners: varrem o codebase periodicamente buscando referências obsoletas
  3. Agentes de limpeza automatizados: removem TODOs mortos com supervisão humana mínima

O mais irônico? Eles estão usando IA pra limpar o código que confunde a IA. O agente que limpa TODOs é tão eficiente que 95% das suas sugestões são aceitas sem alteração. Às vezes a solução pro problema da IA é mais IA.

Pra quem acha que “isso não me afeta”

Se você programa sozinho num projeto pessoal, talvez não. Mas se trabalha numa equipe com mais de 3 pessoas, num codebase com mais de um ano de vida, posso apostar que tem dezenas (se não centenas) de TODOs esquecidos.

Cada um deles é uma potencial armadilha para o agente de IA. E com a tendência de agentes mais autônomos (como o Claude Code com extended thinking ou o Gemini Code Assist no modo agente), o problema só vai crescer.

A pesquisa do Google é um alerta: antes de reclamar que “a IA não funciona direito no meu projeto”, verifique se o seu projeto não está ativamente confundindo a IA.

Talvez o problema não seja o modelo. Talvez seja aquele TODO que você deixou lá “só por enquanto” em 2022.

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Posts