Você já conheceu cada peça do harness. Esta última lição as coloca nas suas mãos: instale-o em dois comandos, veja como cada superfície de IA invoca exatamente o mesmo harness e então acompanhe uma ideia bruta percorrer todo o caminho até um curso publicado — Forge, o loop, uma prova real, o curso, a publicação e o único momento em que ele pausa para te perguntar. O mesmo motor em toda parte; você fica no painel.
Tudo neste curso — o loop, o Portão da Prova, o Forge, a equipe AFK, as ferramentas, o Portão de Publicação — vive dentro de uma única coisa chamada harness: um pequeno conjunto de skills (pastas de instruções) que ficam na sua máquina. Esta lição é o desfecho prático. Primeiro você instala o harness. Depois você percebe que, não importa com qual IA você esteja conversando, está alcançando o mesmo harness por uma porta de entrada diferente. Por fim, você acompanha uma única ideia bruta percorrer todo o caminho até um curso concluído e publicado, e nota o único lugar em que ele para para te fazer uma pergunta.
Três tipos de leitor encontram o harness aqui, e ajuda nomeá-los de antemão. Você, o humano, em geral precisa de uma só coisa: a cola — uma página curta chamada USAGE.md que te lembra como iniciar uma execução e onde acompanhá-la. A IA que você está dirigindo (um LLM) faz o trabalho de fato: lê a skill, roda o loop, obtém uma prova real, constrói o curso e o publica. E os próprios agentes — Claude Code, Codex, Cursor, Gemini e os demais — são intercambiáveis: o harness é byte a byte idêntico em cada um deles, então as mesmas instruções produzem o mesmo comportamento onde quer que rodem.
Esse último ponto é a mágica silenciosa de todo o design, então guarde-o: instale uma vez, comporte-se igual em toda parte. Você não aprende uma ferramenta diferente para cada assistente. Você aprende o harness e, então, pode escolher qualquer IA que estiver à sua frente.
Pense nisso como… um cartão de receita afixado em várias cozinhas diferentes. O cartão é o mesmo em cada cozinha — mesmos passos, mesma linha de chegada. Um cozinheiro prefere fogão a gás, outro uma placa de indução, um terceiro uma fogueira, mas todos seguem o cartão idêntico e servem o mesmo prato. Instalar o harness é afixar esse único cartão em todas as suas cozinhas de uma vez; as IAs são os cozinheiros; você é quem lê o resumo curto na geladeira e prova o resultado.
É um diretório de skills — no mínimo loop-engineering, visual-teach, brightdata-cli e computer-use-cli, além dos auxiliares Forge e fusion. Cada skill é uma pasta contendo um SKILL.md (as instruções) e arquivos de apoio. O Claude Code lê esses arquivos como slash-commands nativos; outros agentes leem o mesmo SKILL.md como contexto puro. Nada é compilado e nada é um serviço — o harness é apenas instruções em disco, que é exatamente o motivo de poder ser idêntico em toda parte.
O passo de instalação copia uma fonte canônica e então a symlinka no diretório de skills de cada agente. Um symlink é um ponteiro, não uma cópia, então todos os doze agentes resolvem para os mesmos bytes. Mude a skill canônica e cada agente vê a mudança de uma vez; não há fork por agente para divergir. A única exceção é o Council, que não consegue seguir symlinks da mesma forma e, em vez disso, usa pequenos arquivos ponteiro .md — abordados na seção de instalação abaixo.
Instalar o harness são genuinamente dois comandos. O primeiro copia as skills para a pasta de skills do seu assistente principal. O segundo roda um pequeno script que espalha essas skills para toda outra IA na sua máquina, de modo que todas compartilhem uma única fonte de verdade. Depois disso, o harness está ativo em toda parte — nenhum serviço para iniciar, nada para manter rodando.
Copie as skills para o seu assistente principal
# from the suite folder, copy every skill into Claude Code's skills dir
cp -R skills/* ~/.claude/skills/
Isso coloca as pastas de skills — loop-engineering, visual-teach, brightdata-cli, computer-use-cli e companhia — onde seu assistente principal procura por elas. Depois desse único passo, esse assistente já tem o harness inteiro.
Espalhe-as para todo outro agente
# symlink the 6 skills into all 12 agents' skill folders
bash install-agent-skills.sh
Este script cria symlinks (ponteiros) da pasta de skills de cada outro agente de volta para a única cópia canônica. O resultado: 6 skills compartilhadas entre 12 agentes, todas apontando para os mesmos bytes. É seguro rodar de novo — ele só adiciona os links que estão faltando.
Dois detalhes arrematam tudo. O Council — o painel de debate multimodelo da lição 8 — não pode ser conectado com o mesmo tipo de symlink, então o script lhe dá pequenos arquivos ponteiro .md no lugar; mesmas skills, alcançadas de um jeito ligeiramente diferente. E, dentro do seu assistente principal, um plugin registra as skills para que apareçam como comandos reais que você pode digitar, como /loop-engineering. Você não configura nada disso à mão — os dois comandos acima ajustam tudo.
Pense nisso como… colocar uma cópia mestra de um documento num drive compartilhado e então soltar atalhos para ela nas áreas de trabalho de doze pessoas. Todos abrem o mesmo arquivo; edite o mestre e cada atalho o reflete instantaneamente. O Council é o único colega cujo computador não consegue criar um atalho, então ele recebe um bilhete adesivo com o endereço do arquivo — que ainda leva ao mesmo documento.
Abra um terminal na pasta raiz da suíte (a que contém o diretório skills/ e o install-agent-skills.sh). Rode os dois comandos em ordem. cp -R skills/* ~/.claude/skills/ copia recursivamente; bash install-agent-skills.sh então cria os symlinks. Rodar o script de novo é idempotente — ele pula links que já existem, então é seguro executá-lo novamente depois de adicionar um novo agente.
Duas checagens rápidas. Liste as skills vinculadas com ls -l ~/.claude/skills/ (você deve ver as pastas) e, no seu assistente, digite / para confirmar que os comandos /loop-engineering e /fusion-* aparecem. Se um agente lê skills de um caminho não padrão, a saída do script informa onde ele vinculou; nada mais precisa ser editado.
Vale ver, numa única imagem, por que isso funciona. Existe exatamente uma cópia das instruções de cada skill. A pasta de skills de cada agente contém um ponteiro para essa única cópia, em vez de sua própria versão. Então, quando uma IA "lê a skill", todas estão lendo as mesmas palavras. Não há passo de tradução nem edição por agente para manter em sincronia — que é precisamente o que te permite tratar os assistentes como intercambiáveis.
O ganho
Aprenda o harness uma vez. Como a instalação aponta cada assistente para as mesmas instruções, o comando que você digita e o comportamento que você obtém são os mesmos no Claude Code, Codex, Cursor, Gemini, Kimi, Grok, Aider, OpenCode, Crush e Goose.
Embora o harness seja idêntico em toda parte, o jeito de iniciá-lo difere um pouco por superfície — porque cada IA tem sua própria porta de entrada. Há três padrões, e essa é a lista inteira. Alguns assistentes te dão slash-commands que você digita. Outros você dirige headless, pela linha de comando, com um prompt. E outros simplesmente leem o arquivo da skill como contexto e agem sobre ele. O mesmo motor nos três; apenas três jeitos de girar a chave.
Padrão A · slash-commands
Você digita um comando e a skill assume. Esta é a porta de entrada mais rica — é onde o loop, o Forge e o painel fusion são comandos de primeira classe.
# drive the whole harness by name
/loop-engineering
/fusion-3
/fusion-opus4.8
Padrão B · prompt headless
Sem menu de barra — você entrega ao assistente um prompt pela linha de comando e ele roda sem supervisão. É assim que o orquestrador delega uma unidade de trabalho a outro modelo durante uma execução AFK.
# run unattended with a prompt cli -p "run /loop-engineering on GOAL.md"
Padrão C · ler SKILL.md
Estes leem o SKILL.md da skill como contexto puro e o seguem. Você os aponta para o arquivo (ou ele já está no caminho de skills deles) e pede que rodem o loop; as instruções fazem o resto.
# the skill is just context they read read SKILL.md → follow the loop
O padrão é uma propriedade do agente, não do harness. O Claude Code tem um sistema de plugins que transforma uma skill num slash-command registrado, então /loop-engineering e o painel /fusion-* aparecem em seu menu. CLIs headless (Codex, Kimi, Grok) expõem uma flag -p/prompt para execuções não interativas — ideal para um orquestrador que cria workers com cli -p "…". Os demais agentes não têm registro de comandos, então consomem o mesmo SKILL.md como contexto comum. Como as instruções subjacentes são idênticas, os três caminhos levam ao mesmo comportamento do loop.
Durante uma execução AFK, o modelo de topo atua como orquestrador e delega unidades delimitadas a outros modelos precisamente pelo Padrão B — cli -p — enquanto o validador (nunca o construtor) checa o resultado. O humano nunca está nesse caminho; ele apenas lê LOOP-LOG.md / review.md para observabilidade, exatamente como ensinado na lição 5 e no fluxo Forge.
Aqui está a ideia tornada tangível. Qualquer que seja a porta de entrada que você use, o que você de fato envia à IA é um pequeno prompt estruturado — algumas escolhas montadas em instruções. Abaixo há um ajustador ao vivo: gire os botões à esquerda (qual agente, quanto ele roda por conta própria, o que deve produzir, se deve publicar) e veja o prompt exato que o harness carregaria se remontar à direita. O ponto a sentir é que a mesma instrução montada funciona de forma idêntica, não importa qual assistente a receba.
Este é também um pequeno modelo fiel de como o harness pensa: suas escolhas são entradas, um montador as transforma numa única instrução, e a instrução é o que viaja. Mude um botão, veja precisamente as palavras que se movem.
Cada controle escreve num objeto state compartilhado (agent, autonomy, goal, publish) e chama render(). A prévia é o que buildParts(state) retorna — nada escreve nela diretamente. Como o montador é puro (mesmo state na entrada, mesma string na saída), a instrução é reproduzível, e apenas a linha que você mudou pisca. Troque agent e note que a linha de comando do harness permanece idêntica: isso é "instale uma vez, comporte-se igual em toda parte" em miniatura.
O agente usa toggles reais <button aria-pressed>; a autonomia é um <input type="range"> nativo com aria-describedby em sua leitura; a prévia é uma região aria-live="polite" para que um leitor de tela anuncie cada remontagem sem roubar o foco. O texto livre é escapado antes de tocar o DOM.
Agora tudo em movimento. Você começa com uma ideia bruta — pouco mais que uma frase. O harness a transforma em algo entregável por meio de uma sequência fixa de batidas, e o humano observa do painel em vez de conduzir cada turno. Aqui está a jornada, de cima a baixo.
Pense nisso como… deixar um briefing vago numa oficina e voltar para um produto pronto e embalado. A oficina tem um processo permanente — esclarecer o briefing, fazer o trabalho em pequenas passagens checadas, testá-lo de verdade, escrever o manual, entregá-lo — e uma recepção que só te chama quando uma decisão genuína precisa da sua assinatura. Você não opera as máquinas; você lê o quadro de progresso e aprova a única coisa que só você pode.
Início
Uma ideia bruta
Você entrega uma frase solta — "ensinar minha equipe como o harness funciona", digamos. Vago tudo bem; afiá-la é tarefa da próxima batida.
Forge
Ideia → escopo mensurável
Como a ideia é crua, o front-end Forge roda primeiro: ele grelha a ideia, opcionalmente pesquisa, então escreve um GOAL.md com um done-when que um verificador poderia checar, e quebra o trabalho em issues. Nenhum trabalho começa enquanto "pronto" não for mensurável.
Loop
Uma unidade delimitada por passo
O loop assume: learn → analyze → execute one unit → verify → improve, repetindo. Cada passagem muda exatamente uma coisa e é pequena o suficiente para checar. O orquestrador pode delegar unidades a outros modelos de forma headless.
Prova
Verificar no limite real
Toda passagem termina no Portão da Prova: a checagem roda contra a coisa real — o teste de fato executa, a página de fato carrega — nunca uma alegação ou um mock. Se falhar, o loop continua; ele não pode declarar sucesso sobre um palpite.
Curso
Transformar o resultado num curso
Quando o objetivo converge, o visual-teach constrói um curso autocontido explicando o que foi feito — multilição, bonito e bilíngue (EN + PT-BR), exatamente como a página que você está lendo.
Publicação
Entregá-lo e reportar a URL
O Portão de Publicação envia o curso concluído para um gist privado (secreto) e reporta o link de volta. O course/ do repositório permanece a casa canônica; o gist é uma cópia plana e compartilhável.
O Forge é o front-end de 7 passos (grill → research → prototype → to-prd → issues + GOAL.md → implement → review) abordado na lição 4. O loop e seu ciclo learn/analyze/execute/verify/improve são as lições 2 e 3; a regra do Portão da Prova de "limite real, nunca uma alegação" é a espinha da lição 3. O motor do curso é o visual-teach (lição 10), e o Portão de Publicação (lição 11) roda publish-course-gist.js para achatar a árvore, reescrever os links internos e gh gist create um gist secreto.
Nada operacional. Tudo roda AFK; o humano tem apenas observabilidade — ele lê LOOP-LOG.md, review.md e o status. Até o QA é um agente (e nunca o mesmo agente que construiu a unidade). A única vez em que a execução recorre ao humano é uma bifurcação deliberada, que é a próxima seção.
Uma execução tão autônoma precisa de exatamente uma saída de emergência: um momento em que só um humano pode decidir. O harness chama isso de handoff. É raro e é específico — a execução chega a uma bifurcação genuína que ela não está autorizada a resolver (uma ação destrutiva, uma questão de escopo, uma decisão que precisa do seu julgamento), então ela para, anota tudo o que é preciso para decidir e espera. Ela não adivinha passando por cima de você, e não te importuna por trabalho rotineiro.
Crucialmente, o handoff é pronto para decisão. Quando ele pausa, te entrega um resumo organizado — o que está pronto, o que está bloqueado, as opções e sua própria recomendação — para que você responda num só movimento e o deixe seguir. Nunca te pedem para operar a maquinaria; pedem, uma vez, que você tome a decisão humana.
Pense nisso como… um empreiteiro de confiança reformando sua cozinha enquanto você está no trabalho. Ele cuida de tudo o que está no plano sem ligar. Mas se abrir uma parede e encontrar um cano que não estava nas plantas, ele para, fotografa, apresenta duas opções com uma recomendação e te manda mensagem — porque mover uma tubulação de água é decisão sua, não dele. Uma pergunta clara, e de volta ao trabalho.
Para toda a maquinaria por baixo, a superfície do humano é pequena de propósito. Há uma página curta chamada USAGE.md — a cola — que te diz o punhado de coisas que você de fato faz: como disparar uma execução, onde acompanhá-la e como ler o resultado. Essa é a interface humana inteira. Você não memoriza o loop; você lê isto e deixa o harness fazer o resto.
# 1 · install once (per machine) cp -R skills/* ~/.claude/skills/ bash install-agent-skills.sh # 2 · start a run from a rough idea (raw idea → Forge runs first) /loop-engineering # in Claude Code, or: cli -p "run /loop-engineering" # 3 · watch from the dashboard (you never operate, only observe) cat LOOP-LOG.md # progress, pass by pass cat review.md # the QA agent's observability report # 4 · collect the result # the run reports the private gist URL of the finished course
O USAGE.md fica na raiz da suíte ao lado de install-agent-skills.sh; abra-o com cat USAGE.md ou qualquer visualizador. Inicie uma execução invocando /loop-engineering no Claude Code, ou de forma headless com cli -p "run /loop-engineering on GOAL.md" para os agentes de CLI. Enquanto roda, os únicos arquivos de que você precisa são os logs ao vivo — LOOP-LOG.md para o progresso passagem a passagem e review.md para o relatório do agente de QA. Você não opera mais nada; esse é o design.
Humanos leem esta cola e aprovam o raro handoff. O LLM dirige a execução e entrega o resultado, o curso e a URL publicada. Os agentes são intercambiáveis porque o harness é idêntico em cada um deles — que é toda a razão pela qual uma única cola funciona, não importa qual assistente você abriu.
Três perguntas rápidas para fixar a lição. Escolha uma resposta em cada; você receberá feedback instantâneo e um breve porquê.
Q1O que bash install-agent-skills.sh faz depois do passo de cópia?
Q2Você está trabalhando no Cursor, não no Claude Code. Como ele invoca o harness?
Q3Durante uma execução AFK, quando o harness para para envolver o humano?
/loop-engineering real sobre uma pequena ideia sua, acompanhe o LOOP-LOG.md enquanto ele avança e leia o curso que ele publica no fim. Essa é a loop engineering suite, nas suas mãos.