Como construir seu primeiro loop de IA em 2026

Dois dos engenheiros de IA mais experientes do mundo disseram a mesma coisa no mês passado.

Peter Steinberger, criador do OpenClaw, agora na OpenAI:

"Você não deveria mais dar comandos para agentes de codificação. Você deveria estar projetando loops que dão comandos para seus agentes."

Boris Cherny, chefe do Claude Code na Anthropic:

"Eu não dou mais comandos para o Claude. Eu tenho loops rodando que dão comandos para o Claude e decidem o que fazer. Meu trabalho é escrever loops."

A maioria das pessoas leu isso e pensou: o que isso realmente significa?

E mais importante: como eu construo um?

Este artigo te diz exatamente como.

Sem teoria sem código. Sem código sem contexto. Passos reais. Comandos reais. Copie e execute.

Slate orquestrando GPT-5.6, Claude e subagentes especializados em uma tarefa de migração real. O modelo ficou mais inteligente. A mudança maior é que ferramentas como o Slate podem finalmente manter esses modelos ocupados continuamente, em vez de esperar por comandos humanos.

A forma como a maioria das pessoas usa IA já está ultrapassada

Escreva o comando. Espere. Leia a saída. Corrija manualmente. Escreva outro comando.

Você é o loop.

Cada etapa passa por você. A IA espera. Você decide. A IA espera de novo.

No momento em que você para, tudo para.

Os construtores que estão se movendo mais rápido em 2026 não estão escrevendo comandos melhores.

Eles estão construindo sistemas que fazem os comandos por eles.

O ponto de alavancagem mudou.

De digitar comandos → para projetar loops.

O que mudou com o GPT-5.6?

O GPT-5.6 não muda a necessidade de loops.

Ele aumenta o valor deles.

Quanto melhor o modelo fica, mais caro se torna deixá-lo ocioso entre os comandos.

Em fluxos de trabalho de terminal, o GPT-5.6 é visivelmente melhor em:

→ entender grandes bases de código

→ manter a consistência da implementação

→ seguir planos de várias etapas

→ se recuperar de tentativas fracassadas

→ atuar como um verificador rigoroso

O resultado não é "comandos melhores".

São menos intervenções humanas por tarefa.

O que realmente é um loop

Definição simples:

Um comando responde uma vez e para.

Um loop continua trabalhando até que o trabalho esteja realmente concluído.

Não até gerar uma resposta.

Até atingir um resultado verificado.

Todo agente de IA sério executa o mesmo ciclo subjacente:

→ Descobrir — o que precisa ser feito?

→ Executar — faça o trabalho

→ Verificar — funcionou mesmo?

→ Iterar — não terminou? corrija e repita

→ Parar — condição atendida, ou limite máximo atingido

Claude Code. Cursor. Codex.

Por baixo, todos executam esse loop.

A diferença entre um comando e um loop não é o modelo.

É se algo verifica o trabalho e continua até que ele passe.

O teste das 4 condições — execute isso antes de construir qualquer coisa

A maioria dos loops falha aqui.

Um loop só vale o custo de configuração quando todas as 4 condições são verdadeiras.

Se uma falhar, o loop custa mais do que retorna.

1. A tarefa se repete. Pelo menos semanalmente. Uma tarefa única ainda é melhor atendida por um bom comando.

2. A verificação é automatizada. Algo deve reprovar o trabalho sem você na sala. Testes. Linters. Builds. Verificações de tipo. Sem barreira = o agente está corrigindo a própria lição de casa.

3. Seu orçamento de tokens pode absorver o desperdício. Loops releem o contexto completo a cada iteração. Eles tentam novamente, exploram, queimam tokens quer a execução entregue algo ou não. Este é o custo que ninguém menciona.

4. "Pronto" é objetivo. Um teste que passa ou falha. Um build que compila ou não. Não "quando parece bom". Se "pronto" requer uma opinião humana, mantenha-o manual.

Passe em todos os 4 → construa o loop.

Falhe em qualquer 1 → use um comando.

A versão honesta: a maioria dos desenvolvedores ainda não precisa de loops pesados. O que todos podem usar é um loop simples. Construiremos um em breve.

