Engenharia de Loop: Como construir agentes que aprimoram seu próprio trabalho

Da criação manual de prompts a loops projetados

A maioria das pessoas ainda opera agentes de IA manualmente

Elas inserem uma tarefa

Aguardam uma resposta

Revisam o resultado por conta própria

Corrigem os erros manualmente

E então enviam outro prompt

O humano ainda está fazendo o looping

O próximo estágio é diferente

Você para de dar prompts ao agente passo a passo

Você constrói um loop ao redor dele

O loop fornece instruções

Verifica a saída

Escolhe a próxima ação

E continua rodando até que o resultado atenda ao padrão

Isso é engenharia de loops

A ideia é simples

Pare de gastar seu tempo dando prompts manuais para agentes

Comece a projetar os sistemas que dão prompts para você

"Você não deveria mais estar dando prompts para agentes de código. Você deveria estar projetando loops que dão prompts para seus agentes"

Boris Cherny lidera o Claude Code na Anthropic

Ele descreveu a mesma mudança através de seu próprio fluxo de trabalho:

"Eu não dou mais prompts para o Claude. Tenho loops rodando que dão prompts para o Claude e descobrem o que fazer. Meu trabalho é escrever loops"

Por que a maioria das pessoas ainda não constrói loops reais

Loops parecem incríveis até você ver a conta de tokens

Um loop de agente normal pode consumir contexto extremamente rápido:

• Um loop de codificação de médio porte pode usar 50K-200K tokens
• Uma frota com um orquestrador e especialistas pode usar 500K-2M tokens
• Um loop programado para rodar diariamente pode consumir milhões de tokens toda semana

Cada nova tentativa custa tokens

Cada correção custa tokens

Cada etapa de verificação custa tokens

Cada subagente adiciona outra conta

Essa é a limitação oculta que as pessoas raramente discutem

A engenharia de loops não é difícil porque o conceito é complicado de entender

É difícil porque a maioria dos usuários não pode pagar por execuções ilimitadas de agentes

A resposta óbvia é:

"Fácil para você dizer, você tem acesso ilimitado ao OpenAI"

E essa crítica é justa

É por isso que modelos baratos com grandes janelas de contexto são tão importantes

Para rodar loops úteis todos os dias, você precisa de:

• Tokens de entrada acessíveis
• Tokens de saída acessíveis
• Grandes janelas de contexto
• Chamada de ferramentas confiável
• Saída JSON estruturada
• Alta concorrência
• Contexto suficiente para lembrar etapas anteriores

Sem essas coisas, loops continuam sendo experimentos caros

Com elas, loops se tornam sistemas práticos que podem executar trabalho real

O fluxo de trabalho antigo vs o novo fluxo de trabalho

Nos últimos dois anos, a maioria das pessoas usou agentes assim:

Você dá o prompt

O agente responde

Você revisa a resposta

Você percebe um problema

Você dá o prompt novamente

Funciona, mas não escala

O fluxo de trabalho antigo:

• Você escreve o prompt
• O agente cria uma saída
• Você inspeciona a saída
• Você repara as partes fracas
• Você repete o processo manualmente

O novo fluxo de trabalho:

• Você define o resultado
• O loop descobre o que é necessário
• O loop cria um plano
• O agente executa o trabalho
• Um verificador avalia o resultado
• O loop corrige falhas
• O sistema para quando o objetivo é concluído

Um prompt dá ao agente uma única instrução

Um loop dá ao agente um trabalho completo

O que a engenharia de loops realmente significa

Engenharia de loops significa construir ciclos de feedback repetíveis em torno de agentes de IA

O objetivo é direto:

Ir de uma tentativa inicial a um resultado verificado

Sem um humano controlando cada etapa

O loop básico contém cinco estágios:

1. Descobrir
2. Planejar
3. Executar
4. Verificar
5. Iterar

Se o resultado passar na verificação, publique

Se o resultado falhar, retorne-o ao loop

Esse é o conceito inteiro

Você não está tentando escrever um prompt perfeito

Você está criando um sistema

Um que melhora saídas imperfeitas até que elas atendam ao requisito

Loops de agente único

Loops geralmente vêm em dois tamanhos

A versão menor usa um agente para completar todo o ciclo

Ele descobre o que precisa acontecer

Planeja o trabalho

Realiza a tarefa

Revisa o resultado

E tenta novamente quando algo falha

É semelhante a uma pessoa editando seu próprio rascunho até que esteja pronto

Loops de agente único funcionam bem para:

• Tarefas focadas
• Escopos limitados
• Objetivos claros
• Rascunhos de conteúdo
• Correções de bugs
• Resumos de pesquisa

Um agente

Um ciclo de feedback

Autoaperfeiçoamento contínuo

Loops de frota

Um loop de frota opera em uma escala maior

Um orquestrador recebe o objetivo principal

Ele divide o objetivo em partes menores

