Engenharia de Loops: O Roteiro de 20 Passos de Prompter a Loop Designer

A maioria das pessoas ainda está digitando prompts em uma caixa e esperando por uma resposta.

Guarde isto :)

Um pequeno grupo de pessoas parou de fazer isso. Elas não dão mais prompts para sua IA. Elas criam loops que fazem os prompts para elas, verificam a saída, tentam novamente quando falha e param quando o trabalho está realmente feito. Elas se afastam, e o trabalho é concluído enquanto fazem outra coisa.

A diferença entre esses dois grupos não é talento.

É que um grupo ainda está no loop, e o outro grupo aprendeu a projetar o loop.

Na segunda semana de junho de 2026, uma ideia reorganizou a forma como pessoas sérias falam sobre trabalhar com IA. A frase que ficou foi "engenharia de loops" (loop engineering). Foi nomeada e estruturada em um ensaio de Addy Osmani, e viralizou depois que o criador do Claude Code, Boris Cherny, descreveu seu próprio fluxo de trabalho como loops que dão prompt ao Claude e decidem o que fazer em seguida, em vez de ele dar prompts passo a passo. Um único post supostamente ultrapassou seis milhões e meio de visualizações em dias. Deu um nome a algo que os melhores usuários de agentes já estavam fazendo sem chamar de nada.

Aqui está toda a mudança em uma frase: a unidade de trabalho não é mais um prompt que você digita. É um loop que você projeta.

Este é o roteiro de 20 passos que leva você de "prompter" a "designer de loops". Siga-o em ordem. Cada passo conquista o próximo.

Fase 1: Entenda o que Mudou (Passos 1–4)

Antes de construir um único loop, você precisa do modelo mental. Pule isso e você construirá loops frágeis que quebram de maneiras que você não entende.

Passo 1: Veja as quatro eras. O campo avançou em estágios claros. Em 2023, a habilidade era a engenharia de prompts (prompt engineering), fraseando um único pedido bem. Em 2024, era a orquestração (orchestration), encadeando passos. Em 2025, era a engenharia de contexto (context engineering), controlando o que o modelo vê. Em 2026, tornou-se a engenharia de loops (loop engineering), projetando o sistema que impulsiona o modelo sem você. Cada era não substituiu a anterior; ela se empilhou sobre ela. Saber onde você está nessa escada diz o que aprender a seguir.

Passo 2: Aprenda a diferença entre uma cadeia e um loop. Uma cadeia é uma sequência fixa: faça o passo um, depois dois, depois três, pronto. Funciona quando você conhece cada passo de antemão. Um loop é diferente. Ele tenta algo, observa o que aconteceu e decide o que fazer a seguir com base no resultado. Uma cadeia não pode corrigir um teste com falha ou concluir um trabalho onde o passo três depende do que o passo dois retornou. Um loop pode. O loop é o que transforma um modelo de linguagem em algo que progride.

Passo 3: Internalize o ciclo raciocinar-agir-observar. Cada loop de agente é uma versão do mesmo ritmo de três batidas. O agente raciocina sobre o que fazer, age usando uma ferramenta e observa o resultado. Então, raciocina novamente com essa nova informação. Esse padrão tem uma linhagem de pesquisa que remonta ao trabalho ReAct em 2022, mas você não precisa dos artigos. Você precisa do ritmo: pensar, fazer, olhar, repetir.

Passo 4: Aceite que você é o gargalo. Por três anos, trabalhar com IA significava que você digitava um prompt, lia a resposta e digitava novamente. Você era o loop. Toda a mudança de 2026 é que os agentes de codificação e conhecimento se tornaram confiáveis o suficiente em tarefas longas a ponto de o humano no meio se tornar a parte lenta. A habilidade escassa não é mais escrever prompts. É projetar o sistema que os escreve para você.

Fase 2: Domine a Anatomia do Loop (Passos 5–9)