Instale o Slate

Slate é um agente de codificação de IA construído exatamente para isso — executar tarefas longas, paralelas e de várias etapas no seu terminal.

Construído pela RandomLabs. O primeiro agente construído especificamente para orquestração de enxame.

O que o torna diferente do Claude Code ou Cursor:

→ Seleciona automaticamente o modelo certo para cada etapa. Planeje com Claude, pesquise com outro, execute com Codex — o Slate decide.

→ Executa subagentes paralelos simultaneamente em sua base de código

→ Gerencia seu próprio contexto em longas sessões de várias horas

→ Trabalha junto com você — não apenas para você

Instale em uma linha:

1npm i -g @randomlabs/slate

Navegue até seu projeto e inicie:

1cd /caminho/para/seu/projeto
2slate

Isso abre a TUI do Slate — uma interface de terminal onde você dá tarefas a ele e o vê trabalhar.

Passo 1 — Configure seu espaço de trabalho

Antes que o Slate possa executar loops em seu projeto, ele precisa entender sua base de código.

Crie um arquivo AGENTS.md na raiz do seu projeto. Este é o contexto que o Slate lê no início de cada sessão.

1# AGENTS.md
2
3## O que esta base de código faz
4[Descrição de um parágrafo do projeto]
5
6## Arquitetura
7- src/api/ — Rotas da API Express
8- src/services/ — Lógica de negócios
9- src/db/ — Modelos de banco de dados (PostgreSQL via Prisma)
10- tests/ — Suíte de testes Jest
11
12## Comandos principais
13- npm test — executar a suíte de testes completa
14- npm run build — compilar TypeScript
15- npm run lint — verificação ESLint
16- npm run typecheck — tsc --noEmit
17
18## Regras
19- Nunca modificar src/billing/ ou src/auth/ sem aprovação humana
20- Sempre executar testes antes de marcar qualquer tarefa como concluída
21- Usar o padrão de tratamento de erros existente em src/utils/errors.ts
22
23## Ambiente
24- .env.slate contém todas as variáveis de ambiente que o Slate precisa

O Slate lê este arquivo automaticamente na inicialização — sem necessidade de colá-lo a cada sessão.

Adicione seus diretórios de trabalho dentro do Slate:

1/workspace add ./src
2/workspace add ./tests
3/workspace list

Ou referencie arquivos específicos inline usando menções @:

1Por favor, revise @src/api/routes.ts e sugira melhorias

Passo 2 — Configure o Slate

Crie slate.json na raiz do seu projeto para controlar como o Slate se comporta.

1{
2  "$schema": "https://randomlabs.ai/config.json",
3  "permission": {
4    "*": "allow",
5    "bash": "ask"
6  },
7  "models": {
8    "main": { "default": "anthropic/claude-opus-4.6" },
9    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
10    "search": { "default": "anthropic/claude-haiku-4.5" },
11    "reasoning": { "default": "openai/gpt-5.6" }
12  }
13}

O que isso faz:

→ "*": "allow" — Slate pode ler e escrever arquivos sem perguntar a cada vez

→ "bash": "ask" — Slate pergunta antes de executar comandos shell (mantenha isso ativado até você confiar nele)

→ Config de modelos — modelo barato e rápido para pesquisa, modelo caro para raciocínio principal

Para execuções de CI ou automação onde você quer zero prompts:

1slate run "Execute a suíte de testes e corrija quaisquer falhas" --dangerously-skip-permissions --output-format stream-json

Passo 3 — Sua primeira tarefa (ainda não é um loop)

Antes de construir um loop, torne uma única execução manual confiável.

Esta é a etapa mais ignorada. E a razão pela qual a maioria dos loops falha em produção.

Dê ao Slate uma tarefa real:

1Por favor, revise a arquitetura de toda a minha base de código.
2Crie um ARCH.md com:
3- estrutura atual
4- dependências entre módulos
5- 3 coisas para melhorar
6Olhe em @src/ primeiro, depois em @tests/

Observe o Slate trabalhar. Ele irá:

1. Pesquisar seus arquivos
2. Construir entendimento da arquitetura
3. Rascunhar o ARCH.md
4. Revisá-lo em relação à sua solicitação antes de parar