Essas partes são atribuídas a agentes especialistas

Cada especialista também pode delegar tarefas estreitas a subagentes menores

Exemplo:

1Objetivo: Construir um aplicativo de produtividade
2
3Orquestrador é o dono da missão
4        ↓              ↓              ↓
5    Pesquisa        Engenharia        QA
6    Especialista    Especialista      Especialista
7        ↓              ↓              ↓
8 Pesquisador Web  Escritor de Código  Escritor de Testes
9                  + Depurador         + Rastreador de Bugs

Isso não é mais um agente trabalhando sozinho

É mais próximo de uma pequena equipe autônoma executando um projeto do início ao fim

Loops abertos vs loops fechados

Esta é a diferença prática mais importante

Nem todo loop funciona da mesma forma

Loops abertos

Loops abertos são exploratórios

Você fornece um objetivo amplo e permite que o agente descubra seu próprio caminho

O agente pode descobrir coisas úteis que você nunca especificou

Mas também pode se tornar caro e caótico

Loops abertos podem:

• Explorar muitas direções
• Desperdiçar grandes quantidades de tokens
• Gerar trabalho de baixa qualidade em alta velocidade
• Desviar do objetivo real
• Tornar-se difíceis de controlar

Loops abertos são empolgantes

Mas geralmente não são o melhor ponto de partida

Loops fechados

Loops fechados têm limites claros

O humano define o caminho primeiro

O loop ainda opera de forma independente, mas permanece dentro de regras explícitas

Um loop fechado inclui:

• Um objetivo claro
• Estágios definidos
• Avaliação após cada estágio
• Uma condição de parada
• Uma transferência para humano se o sistema travar

Esta é a versão que cria valor hoje

Custa menos

É mais fácil de confiar

Produz resultados mais limpos

Comece com loops fechados

Torne-os mais abertos somente depois que suas verificações forem fortes o suficiente

Os 6 blocos de construção de um loop eficaz

Todo loop segue o mesmo ciclo de cinco estágios conceitualmente

Na prática, seis blocos de construção tornam esse ciclo útil

1 Automações

Automação é o coração do loop

Ela inicia o processo sem exigir que você se lembre de lançá-lo manualmente

Exemplos:

• Rodar todas as manhãs
• Rodar sempre que um PR for aberto
• Rodar após um arquivo ser alterado
• Rodar quando um novo ticket aparecer
• Continuar até que todos os testes passem

Se você ainda inicia cada ação manualmente, o loop não está fazendo o suficiente

2 Worktrees

Worktrees se tornam importantes quando vários agentes editam código ao mesmo tempo

Sem isolamento, os agentes colidem

Dois agentes podem alterar o mesmo arquivo

Um agente pode sobrescrever o trabalho de outro agente

Uma worktree dá a cada agente um espaço de trabalho e um branch separados

Isso permite que vários agentes trabalhem em paralelo

Sem transformar o repositório em uma bagunça

3 Skills

Skills armazenam conhecimento reutilizável sobre o projeto

Pare de explicar o mesmo contexto durante toda execução

Escreva a informação importante uma vez

Deixe que todo loop futuro a reutilize

Arquivos de skill úteis podem conter:

• Visão do produto
• Arquitetura
• Regras do projeto
• Instruções de build
• Instruções de teste
• Ações que o agente nunca deve tomar

Sem skills, todo loop começa do zero

Com skills, toda execução começa com conhecimento acumulado de trabalhos anteriores

4 Plugins e conectores

Um loop que só pode ler arquivos locais tem valor limitado

Conectores permitem que ele interaja com as ferramentas onde seu trabalho real acontece

Exemplos:

• GitHub
• Slack
• Linear
• Jira
• Gmail
• Google Drive
• Bancos de dados
• APIs de staging

Esta é a diferença entre:

"Aqui está uma possível correção"

E:

"Abri o PR e o conectei ao ticket"

"Então monitorei o CI e publiquei a atualização final"

5 Subagentes

O criador e o verificador não devem ser sempre o mesmo agente

Um agente que escreveu o código pode ser muito indulgente ao revisá-lo

Um agente que redigiu um artigo pode ignorar as mesmas seções fracas duas vezes

Use agentes separados para:

• Exploração
• Implementação
• Revisão
• Teste
• Verificação de fatos
• Resumos finais

A qualidade melhora quando o revisor é independente

O criador não deve ser o único a verificar o trabalho

6 Memória

A memória permite que o loop continue em várias execuções

O modelo esquece

O repositório não esquece

As anotações não esquecem

O log do projeto não esquece

A memória pode ser armazenada em:

• Arquivos Markdown
• Logs de projeto
• Tickets do Linear
• Issues do GitHub
• Vaults do Obsidian
• Bancos de dados
• Projetos do Claude

Um loop de longa duração deve lembrar o que já foi tentado

O que funcionou

O que falhou

E o que ainda precisa ser concluído