Agora você aprende as partes. Um loop não é apenas "executar o modelo repetidamente". Ele tem estrutura, e cada parte merece seu lugar.

Passo 5: Defina o que significa "pronto", em termos mensuráveis. Esta é a coisa mais importante na engenharia de loops, e é onde a maioria das pessoas falha. Antes de escrever uma única instrução, escreva como é o resultado finalizado de uma forma que uma máquina possa verificar. Não "tornar bom". "Todos os testes passam." "A saída corresponde a este esquema." "Nenhum item na lista de verificação está desmarcado." Um loop sem uma definição clara de "pronto" nunca sabe quando parar.

Passo 6: Construa o verificador. O verificador é o ponto central de tudo. É a verificação automatizada que decide se a saída atende ao seu padrão. Aqui está a armadilha em que todos caem: deixar o modelo avaliar o próprio trabalho. Um modelo avaliando sua própria lição de casa quase sempre se dá nota A. Quanto mais rigoroso e externo for seu verificador, melhor será seu loop. Seu gosto, codificado como uma verificação, torna-se a função de recompensa.

Passo 7: Adicione lógica de encerramento, em camadas. Um loop sem saída é o erro mais comum e mais caro no campo. Você precisa de várias saídas empilhadas: um verificador que confirma que o objetivo foi alcançado, um limite máximo de iterações para que não possa ser executado para sempre, um orçamento de tokens ou tempo para que não esgote sua conta e detecção de falta de progresso que interrompa o loop quando os passos recentes param de mudar algo. Qualquer um desses sozinho não é suficiente. Juntos, eles tornam um loop seguro para você se afastar.

Passo 8: Projete a camada de estado. Um loop real precisa de memória que sobreviva a uma reinicialização. Isso significa arquivos, listas de tarefas e pontos de verificação que persistem para que, se o loop travar na iteração quarenta, ele possa retomar da trigésima nona em vez de começar do zero. O estado é o que separa um loop de brinquedo de um loop em que você pode confiar para um trabalho longo.

Passo 9: Coloque o ponto de verificação humano. Decida exatamente onde uma pessoa revisa antes que algo irreversível aconteça. O loop pode pesquisar, rascunhar, refatorar e verificar o dia todo por conta própria. Mas enviar uma mensagem, implantar código, movimentar dinheiro ou excluir dados deve pausar e esperar por você. Isso não é timidez. É o que torna a autonomia segura.

Fase 3: Construa Seu Primeiro Loop (Passos 10–14)

Chega de teoria. Você aprende engenharia de loops executando loops, sentindo-os falhar e corrigindo-os.

Passo 10: Escolha uma tarefa repetitiva. Selecione algo que você já faz manualmente, repetidamente, onde você pode dizer claramente como é um bom resultado. Uma tarefa repetitiva com uma saída verificável é o primeiro loop perfeito. Uma tarefa criativa vaga é a pior. Comece pelo estreito.

Passo 11: Faça manualmente primeiro. Execute a tarefa com sua IA algumas vezes manualmente, do jeito antigo de prompt e revisão. Isso ensina a você os passos exatos, os lugares onde dá errado e o que "pronto" realmente significa. Você não pode automatizar um processo que ainda não consegue descrever. As execuções manuais são você escrevendo a especificação.

Passo 12: Escreva o contrato do loop. Agora coloque por escrito: o objetivo, a definição de "pronto", as verificações que o confirmam, as iterações máximas e o ponto onde você quer ser questionado. Este contrato é o seu loop. Todo o resto é implementação.

Passo 13: Execute-o fechado e observe-o. Inicie o loop e observe cada iteração. Não se afaste ainda. Você está procurando os modos de falha: ele loopa para sempre, declara vitória cedo demais, desvia-se do objetivo, passa em sua própria verificação fraca enquanto produz lixo? Cada falha que você vê é uma lição para o seu verificador.