Isso já é um mini-loop — ele verifica sua própria saída antes de terminar.

Para uma tarefa mais longa:

1Ei Slate, pesquise minha base de código para o fluxo de autenticação,
2depois faça um plano para adicionar suporte OAuth2.
3Certifique-se de olhar em @src/auth/ e @src/api/routes.ts

O Slate retorna um plano. Você itera sobre ele:

1Não, não adicione uma nova classe de provedor de autenticação.
2Faça com que siga o mesmo padrão do ApiKeyAuth existente em src/auth/api-key.ts

Aprove o plano. O Slate executa autonomamente.

Passo 4 — Crie uma Skill (torne o loop reutilizável)

Uma Skill é como você para de reexplicar seu projeto a cada sessão.

Escreva uma vez. O Slate a lê em toda execução relevante.

Crie a estrutura de pastas:

1mkdir -p .slate/skills/ci-triage
2touch .slate/skills/ci-triage/SKILL.md

Escreva a skill:

1---
2name: "ci-triage"
3description: "Classificar falhas de CI por causa raiz e rascunhar correções para as fáceis."
4---
5
6# Skill de Triagem de CI
7
8## O que eu faço
9Quando uma execução de CI falha, eu:
101. Leio a saída do teste
112. Classifico a falha: problema de ambiente / teste instável / bug real / atualização de dependência / infra
123. Rascunho correções para bugs e problemas de dependência
134. Escalo problemas de ambiente e infra para humanos
14
15## Regras de classificação
16- ambiente: segredo ausente, variável de ambiente errada → sinalizar para humano
17- instável: passa na repetição sem alteração de código → repetir uma vez, depois abrir issue
18- bug: falha determinística ligada a um commit recente → rascunhar correção
19- dependência: falha ligada a atualização de versão → rascunhar PR de reversão
20- infra: timeout, OOM, problema no executor → escalar imediatamente
21
22## Padrões de correção
23- Falhas em testes de autenticação → verificar src/auth/middleware.ts primeiro
24- Falhas em testes de banco de dados → verificar se a migração foi executada no ambiente de CI
25- Falhas em testes E2E → verificar seletores de UI contra o snapshot mais recente
26
27## Nunca fazer
28- Desabilitar testes com falha
29- Modificar a config de CI sem perguntar
30- Tocar em src/billing/ ou src/payments/
31
32## Estado
33Atualizar STATE.md após cada execução:
34- Arquivos verificados
35- Classificações feitas
36- PRs abertos
37- Itens escalados

Liste as skills disponíveis dentro do Slate:

1/skills

Ative uma manualmente:

1@ci-triage, por favor, faça a triagem dos testes com falha de hoje

Ou o Slate ativa skills automaticamente quando decide que são relevantes para a tarefa atual.

Passo 5 — Adicione estado (a memória do loop)

O agente esquece.

O arquivo não.

Crie STATE.md na raiz do seu projeto:

1# Estado do Loop — Triagem de CI
2
3## Última execução
42026-06-28 03:30 UTC — 7 falhas classificadas, 3 correções rascunhadas, 4 escaladas
5
6## Em andamento
7- claude/fix-auth-token-refresh — testes passando localmente, aguardando CI
8- claude/fix-flaky-payment-webhook — padrão de repetição aplicado, monitorando
9
10## Concluído
11- claude/bump-axios-1.7.4 → mesclado (CI verde)
12- claude/lint-fix-pass-june-28 → mesclado
13
14## Escalado para humanos
15- src/billing/refund.ts — testes falhando de 3 maneiras, causa raiz incerta
16- ci/staging-runner — timeouts de infra, não é um problema de código
17
18## Lições aprendidas
19- 2026-06-27: PowerShell encontra problema de TLS 1.2 neste executor Windows. Use bash.
20- 2026-06-26: tests/e2e/checkout requer segredo do webhook do Stripe no env. Pule se ausente.

Diga ao Slate para usá-lo no início de cada sessão, adicionando ao AGENTS.md:

1## Início da sessão
2Sempre leia STATE.md primeiro. Continue de onde a última execução parou.
3Atualize STATE.md ao final de cada execução com o que foi feito e o que vem a seguir.