Sem memória persistente, o loop começa do zero toda vez

Exemplos reais de loops

Esses fluxos de trabalho tornam a ideia concreta

Loop de codificação

1Ler VISION.md + ARCHITECTURE.md
2↓
3Planejar a próxima alteração
4↓
5Editar o código
6↓
7Executar os testes
8↓
9Se os testes falharem → inspecionar o erro → corrigir → testar novamente
10↓
11Se os testes passarem → resumir as alterações
12↓
13Parar

Um humano não precisa dirigir cada etapa

O agente escreve, testa, corrige e verifica seu próprio trabalho

Loop de pesquisa

1Definir a pergunta de pesquisa
2↓
3Encontrar fontes relevantes
4↓
5Resumir as evidências
6↓
7Verificar cada afirmação contra as fontes
8↓
9Comparar informações conflitantes
10↓
11Criar a síntese final
12↓
13Parar quando o limite de confiança for atingido

Isso produz um resultado muito mais forte do que pedir um resumo rápido

Loop de conteúdo

1Definir o tópico + público + objetivo
2↓
3Criar o primeiro rascunho
4↓
5Enviá-lo para um agente de crítica
6↓
7Reescrever usando a crítica
8↓
9Pontuar contra os critérios de sucesso
10↓
11Se passar → publicar
12↓
13Se falhar → reescrever novamente

O loop transforma uma ideia em um sistema de conteúdo repetível

Loop de prospecção de vendas

1Definir o ICP
2↓
3Encontrar leads que correspondam ao perfil
4↓
5Enriquecer cada lead com dados da empresa
6↓
7Qualificá-los contra os critérios
8↓
9Personalizar a mensagem
10↓
11Executar uma revisão de qualidade
12↓
13Enviar ou escalar para um humano

Cada exemplo usa o mesmo esqueleto:

Objetivo

Ação

Verificação

Correção

Repetir até que o trabalho esteja completo

Engenheiro de prompts vs engenheiro de loops

Esta é a nova lacuna de habilidades que está se abrindo em 2026

Engenheiro de prompts

Um engenheiro de prompts concentra-se em melhores instruções

Eles melhoram o texto

Eles produzem uma resposta única mais forte

Mas depois que o agente termina, um humano ainda precisa revisar tudo

O humano continua sendo o loop de feedback

Engenheiro de loops

Um engenheiro de loops constrói o próprio sistema de feedback

Eles determinam:

• O que inicia o loop
• Qual contexto o agente recebe
• Quais ferramentas ele pode acessar
• O que qualifica como sucesso
• Quem verifica o resultado
• Quando o processo deve parar
• Onde a saída final é armazenada

Um engenheiro de prompts diz:

"Escreva uma função para mim"

Um engenheiro de loops diz:

"Escreva a função"

"Teste-a e corrija-a até que todos os testes passem"

"Depois resuma a alteração"

As ferramentas podem ser idênticas

A mentalidade é completamente diferente

Os construtores de IA de maior alavancagem estão indo além de melhores instruções

Eles estão criando sistemas que descobrem e planejam

Executam e verificam

E então param no momento correto

A versão resumida

Engenharia de loops é a mudança de prompts manuais para ciclos de feedback automatizados

A mudança:

• Modo antigo: Dar uma tarefa por vez a um agente
• Modo novo: Construir um loop que gerencia o ciclo completo

As 6 coisas que você constrói:

• Automações: Iniciar o loop automaticamente
• Worktrees: Permitir que agentes trabalhem em paralelo sem conflitos de arquivos
• Skills: Reutilizar conhecimento do projeto em toda execução
• Plugins e conectores: Dar ao loop acesso a ferramentas reais
• Subagentes: Separar criadores de revisores
• Memória: Preservar conhecimento entre execuções

Os 2 tamanhos:

• Loop de agente único: Um agente melhora repetidamente seu próprio trabalho
• Loop de frota: Um orquestrador coordena especialistas e subagentes

Os 2 tipos:

• Loop aberto: Flexível, exploratório e caro
• Loop fechado: Limitado, confiável e acessível

Os 5 estágios:

1. Descobrir
2. Planejar
3. Executar
4. Verificar
5. Iterar

O problema real de custo:

• Loops consomem tokens rapidamente
• Modelos baratos de contexto longo os tornam práticos
• Sem tokens acessíveis, a maioria dos usuários nunca vai além de experimentos

A mudança de mentalidade:

• Engenheiros de prompts solicitam saídas da IA
• Engenheiros de loops constroem sistemas que entregam resultados verificados

Esse é o verdadeiro ganho

Pare de procurar um prompt perfeito

Construa um loop que continua melhorando saídas imperfeitas

Um loop confiável vencerá um prompt perfeito

Se você leu até aqui

Siga @elune0x e salve este artigo nos favoritos

Volte a ele quando estiver pronto para construir seus próprios loops