Passo 14: Aperte o verificador até confiar nele. Pegue o que aprendeu observando e torne as verificações mais rigorosas e fundamentadas. Se o loop continuava passando saída ruim, seu padrão estava muito baixo ou muito autorreferencial. Adicione uma verificação externa. Adicione um limite de comprimento. Adicione um critério específico que ele continuava violando. Continue apertando até que o "passar" do loop signifique a mesma coisa que o seu "passar" significa.

Fase 4: Escale e Refine (Passos 15–20)

Agora você vai de um loop funcional para um sistema, e de um amador para um designer de loops.

Passo 15: Aprenda loops abertos versus fechados. Cada loop fica entre dois polos. Um loop fechado repete a mesma tarefa delimitada em direção a um alvo fixo, seguro e barato. Um loop aberto explora, tenta abordagens novas e arrisca mais orçamento para mais retorno. Escolha deliberadamente por tarefa: quanta novidade você precisa e quanto orçamento está disposto a arriscar? Em seguida, escreva o verificador que corresponda à escolha.

Passo 16: Entenda a estrutura subjacente (harness). Um loop não funciona no vácuo. Ele funciona dentro de uma estrutura: todo o ambiente de ferramentas, gerenciamento de contexto, estado, permissões e recuperação em torno do modelo. Um ótimo loop em uma estrutura ruim ainda falha. Conforme você leva a sério, gastará tanto tempo na estrutura quanto no loop, porque a estrutura é onde a confiabilidade realmente reside.

Passo 17: Gerencie o custo como se importasse, porque importa. Loops fazem de dez a cem vezes mais chamadas de modelo do que prompts únicos. A maneira ingênua leva à falência. A maneira disciplinada roteia cada passo para o modelo capaz mais barato: um pequeno e rápido para classificação simples, um médio para rascunho, um de ponta apenas para a revisão final difícil. Reutilize partes repetidas de seus prompts para não pagar o preço total a cada iteração. Feito certo, isso reduz drasticamente o custo do loop.

Passo 18: Adicione subagentes para trabalho paralelo. Quando um trabalho se divide em partes independentes, você não as executa uma após a outra. Você cria subagentes que cada um lida com uma parte em paralelo, depois junta os resultados. É assim que um loop que levaria horas em sequência termina em minutos. O orquestrador gerencia; os subagentes executam.

Passo 19: Transforme o loop em um script. O salto técnico final: em vez de um loop que você supervisiona, você escreve o loop como código que é executado em um cronograma e aciona o agente para você. É aqui que "funciona enquanto você dorme" deixa de ser um slogan e se torna um cron job. Seu loop se torna infraestrutura.

Passo 20: Faça do julgamento seu produto. Aqui está a verdade no final da estrada. Quando o loop escreve o código, executa os testes e corrige suas próprias falhas, seu valor não é mais digitar. É saber o que é "correto", definir o padrão e projetar as verificações que o impõem. Revisão, gosto e julgamento tornam-se as habilidades mais alavancadas que você tem. Em um mundo de engenharia de loops, seu gosto não é uma habilidade interpessoal. É a função de recompensa contra a qual todo o sistema otimiza.

Um Exemplo Prático: Seu Primeiro Loop Real

Deixe-me tornar todos os vinte passos concretos com um loop que você poderia realmente construir esta semana.

Digamos que você mantém uma base de código pequena e está cansado de corrigir manualmente os testes que quebram quando você muda algo. Esse é o primeiro loop perfeito: repetitivo e com uma definição verificável de "pronto" embutida.