Sem estado: toda execução começa do zero.

Com estado: toda execução retoma e acumula sobre a última.

Passo 6 — Construa o loop real

Agora você tem:

→ Espaço de trabalho configurado (AGENTS.md)

→ Config definida (slate.json)

→ Uma execução manual confiável comprovada

→ Uma skill escrita (ci-triage)

→ Arquivo de estado criado (STATE.md)

Hora de transformar isso em um loop real.

Opção A: Loop de arquivo de fila (mais simples)

Crie loop.md:

1Leia STATE.md para entender o que já foi tentado.
2
3Execute a skill de triagem de CI em todos os testes com falha no último build.
4
5Para cada falha:
6- Classifique-a usando as regras da skill ci-triage
7- Rascunhe uma correção para bugs e problemas de dependência
8- Escale problemas de ambiente e infra
9
10Execute as correções. Verifique se os testes passam.
11Se os testes passarem → abra um PR.
12Se os testes ainda falharem → registre em STATE.md e pare.
13
14Limite máximo: 8 tentativas. Ao atingir o limite, relate o estado atual.

Execute:

1slate --queue loop.md

O Slate lê o arquivo de fila e executa cada bloco como uma mensagem na fila.

Opção B: Loop headless/CI (automatizado)

Execute de forma não interativa em uma GitHub Action ou cron job:

1slate run "$(cat loop.md)" --output-format stream-json --dangerously-skip-permissions

Em um fluxo de trabalho do GitHub Actions:

1name: Loop de Triagem de CI
2on:
3  workflow_run:
4    workflows: ["CI"]
5    types: [completed]
6
7jobs:
8  triage:
9    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
10    runs-on: ubuntu-latest
11    steps:
12      - uses: actions/checkout@v4
13
14      - name: Instalar Slate
15        run: npm i -g @randomlabs/slate
16
17      - name: Executar loop de triagem
18        env:
19          SLATE_API_KEY: ${{ secrets.SLATE_API_KEY }}
20        run: |
21          slate run "$(cat loop.md)" \
22            --output-format stream-json \
23            --dangerously-skip-permissions \
24            --workspace ./src \
25            --workspace ./tests

Agora, toda falha de CI aciona automaticamente o loop de triagem.

Nenhum humano necessário até o escalonamento.

Passo 7 — Adicione subagentes (a divisão criador-verificador)

A melhoria estrutural mais importante para qualquer loop.

Nunca deixe o mesmo agente corrigir a própria lição de casa.

O modelo que escreveu a correção é um corretor muito generoso.

No Slate, você pode definir modelos diferentes para funções diferentes:

1{
2  "models": {
3    "main": { "default": "anthropic/claude-opus-4.6" },
4    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
5    "search": { "default": "anthropic/claude-haiku-4.5" }
6  }
7}

Em seguida, escreva sua tarefa para que o Slate use essa divisão naturalmente:

1Por favor, corrija os testes de autenticação com falha.
2
3Passo 1: Faça um agente de pesquisa explorar src/auth/ para entender a implementação atual.
4Passo 2: Faça um agente separado implementar a correção com base no que foi encontrado.
5Passo 3: Faça um terceiro agente verificar a correção em relação aos requisitos originais do teste —
6        este agente NÃO deve ter visto a implementação.
7Passo 4: Só abra o PR se o verificador aprovar.

O Slate orquestra os subagentes automaticamente.

O agente de pesquisa usa um modelo rápido e barato. O agente de implementação usa um modelo mais forte. O verificador usa um modelo rigoroso sem acesso ao raciocínio do criador.

Essa divisão é a razão pela qual o Slate pode executar 5 subagentes paralelos em uma única tarefa — cada um especializado, cada um isolado.

Passo 8 — O padrão de loop de estado (para tarefas de longa duração)

Para tarefas que duram horas ou dias, use este padrão no prompt da sua tarefa:

1Você está executando um loop de várias sessões.
2
3OBJETIVO: Migrar todas as rotas Express para o novo padrão ApiError.
4Acompanhe o progresso em STATE.md.
5
6INÍCIO DE CADA SESSÃO:
71. Leia STATE.md
82. Encontre o primeiro item incompleto em "Rotas restantes"
93. Faça apenas esse item
10
11FIM DE CADA SESSÃO:
121. Mova os itens concluídos para "Rotas concluídas" em STATE.md
132. Registre quaisquer bloqueadores em "Bloqueadores"
143. Atualize o timestamp da "Última execução"
154. Pare de forma limpa
16
17Formato STATE.md:
18---
19## Rotas concluídas
20- [x] /api/users (2026-06-27)
21- [x] /api/auth/login (2026-06-28)
22
23## Rotas restantes
24- [ ] /api/payments/checkout
25- [ ] /api/payments/refund
26- [ ] /api/admin/users
27
28## Bloqueadores
29- /api/payments/refund — requer revisão humana (toca na lógica de faturamento)
30
31## Última execução
322026-06-28 14:30 UTC
33---
34
35REGRAS RÍGIDAS:
36- Nunca toque em src/billing/ sem aprovação humana
37- Sempre execute testes após cada migração de rota
38- Pare após concluir UMA rota por sessão

Execute isso todas as manhãs:

1slate --continue "$(cat loop.md)"

--continue retoma a sessão mais recente em vez de começar do zero.

Cada dia, mais uma rota. STATE.md rastreia tudo.

O loop retoma exatamente de onde parou.

Passo 9 — Comandos personalizados para seus loops mais usados

Adicione comandos de barra personalizados ao slate.json para que seus loops estejam sempre a um toque de distância:

1{
2  "command": {
3    "triage": {
4      "description": "Executar loop de triagem de CI",
5      "template": "Leia STATE.md. Execute a skill ci-triage em todos os testes com falha. Atualize STATE.md quando terminar.",
6      "agent": "build"
7    },
8    "review": {
9      "description": "Revisar um arquivo quanto à correção",
10      "template": "Revise @$ARGUMENTS quanto à correção, casos de borda e consistência com o código ao redor."
11    },
12    "migrate": {
13      "description": "Migrar uma rota para o padrão ApiError",
14      "template": "Leia STATE.md. Migre a próxima rota incompleta para o padrão ApiError. Execute os testes. Atualize STATE.md."
15    }
16  }
17}

Agora dentro do Slate:

1/triage
2/review src/api/payments.ts
3/migrate

Cada um executa seu prompt de loop pré-escrito instantaneamente.

3 loops completos que você pode executar hoje

Loop 1: Triagem de falhas de CI (o que construímos)

Quando: toda falha de CI O que: classificar → corrigir as fáceis → escalar as difíceis → abrir PRs Estado: STATE.md Portão: testes passam Tempo de configuração: 30 minutos

1# gatilho
2slate run "$(cat loop.md)" --dangerously-skip-permissions --output-format stream-json
3
4# ou em GitHub Actions — veja o Passo 6 acima

Loop 2: Briefing matinal

Quando: 7h todos os dias úteis (cron job) O que: escanear últimos 24h de commits, PRs e issues abertas → escrever um briefing de 5 tópicos → postar no Slack

1# loop.md para briefing matinal
2cat > morning-brief-loop.md << 'EOF'
3Leia as últimas 24 horas de:
4- git log --since="24 hours ago" --oneline
5- PRs abertos em rascunho ou revisão
6- GitHub Issues abertas ou atualizadas nas últimas 24h
7
8Escreva um briefing matinal:
9- 3 coisas mais importantes que aconteceram
10- 2 coisas que precisam de atenção hoje
11- 1 coisa em risco de bloquear alguém
12
13Mantenha abaixo de 120 palavras. Poste no canal de engenharia do Slack.
14EOF
15
16# execute em um agendamento com cron
170 7 * * 1-5 slate run "$(cat morning-brief-loop.md)" --dangerously-skip-permissions

Loop 3: Loop de atualização de dependências

Quando: toda segunda-feira O que: escanear pacotes desatualizados → testar compatibilidade → abrir PRs para atualizações seguras

