Se você usou Claude Code, Codex, Workbuddy ou Kimi Work nos últimos seis meses, você sentiu a mudança: em vez de instruir uma IA frase por frase, você insere um requisito e ela escreve, executa, encontra um erro, se corrige e continua trabalhando até que a coisa exista. Essa qualidade de girar por conta própria tem um nome, e o nome está se tornando a disciplina de engenharia do ano: engenharia de loops.
Em junho, o criador do OpenClaw, Peter Steinberger, acendeu o pavio com um post que se espalhou muito: você não deveria mais escrever prompts para agentes de código — você deveria projetar loops. Pouco antes, o líder de engenharia do Google, Addy Osmani, havia sistematizado o conceito de loop em um ensaio amplamente compartilhado. E a pessoa que primeiro fez os loops brilharem, o criador do Claude Code, Boris Cherny, publicou no fim de junho as quatro primitivas de loop integradas ao Claude Code. Em menos de um mês, a engenharia de loops passou de gíria da indústria para foco mainstream.
A maior parte dos comentários para na história da eficiência. Indo uma camada mais fundo, algo mais consequente está acontecendo: os humanos estão sendo empurrados para fora do centro do loop. Essa mudança estrutural importará por muito mais tempo do que os ganhos de velocidade.
De Escrever Prompts a Projetar Harnesses: O Que os Agentes Realmente Ganhou
A antiga disciplina de uso de IA girava em torno de prompts. Quanto mais refinadas suas instruções, melhor o resultado — para chat. Mas quando os modelos se tornaram agentes, eles pararam de apenas responder e começaram a decidir: quando ler um arquivo, quando executar um comando, quando buscar na web, quando parar e perguntar a um humano. A engenharia de prompts não era mais suficiente.
O que surgiu primeiro foi a engenharia de harness — a moldura de runtime em torno do modelo que conecta ferramentas, gerencia permissões, injeta contexto e mantém o estado. O modelo ainda faz o raciocínio, mas agora vive dentro de um ambiente que pode realmente executar trabalho.
A engenharia de loops é o próximo passo: trata de como fazer um agente girar continuamente em torno de um objetivo. Você dá um objetivo; o agente interpreta a tarefa, reúne contexto, chama ferramentas, observa resultados, julga a conclusão, continua corrigindo se não estiver pronto, continua executando, continua verificando. Parece suspeitamente com o modo como as pessoas trabalham: rascunho, encontra problemas, reescreve, até que saia.
A essência de um loop não é a palavra “ciclo”. É o que você coloca dentro do ciclo — e quem decide quando o ciclo para.
Quatro Primitivas de Loop: Saber Quando Fazer O Quê
O post de junho da Anthropic dividiu os loops em quatro tipos, e a taxonomia é mais reveladora do que parece:
- Baseado em turnos — você envia uma mensagem, ela responde. O padrão clássico de conversa.
- Baseado em objetivos — “construa uma página de login”, e ela escreve, testa e itera até terminar. Esse é o modo padrão do Claude Code e do Codex.
- Baseado em tempo — a cada duas horas, verificar um pull request e revisar as atualizações. O agente adquire vigilância programada e permanente.
- Proativo — o mais agressivo. O agente percebe algo por conta própria — digamos, cobertura de testes em declínio — e vai corrigir sem ser solicitado.
A ordem não é acidental. De turnos a proativo, cada passo transfere mais autoridade de disparo dos humanos para os sistemas. Os dois primeiros mantêm as pessoas como fonte de ignição: os humanos se movem primeiro, os agentes seguem. Os dois últimos entregam as chaves na dimensão tempo e na dimensão estado. Um loop proativo, no fundo, significa que o agente adquiriu um senso primitivo de “o que vale a pena fazer” — por mais rudimentar que esse julgamento ainda seja.
A Verdadeira Percepção de Andrew Ng: Três Loops Aninhados
O framework mais completo veio da carta de 30 de junho de Andrew Ng, que colocou os loops dentro de todo o arco de construção de um produto, e não dentro de um editor de código. Seu modelo desenha três ciclos concêntricos:
| Loop | Cadência | Quem o executa | O que decide |
|---|---|---|---|
| Loop de codificação agêntica | Segundos a minutos | O próprio agente | Escrever, testar e iterar código até que os testes passem |
| Loop de feedback do desenvolvedor | Dezenas de minutos a horas | Desenvolvedores | Revisar direção, ajustar especificações, calibrar objetivos |
| Loop de feedback externo | Horas a semanas | Usuários e mercado | Feedback de beta, testes A/B, dados de produção remodelando o produto |
Observe o padrão: quanto mais para fora você vai, mais lento o loop — e mais humano o verificador. O loop mais interno pode se autoverificar com casos de teste; código que passa nos testes passou, sem espaço para gosto. O segundo loop exige que um desenvolvedor julgue se a direção está certa, se a experiência parece boa — não automatizável. O loop mais externo leva dias ou semanas para convergir, e nenhuma IA no mundo consegue comprimir a velocidade com que os usuários realmente se comportam.
Ng também fez uma correção silenciosa, mas importante, sobre uma ideia popular. Muitas pessoas resumem o valor residual humano na era da IA como “bom gosto” — um julgamento estético indescritível. Ng trocou por um termo mais preciso: vantagem de contexto.
Enquanto os humanos souberem algo que a IA não sabe, os humanos precisam estar no loop para injetar esse conhecimento.
Bom gosto soa inato e inensinável. Vantagem de contexto diz exatamente o que codificar no loop: os fatos sobre seus usuários, seu negócio e seu problema que você conhece e seu modelo não conhece. Esse é o valor real que você fornece de fora do ciclo — não “melhor gosto que a IA”, mas “conhecimento que a IA não tem”.
Quem Decide “Pronto”? O Gargalo do Verificador
O framework expõe o modo de falha menos examinado na engenharia de loops: o gargalo do verificador. Em um loop fechado sem intervenção humana, o agente executa até que alguma condição de parada seja atendida. Se essa condição for mal definida — se você não codificou sua vantagem de contexto no mecanismo de verificação — o agente se tornará silenciosamente um gerador de lixo muito caro. Como colocou o guia de engenharia de loops do AI Builder Club: em qualquer loop, o verificador é o gargalo, não o modelo.
Cada estratégia de verificação compra velocidade com um ponto cego diferente:
- Inspeção manual arrasta a cadência do segundo loop para minutos. O humano se torna o componente mais lento de um sistema construído para velocidade.
- Verificação por casos de teste pode checar se algo funciona, nunca se é bom.
- Modelo como verificador introduz risco de alucinação em cascata — um modelo confiante avaliando outro modelo confiante.
- Deferir toda a verificação aos usuários puxa o loop externo de semanas para o ciclo mais interno, e o sistema inteiro trava.
É por isso que a vantagem de contexto importa tanto: o gargalo do verificador não é um problema de capacidade do modelo. É o custo do conhecimento que você possui mas nunca registrou. Você sabe por que os usuários abandonam seu fluxo de cadastro na terceira etapa. Se esse conhecimento não for codificado nos critérios de aceitação, o agente vai se esforçar para sempre sem jamais aprender onde está o defeito real.
O Framework Viaja Muito Além da Programação
Rode o modelo de três loops contra outros domínios e ele prevê falhas com precisão desconfortável. Um agente de análise de dados roda SQL e constrói gráficos em segundos; um cientista de dados revisa resultados, pergunta sobre o outlier que ninguém considerou e direciona a análise em ciclos de horas; a área de negócios consome relatórios e remodela o framework analítico ao longo de dias a semanas. Muitos produtos de análise morrem na camada dois — o cientista vira uma esteira de revisão manual. Um agente de atendimento ao cliente resolve problemas comuns em segundos, uma equipe de QA revisa transcrições e itera a base de conhecimento por hora, e pesquisas de satisfação mais dados de NPS recalibram a estratégia semanalmente — pule o loop externo e a base de conhecimento se afasta do que os clientes realmente querem. Um agente de conteúdo de vendas redige e-mails personalizados em minutos, um líder de vendas revisa tom e conformidade por hora, e dados de taxa de resposta remodelam as mensagens ao longo de dias — a falha clássica é tentar automatizar toda a verificação no loop interno, o que produz montanhas de e-mails conformes que ninguém responde.
O padrão nos três casos: equipes que comprimem a verificação das camadas dois e três na camada um travam; equipes que mantêm as três cadências distintas, com humanos e IA cada um segurando sua própria camada, continuam compondo ganhos. Isso não é um problema de tecnologia. É um problema de design de sistemas.
O Que Isso Significa Para Você
A engenharia de loops não é mais um jargão da moda; é uma renegociação estrutural da relação humano-máquina. Por três anos o padrão subjacente do uso de IA nunca mudou — um humano instrui, a IA executa, o humano julga o resultado. O humano sentava dentro do loop como seu motor. A engenharia de loops é o primeiro paradigma que move o humano do centro do ciclo para sua periferia: de motorista para navegador.
- Se você é desenvolvedor, sua vantagem competitiva não é mais o artesanato de prompts. É a capacidade de definir problemas, projetar critérios de aceitação e codificar o que você sabe que o modelo não sabe em mecanismos de verificação. Pare de perguntar “o modelo consegue construir essa funcionalidade” e comece a perguntar “como esse loop deveria ser projetado para que o agente consiga levá-lo até a conclusão sozinho”.
- Se você é gerente de produto, a velocidade de iteração interna está prestes a colapsar para segundos na camada de código — mas o julgamento de produto e o feedback dos usuários não ficarão mais rápidos. A pressão da equipe migra para cima, para a camada de abstração: a qualidade das suas especificações e critérios de aceitação agora limita diretamente a qualidade do que os agentes produzem.
- Se você cuida do lado do negócio, seu conhecimento específico e não codificado do negócio está se valorizando. A vantagem de contexto não é automatizada — enquanto você souber coisas que o modelo não sabe, você pertence ao loop. O que você precisa aprender não é escrever prompts, mas estruturar conhecimento de negócio em regras de verificação.
Todo mundo começa com o mesmo instinto — a IA é uma estagiária brilhante que precisa de supervisão. O objetivo de design da engenharia de loops é transformar essa supervisão de microgerenciamento em gestão por objetivos. Você não está mais supervisionando cada passo que o agente dá. Você está projetando o sistema dentro do qual ele trabalha de forma eficaz. Essa é a atualização mais importante de modelo mental sobre IA em 2026 — não sobre os modelos, mas sobre nossa relação com eles.
Fontes: Anthropic, Getting Started with Loops; Andrew Ng, The Batch, 30 de junho de 2026; AI Builder Club Loop Engineering Guide (2026); posts públicos de Addy Osmani e Peter Steinberger.