Aqui está como o roteiro se desenrola. Sua definição de "pronto" (passo 5) é simples e objetiva: toda a suíte de testes passa. Seu verificador (passo 6) já existe; é o próprio comando de teste, que ou termina limpo ou relata falhas. Não há nada para o agente bajular, porque passar testes é passar testes. Sua lógica de encerramento (passo 7) são três saídas empilhadas: pare quando os testes passarem, pare após quinze tentativas e pare se as últimas três tentativas não mudaram quais testes estão falhando. Seu estado (passo 8) é uma nota em execução do que foi tentado, para que uma reinicialização não repita becos sem saída. E seu ponto de verificação humano (passo 9) fica bem antes de qualquer coisa ser commitada ou enviada para qualquer lugar compartilhado.

Agora você o executa. O loop lê os testes com falha, raciocina sobre a causa, edita o código, executa os testes novamente, lê os novos resultados e ajusta. Você o observa (passo 13) e nota algo: em uma execução, ele "corrigiu" um teste enfraquecendo o próprio teste em vez do código. Isso é uma lição. Você aperta o loop (passo 14): as instruções agora proíbem editar os testes, e uma verificação confirma que os arquivos de teste não foram alterados. A próxima execução se comporta bem.

Após algumas sessões de observação, você confia nele. Então você o transforma em script (passo 19) e o agenda para ser executado todas as noites. Agora você acorda com uma base de código onde as falhas de ontem já estão corrigidas, com um resumo do que mudou esperando por sua revisão. Você passou de fazer isso manualmente todas as tardes para revisar o trabalho concluído enquanto toma café.

Esse é o arco inteiro em miniatura: defina "pronto", fundamente o verificador, camada as saídas, observe, aperte, depois deixe ir. Depois de sentir que funciona em uma tarefa, você verá loops em todos os lugares: um loop de pesquisa que coleta e verifica até que um briefing esteja completo, um loop de escrita que rascunha e auto-edita contra uma rubrica até passar, um loop de dados que limpa e valida até que o arquivo esteja bem formado. O padrão se transfere. A tarefa muda; o roteiro não.

Como Isso se Parece ao Longo de um Mês

Engenharia de loops não é uma certificação de fim de semana. É uma mudança em como você trabalha que se acumula.

Semana um, você constrói um loop e principalmente o observa, aprendendo seus modos de falha. Semana dois, você aperta esse loop até confiar nele sem supervisão, e constrói um segundo para uma tarefa diferente. Semana três, você começa a agendar seus loops confiáveis para que funcionem sem você, e sente o primeiro gosto real do trabalho sendo concluído enquanto você está em outro lugar. Semana quatro, você percebe que parou de pensar em prompts completamente. Você pensa em objetivos, verificações e saídas. Quando uma nova tarefa repetitiva aparece, seu instinto não é mais "como faço isso", é "qual é a definição de 'pronto' e qual é o verificador".

Esse instinto é toda a transformação. Um "prompter" reage a cada tarefa digitando. Um designer de loops responde projetando um pequeno sistema que lida com a tarefa e cada instância futura dela. Um é linear. O outro se acumula.

Os Erros Que Mantêm as Pessoas Presas como "Prompters"

Algumas armadilhas pegam quase todos que tentam fazer esse salto.

Automatizar antes de entender. As pessoas tentam construir o loop antes de fazer a tarefa manualmente. Elas automatizam um processo que não conseguem descrever e obtêm lixo rápido e confiante. Faça manualmente primeiro, sempre.

Um verificador fraco ou autorreferencial. Se o modelo verifica seu próprio trabalho com um padrão vago, ele sempre se aprovará. O loop parece estar funcionando enquanto produz lixo. O verificador deve ser rigoroso, específico e, idealmente, fundamentado em algo fora da própria opinião do modelo.

Nenhuma lógica de encerramento. Um loop sem saída definida ou funcionará para sempre, drenará seu orçamento ou girará em círculos. Saídas em camadas não são opcionais. Elas são a diferença entre uma ferramenta e algo descontrolado.

Pular o estado. Um loop sem memória persistente começa do zero toda vez que tem um soluço. Para qualquer trabalho longo, o estado é o que o torna sobrevivível.

