Da criação manual de prompts à engenharia de loop
A maioria das pessoas ainda opera agentes de IA manualmente.
Elas inserem uma tarefa, aguardam uma resposta, revisam o resultado, corrigem os erros, e então enviam outro prompt.
O ser humano ainda é quem executa o loop.
A próxima etapa é diferente.
Você deixa de fazer o prompting do agente passo a passo e passa a construir um loop ao redor dele.
O loop fornece as instruções, verifica o resultado, escolhe a próxima ação e continua executando até que o resultado atenda ao padrão estabelecido.
Isso é engenharia de loop.
A ideia é simples:
Pare de gastar seu tempo criando prompts manualmente para os agentes.
Comece a projetar sistemas que criem esses prompts para você.
“Você não deveria mais ficar criando prompts para agentes de programação. Você deveria projetar loops que criem prompts para seus agentes.”
Boris Cherny lidera o Claude Code na Anthropic.
Ele descreveu essa mesma mudança a partir de seu próprio fluxo de trabalho:
“Eu não crio mais prompts para o Claude. Tenho loops que executam 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 de verdade
Os 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 programação de tamanho médio pode usar 50 mil a 200 mil tokens.
- Uma frota com um orquestrador e agentes especialistas pode usar 500 mil a 2 milhões de tokens.
- Um loop programado para ser executado diariamente pode consumir milhões de tokens por semana.
Cada nova tentativa custa tokens. Cada correção custa tokens. Cada etapa de verificação custa tokens. Cada subagente acrescenta uma nova cobrança.
Essa é a limitação oculta que raramente é discutida.
A engenharia de loop não é difícil porque o conceito seja complicado de entender.
Ela é 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 isso, você tem acesso ilimitado à OpenAI.”
E essa crítica é justa.
É por isso que modelos baratos com grandes janelas de contexto são tão importantes.
Para executar loops úteis todos os dias, você precisa de:
- Tokens de entrada acessíveis
- Tokens de saída acessíveis
- Grandes janelas de contexto
- Chamadas de ferramentas confiáveis
- Saída estruturada em JSON
- Alta concorrência
- Contexto suficiente para lembrar das etapas anteriores
Sem essas características, os loops continuam sendo experimentos caros.
Com elas, os loops se tornam sistemas práticos capazes de executar trabalho real.
O fluxo de trabalho antigo versus o novo
Nos últimos dois anos, a maioria das pessoas utilizou agentes desta forma:
Você cria um prompt. O agente responde. Você revisa a resposta. Percebe um problema. Cria outro prompt.
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ê corrige os pontos fracos
- Você repete manualmente o processo
O novo fluxo de trabalho
- Você define o resultado desejado
- 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 as falhas
- O sistema para quando o objetivo é concluído
Um prompt fornece ao agente uma única instrução.
Um loop fornece ao agente um trabalho completo.
O que realmente significa engenharia de loop
Engenharia de loop significa construir ciclos de feedback repetíveis ao redor de agentes de IA.
O objetivo é simples:
Passar de uma primeira tentativa para um resultado verificado, sem que um ser humano controle cada etapa.
O loop básico contém cinco etapas:
- Descobrir
- Planejar
- Executar
- Verificar
- Iterar
Se o resultado passar pela verificação, entregue-o.
Se o resultado falhar, devolva-o ao loop.
Esse é todo o conceito.
Você não está tentando escrever um prompt perfeito.
Você está criando um sistema que melhora resultados imperfeitos até que eles atendam ao requisito.
Loop de agente único
Os loop geralmente aparecem em dois tamanhos.
A versão menor usa um único agente para completar todo o ciclo.
Ele descobre o que precisa acontecer, planeja o trabalho, executa a tarefa, revisa o resultado e tenta novamente quando algo falha.
É semelhante a uma pessoa editando seu próprio rascunho até que ele esteja pronto.
Loop de agente único funcionam bem para:
- Tarefas específicas
- Escopos limitados
- Objetivos claros
- Rascunhos de conteúdo
- Correções de bugs
- Resumos de pesquisas
Um agente. Um ciclo de feedback. Melhoria contínua por conta própria.
Loop em frota
Um loop em 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 específicas a subagentes menores.
Exemplo
Objetivo: Construir um aplicativo de produtividade
Orquestrador
/ | \
/ | \
Pesquisa Engenharia QA
Especialista Especialista Especialista
| | |
Pesquisador Escritor de Escritor de
Web Código Testes
+ +
Debugger Rastreador
de Bugs
Isso já não é mais um único agente trabalhando sozinho.
É mais parecido com uma pequena equipe autônoma executando um projeto do início ao fim.
Loops abertos versus loops fechados
Essa é a diferença prática mais importante.
Nem todo loop funciona da mesma maneira.
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 direções demais
- Desperdiçar grandes quantidades de tokens
- Gerar trabalho de baixa qualidade em alta velocidade
- Se afastar 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 possuem limites claros.
O ser 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
- Etapas definidas
- Avaliação após cada etapa
- Uma condição de parada
- Transferência para um ser humano caso o sistema fique bloqueado
Essa é a versão que gera valor hoje.
Ela custa menos. É mais fácil de confiar. Produz resultados mais consistentes.
Comece com loops fechados.
Torne-os mais abertos somente depois que seus mecanismos de verificação forem suficientemente robustos.
Os 6 blocos de construção de um loop eficaz
Todo loop segue conceitualmente o mesmo ciclo de cinco etapas.
Na prática, seis blocos de construção tornam esse ciclo realmente útil.
1. Automações
A automação é o coração do loop.
Ela inicia o processo sem exigir que você se lembre de iniciá-lo manualmente.
Exemplos:
- Executar todas as manhãs
- Executar sempre que um PR for aberto
- Executar depois que um arquivo for alterado
- Executar quando um novo ticket aparecer
- Continuar até que todos os testes sejam aprovados
Se você ainda precisa iniciar cada ação manualmente, o loop não está fazendo o suficiente.
2. Worktrees
Worktrees tornam-se importantes quando vários agentes editam código simultaneamente.
Sem isolamento, os agentes entram em conflito.
Dois agentes podem alterar o mesmo arquivo.
Um agente pode sobrescrever o trabalho de outro.
Um worktree fornece a cada agente um espaço de trabalho e uma 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 a cada execução.
Escreva as informações importantes uma única vez.
Permita que todos os loops futuros as reutilizem.
Arquivos de skills úteis podem conter:
- Visão do produto
- Arquitetura
- Regras do projeto
- Instruções de compilação
- Instruções de testes
- Ações que o agente nunca deve executar
Sem skills, cada loop começa do zero.
Com skills, cada execução começa com o conhecimento acumulado dos trabalhos anteriores.
4. Plugins e conectores
Um loop que só consegue ler arquivos locais tem valor limitado.
Conectores permitem que ele interaja com as ferramentas onde o trabalho real acontece.
Exemplos:
- GitHub
- Slack
- Linear
- Jira
- Gmail
- Google Drive
- Bancos de dados
- APIs de staging
Essa é a diferença entre:
“Aqui está uma possível correção.”
e:
“Abri o PR e o conectei ao ticket. Depois monitorei o CI e publiquei a atualização final.”
5. Subagentes
O agente que cria e o agente que verifica nem sempre devem ser o mesmo.
Um agente que escreveu o código pode ser tolerante demais ao revisá-lo.
Um agente que escreveu um artigo pode deixar passar as mesmas seções fracas duas vezes.
Use agentes separados para:
- Exploração
- Implementação
- Revisão
- Testes
- Verificação de fatos
- Resumos finais
A qualidade melhora quando o revisor é independente.
O criador não deve ser o único responsável por verificar o trabalho.
6. Memória
A memória permite que o loop continue entre várias execuções.
O modelo esquece.
O repositório não.
As anotações não.
O registro do projeto não.
A memória pode ser armazenada em:
- Arquivos Markdown
- Logs do projeto
- Tickets do Linear
- Issues do GitHub
- Cofres do Obsidian
- Bancos de dados
- Claude Projects
Um loop de longa duração precisa 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 mais concreta.
Loop de programação
Ler VISION.md + ARCHITECTURE.md ↓Planejar a próxima alteração ↓Editar o código ↓Executar os testes ↓Se os testes falharem → inspecionar o erro → corrigir → testar novamente ↓Se os testes passarem → resumir as alterações ↓Parar
Um ser humano não precisa conduzir cada etapa.
O agente escreve, testa, corrige e verifica seu próprio trabalho.
Loop de pesquisa
Definir a pergunta de pesquisa ↓Encontrar fontes relevantes ↓Resumir as evidências ↓Verificar cada afirmação em relação às fontes ↓Comparar informações conflitantes ↓Criar a síntese final ↓Parar quando o limite de confiança for atingido
Isso produz um resultado muito mais robusto do que pedir um único resumo rápido.
Loop de conteúdo
Definir tópico + público + objetivo ↓Criar o primeiro rascunho ↓Enviar para um agente de crítica ↓Reescrever usando a crítica ↓Avaliar segundo os critérios de sucesso ↓Se passar → publicar ↓Se falhar → reescrever novamente
O loop transforma uma única ideia em um sistema de conteúdo repetível.
Loop de prospecção de vendas
Definir o ICP ↓Encontrar leads que correspondam ao perfil ↓Enriquecer cada lead com dados da empresa ↓Qualificá-los de acordo com os critérios ↓Personalizar a mensagem ↓Executar uma revisão de qualidade ↓Enviar ou encaminhar para um ser humano
Todos os exemplos utilizam a mesma estrutura:
Objetivo → Ação → Verificação → Correção → Repetição até concluir o trabalho
Engenheiro de prompt versus engenheiro de loop
Essa é a nova lacuna de habilidades que está surgindo em 2026.
Engenheiro de prompt
Um engenheiro de prompt concentra-se em criar instruções melhores.
Ele aprimora a redação.
Produz uma resposta única mais forte.
Mas, depois que o agente termina, um ser humano ainda precisa revisar tudo.
O ser humano continua sendo o loop de feedback.
Engenheiro de loop
Um engenheiro de loop constrói o próprio sistema de feedback.
Ele determina:
- O que inicia o loop
- Qual contexto o agente recebe
- Quais ferramentas ele pode acessar
- O que é considerado sucesso
- Quem verifica o resultado
- Quando o processo deve parar
- Onde o resultado final é armazenado
Um engenheiro de prompt diz:
“Escreva uma função para mim.”
Um engenheiro de loop diz:
“Escreva a função.” “Teste-a e corrija-a até que todos os testes sejam aprovados.” “Depois, faça um resumo da alteração.”
As ferramentas podem ser idênticas.
A mentalidade é completamente diferente.
Os construtores de IA que geram maior impacto estão indo além de instruções melhores.
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 loop é a transição de prompts manuais para ciclos automatizados de feedback.
A mudança
- Forma antiga: Dar ao agente uma tarefa de cada vez
- Nova forma: Construir um loop que gerencia o ciclo completo
As 6 coisas que você constrói
- Automações: Iniciam o loop automaticamente
- Worktrees: Permitem que os agentes trabalhem em paralelo sem conflitos de arquivos
- Skills: Reutilizam o conhecimento do projeto em cada execução
- Plugins e conectores: Dão ao loop acesso a ferramentas reais
- Subagentes: Separam criadores de revisores
- Memória: Preserva o conhecimento entre as execuções
Os 2 tamanhos
- Loop de agente único: Um agente melhora repetidamente seu próprio trabalho
- Loop em 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
As 5 etapas
- Descobrir
- Planejar
- Executar
- Verificar
- Iterar
O verdadeiro problema de custo
- Loops consomem tokens rapidamente
- Modelos baratos com contexto longo tornam os loops viáveis
- Sem tokens acessíveis, a maioria dos usuários nunca passa dos experimentos
A mudança de mentalidade
- Engenheiros de prompts solicitam resultados à IA
- Engenheiros de loop constroem sistemas que entregam resultados verificados
Esse é o verdadeiro ponto de virada.
Pare de procurar um único prompt perfeito.
Construa um loop que continue tornando melhores os resultados imperfeitos.
Um loop confiável vencerá um prompt perfeito.
Fonte:
Este artigo e a imagem foram traduzidos e adptados do texto original em inglês de @elune0x em https://x.com/elune0x/status/2079923329633313196 e publicado no Linkedin
Blog do Nei 