1cat > deps-loop.md << 'EOF'
2Leia STATE.md.
3
4Execute: npm outdated
5
6Para cada pacote desatualizado:
71. Verifique se a atualização de versão é major (quebra) ou minor/patch (segura)
82. Para minor/patch: atualize o pacote, execute npm test
93. Se os testes passarem: abra um PR
104. Se os testes falharem: registre em STATE.md como "precisa de revisão humana"
115. Para atualizações major: sempre escale para humanos
12
13Regras rígidas:
14- Nunca atualize mais de 5 pacotes em um único loop
15- Nunca atualize pacotes na seção "peer dependencies"
16- Sempre execute a suíte de testes completa após cada atualização, não apenas os testes relacionados
17
18Atualize STATE.md com o que foi atualizado e o que foi escalado.
19EOF
20
21# execute toda segunda-feira
220 9 * * 1 slate run "$(cat deps-loop.md)" --dangerously-skip-permissions

Os modos de falha que custam dinheiro

Conheça estes antes de agendar qualquer coisa.

O Loop Ralph Wiggum

O agente declara concluído um trabalho meio feito.

Sai cedo. O loop continua gastando. Silenciosamente.

Correção: condição de parada rígida verificada por um modelo novo.

1CONDIÇÃO DE PARADA: Todos os testes em tests/auth/ passam E lint retorna 0.
2Verifique usando uma execução de verificação separada, não o julgamento do próprio agente.
3Limite máximo: 8 iterações. Ao atingir o limite: relate o estado e pare.

Desvio de objetivo

Em sessões longas, as restrições iniciais desaparecem.

"Nunca toque em src/billing/" da mensagem 3 se foi na mensagem 47.

Correção: adicione um VISION.md que o Slate releia no início de cada sessão.

1# VISION.md — Leia no início de cada sessão
2
3## Objetivo principal
4Migrar todas as rotas Express para o padrão ApiError.
5
6## Restrições rígidas (nunca violar)
7- Nunca toque em src/billing/ sem aprovação humana
8- Nunca desabilite testes com falha
9- Sempre execute a suíte de testes completa antes de abrir qualquer PR
10
11## Prioridade atual
12Rotas em src/api/payments/ — trate com cuidado extra

Viés autopreferencial

O criador corrige a própria lição de casa. Sempre se dá uma nota de aprovação.

Correção: subagente verificador com zero acesso ao raciocínio do criador.

Diga ao Slate explicitamente:

1O agente verificador NÃO deve ver o trabalho do agente de implementação.
2Ele deve ver apenas: os requisitos originais do teste e a saída do teste.
3Se os testes passarem → aprove. Se os testes falharem → rejeite. Nenhuma opinião contrária.

Preguiça agentiva

O loop chama uma tarefa de "boa o suficiente" na conclusão parcial.

Especialmente em critérios de sucesso vagos.

Correção: condição de parada objetiva apenas.

1CONCLUÍDO QUANDO: npm test retorna código de saída 0 E npm run lint retorna código de saída 0.
2Não quando "os testes parecem bons." Não quando "a maioria dos testes passa."
3Código de saída 0 em ambos os comandos. Essa é a única conclusão.

Os truques específicos do Slate que importam

Algumas coisas que tornam o Slate diferente de outros agentes na prática.

Enfileirando mensagens enquanto ele trabalha

O Slate está executando uma tarefa longa. Você pensa em algo importante.

Pressione Tab para enfileirar a mensagem — ela é executada após a tarefa atual terminar, sem interrompê-la.

1[Slate está trabalhando na tarefa de migração...]
2
3Você: Na verdade, certifique-se de que o novo padrão também lida com o caso em que userId é nulo
4[Tab — enfileirado]
5
6[Slate termina a etapa atual, depois lê sua mensagem enfileirada]

Direcionando durante a execução

Se o Slate estiver indo na direção errada, você não precisa pará-lo:

1[Slate está no meio da implementação da correção...]
2
3Você: Espere — não adicione uma nova classe para isso. Use o BaseError existente em src/utils/errors.ts
4[Enter — direciona imediatamente]
5
6Slate: Entendido, mudando a abordagem para usar BaseError...

Use /enter-mode-next para alternar entre os modos direcionar / enfileirar / interromper.

Comandos shell diretamente

