O que a programação totalmente autônoma deixa para trás

A mensagem final dizia que o repositório estava em ordem.

Não estava.

Ainda havia ramificações extras, arquivos antigos e erros. Já vi isso várias vezes enquanto construía uma aplicação modular para análise de rotas com ChatGPT, Codex e Claude. Código, arquitetura e prompting estão conectados à mesma base de código. Perder o fio central tem um custo real.

Hoje escrevo menos código manualmente. Meu papel está mais próximo do de um arquiteto. Isso ainda exige conhecimento técnico e entendimento real da área em que o produto será usado. Sem os dois, um agente pode criar rapidamente algo que funciona no papel, mas resolve o problema errado.

O modo totalmente autônomo parece atraente. O sistema planeja o trabalho, inicia agentes e continua até decidir que a tarefa terminou. Na minha experiência, um fluxo dividido em etapas ainda é mais confiável.

Uma ramificação secundária pode dominar toda a execução. Ela vira o objetivo principal. Depois, outra tarefa secundária toma o lugar dela. Mais agentes e ambientes aparecem, relatórios antigos voltam, e o objetivo original desaparece aos poucos.

Um relatório de progresso não é prova. Testes verdes também não bastam. Eles podem confirmar que a função atual funciona sem mostrar o dano mais importante: complexidade desnecessária, arquivos antigos, ramificações extras e um objetivo que mudou silenciosamente.

Este é o fluxo que uso hoje:

1. Uma etapa produz um resultado verificável.
2. Cada agente recebe uma tarefa limitada, não permissão para redefinir todo o caminho.
3. Depois de cada etapa, reviso o diff, rodo os testes e faço um commit claro.
4. Antes de continuar, verifico as ramificações, os arquivos antigos, os ambientes desnecessários e o objetivo original.
5. Depois de duas direções malsucedidas, o trabalho para. Primeiro repetimos qual era a hipótese original. Só depois escolhemos o próximo caminho.

Uso agentes todos os dias. Eles podem multiplicar a capacidade de um único especialista. Mas mais autonomia não produz automaticamente um resultado melhor. Às vezes, produz apenas mais velocidade dentro da ramificação errada.

No meu projeto, o custo ainda é fácil de enxergar: tempo perdido e um repositório que precisa ser limpo. O incidente com um grande enxame de agentes mostra o mesmo mecanismo em outra escala. Com tempo e orçamento praticamente ilimitados, milhões de combinações de ramificações podem produzir resultados que ninguém previu. A persistência excessiva pode se tornar perigosa.

A nota completa está no meu site: Por que parei de confiar em programação totalmente autônoma.