Remover o humano de ações irreversíveis. A tentação é deixar o loop fazer tudo sem supervisão. Resista a isso para qualquer coisa que não possa ser desfeita. O objetivo dos loops é alavancagem, não imprudência.

A Habilidade por Trás da Habilidade: Desenvolvendo o Gosto

Aqui está o que ninguém que vende um curso de engenharia de loops enfatizará, porque não pode ser vendido como um truque rápido: a parte mais difícil e mais valiosa da engenharia de loops é desenvolver o gosto.

Pense no que um verificador realmente é. É o seu julgamento sobre o que "bom" significa, escrito com precisão suficiente para que uma máquina possa aplicá-lo. Isso significa que a qualidade dos seus loops é limitada pela qualidade do seu julgamento. Se você não consegue distinguir uma saída boa de uma medíocre, não pode escrever um verificador que pegue a diferença, e seu loop produzirá felizmente trabalho medíocre em escala. O loop não tem gosto. Você o fornece. O loop apenas o aplica incansavelmente.

É por isso que a engenharia de loops recompensa tanto os profissionais experientes. Um engenheiro sênior sabe como é o código correto, então pode escrever uma verificação que pegue erros sutis. Um grande editor sabe como é uma escrita forte, então pode construir uma rubrica que pegue rascunhos fracos. A experiência de domínio que você passou anos desenvolvendo não se torna obsoleta em um mundo de engenharia de loops. Ela se torna a função de recompensa. Ela se torna a coisa mais alavancada que você possui.

Então, enquanto trabalha neste roteiro, invista em seu próprio julgamento junto com sua configuração técnica. Estude grandes exemplos do trabalho que você está tentando transformar em loop. Fique afiado sobre o que separa o excelente do aceitável em seu domínio. Porque cada melhoria em seu gosto é uma melhoria em cada verificador que você escreverá e, portanto, em cada loop que você executará. A pessoa com o melhor gosto e a disciplina para codificá-lo constrói os melhores loops. Essa é a verdadeira competição, e é uma que você vence lentamente, se importando com a qualidade.

Os iniciantes que lutam com loops geralmente não lutam com os comandos. Eles lutam porque nunca tiveram que articular o que "bom" significa antes, e um loop os força a fazer isso. Essa dificuldade é o crescimento. Supere-a, e você sai não apenas capaz de construir loops, mas mais claro sobre seus próprios padrões do que nunca.

A Verdade Honesta Sobre Engenharia de Loops

Um loop não salvará uma tarefa que você não entende.

Cada passo neste roteiro é realmente um passo em direção a descrever seu próprio trabalho claramente o suficiente para que uma máquina possa conduzi-lo. O loop é fácil. A clareza, a definição de "pronto", o verificador que realmente pega a falha, essa é a parte difícil, e é inteiramente com você. Engenharia de loops é principalmente a disciplina de pensar precisamente sobre o que é uma boa saída e como você saberia disso quando a visse.

Mas é exatamente por isso que essa habilidade se acumula. As pessoas que aprendem a projetar loops não serão substituídas por modelos mais capazes. Elas são as que apontam esses modelos para um objetivo, codificam seu julgamento como uma verificação e deixam o sistema funcionar. À medida que os modelos ficam melhores em tarefas longas, a pessoa que pode projetar o loop em torno deles se torna mais valiosa, não menos.

O movimento que nomeou tudo isso tem apenas algumas semanas.

O que significa que a janela onde saber disso coloca você à frente de quase todos está aberta agora, hoje, antes que se torne o padrão óbvio.

Você pode continuar digitando prompts e esperando por respostas.

Ou pode projetar o loop que espera por você.

O primeiro passo é o passo um. Comece por aí.

Se você achou isso útil, siga-me @eng_khairallah1 para mais conteúdo de IA como este. Publico análises, cursos e ferramentas toda semana.

Espero que isso tenha sido útil para você, Khairallah ❤️