Execute comandos dentro da sessão do Slate sem alternar para outro terminal:

1!npm test          # executar testes e enviar saída para o Slate
2!git diff HEAD     # verificar o que mudou
3!git status        # ver estado atual

O Slate lê a saída e a usa em sua próxima ação.

Modo servidor para configurações de equipe

Execute o Slate como um servidor e conecte-se a ele de vários terminais:

1# Terminal 1 — iniciar servidor
2slate serve --port 7777
3
4# Terminal 2 — conectar TUI
5slate attach http://localhost:7777 --dir /caminho/para/projeto

Útil para programação em par com o Slate ou executá-lo em uma máquina remota.

A lista de verificação de configuração completa

Antes de executar seu primeiro loop real:

1□ npm i -g @randomlabs/slate instalado
2□ AGENTS.md criado com visão geral do projeto, comandos, regras
3□ slate.json criado com permissões e configuração de modelo
4□ Uma execução manual concluída e verificada como confiável
5□ SKILL.md escrita para sua primeira tarefa repetida
6□ STATE.md criado e referenciado em AGENTS.md
7□ loop.md escrito com condição de parada explícita
8□ Limite máximo de iterações (8 no máximo para começar)
9□ Verificador NÃO é o mesmo agente que o criador
10□ Portão de revisão humana em qualquer ação irreversível (PRs, deploys)

Marque cada caixa antes de agendar qualquer coisa.

Pule uma e o loop ou falha silenciosamente ou te cobra por nada.

Para mais inspiração de loops

Depois que você entende o padrão, o gargalo muda de "como eu construo um loop" para "qual loop devo construir em seguida."

A Forward Future Loop Library em signals.forwardfuture.com/loop-library é um ótimo lugar para navegar por loops reais em funcionamento em diversas categorias — conteúdo, engenharia, operações, pesquisa.

Quando você vê 20 loops funcionando em um só lugar, você para de pensar em prompts avulsos.

A verdade desconfortável

Dois construtores podem executar exatamente o mesmo loop e obter resultados opostos.

Um o usa para acelerar o trabalho que já entende profundamente.

O outro o usa para evitar entender o trabalho por completo.

O loop não sabe a diferença.

Você sabe.

Projetar loops é mais difícil do que engenharia de prompt — não mais fácil.

A questão não é que o trabalho ficou mais fácil.

O ponto de alavancagem mudou.

Construa o loop.

Mas construa-o como alguém que pretende continuar sendo o engenheiro.

Não apenas a pessoa que aperta o play.

E o novo GPT-5.6 não substitui esse princípio. Na verdade, ele o reforça.

A fronteira não é mais quem escreve o prompt mais inteligente.

É quem projeta os melhores sistemas em torno de modelos cada vez mais capazes.

O resumo de 60 segundos

O que é um loop:

→ Prompt = pergunta. Loop = trabalho.

→ Descobrir → Executar → Verificar → Iterar → Parar

O teste das 4 condições:

→ Tarefa se repete / Verificação automatizada / Orçamento absorve desperdício / "Pronto" é objetivo

As 5 etapas de configuração:

→ AGENTS.md → slate.json → uma execução manual → SKILL.md → STATE.md

Depois, empacote:

→ loop.md arquivo de fila OU execução headless do slate no CI

Os modos de falha:

→ Ralph Wiggum (sai cedo) / Desvio de objetivo (esquece restrições) / Viés autopreferencial (criador = verificador) / Preguiça agentiva (já está bom)

A vantagem do Slate:

→ Seleção automática de modelo por etapa → Subagentes paralelos com isolamento → Gerenciamento de sessões longas → Seu loop, seu design

Se isso foi útil:

→ Compartilhe com todo construtor que você conhece

→ Siga @sairahul1 para mais sistemas como este

→ Salve nos favoritos — só a lista de verificação de configuração já vale a pena

Inscreva-se em theaibuilders.co para mais artigos interessantes como este

Eu escrevo sobre IA, construção de produtos e sistemas que funcionam enquanto você dorme.

Ferramentas mencionadas:

→ Documentação do Slate: docs.randomlabs.ai

→ Forward Future Loop Library: signals.forwardfuture.com/loop-library