---
title: "O que aprendemos construindo uma fábrica de software com IA"
description: "A fábrica de software com IA do Foxl, com 15 a 20 sessões do Claude Code: como o trabalho delas é verificado e por que as regras só valeram quando impostas."
author: "Foxl Team"
date_published: "2026-11-12"
date_modified: "2026-11-13"
canonical_url: "https://foxl.ai/pt/blog/ai-factory"
markdown_url: "https://foxl.ai/pt/blog/ai-factory/index.md"
image: "https://foxl.ai/blog/ai-factory-cover.png"
social_image: "https://foxl.ai/blog/social/ai-factory.png"
content_type: "Deep dive"
topics: ["Coding agents","Multi-agent","Claude Code","Continuous integration","Verification","Release engineering"]
products: ["Foxl Code","Foxl Agent"]
---

<!-- Generated by scripts/blog-publishing.mjs; do not edit. -->

# O que aprendemos construindo uma fábrica de software com IA

> A equipe do Foxl lança dezenas de versões por mês a partir de uma fábrica de software com IA em que 15 a 20 agentes de programação trabalham ao mesmo tempo. Escrever o código foi a parte fácil; saber se ele estava certo foi bem mais difícil. Isto é o que aprendemos construindo as verificações.

- Author: Foxl Team
- Published: 2026-11-12
- Updated: 2026-11-13
- Reading time: 20 minutes
- Canonical HTML: [https://foxl.ai/pt/blog/ai-factory](<https://foxl.ai/pt/blog/ai-factory>)

![Uma caixa de papelão desenhada à mão, com as quatro abas abertas e um grande sinal de visto na lateral; a caixa passou na verificação e não tem nada dentro.](<https://foxl.ai/blog/ai-factory-cover.png>)

A equipe do Foxl lança dezenas de versões por mês. Em outubro foram 66: 22 estáveis e 44 beta. Toda versão leva o app de desktop para Windows, macOS e Linux, e toda versão estável leva também os apps de iOS e Android e o app web. A cada vez, é preciso verificar que tudo isso funciona.

No mesmo mês, foram abertos 2.140 pull requests no nosso repositório e 2.040 foram mesclados, quase 70 abertos por dia. A maior parte desse código não foi escrita por pessoas, e sim por agentes de programação: 15 a 20 sessões do Claude Code rodando ao mesmo tempo em um Mac, cada uma no seu próprio branch. O gráfico de contribuições da conta do GitHub com que essas sessões fazem commit mostra a mudança de relance. Em cada um dos dois anos anteriores, ele somou algumas centenas de contribuições. Neste ano, passa de 30.000.

![O gráfico de contribuições de 2026 de um perfil do GitHub a partir do fim de março, com o título 33,951 contributions in 2026: de abril a agosto a maioria dos dias são quadrados verde-claros, e do fim de setembro até novembro os quadrados verde-escuros se acumulam.](<https://foxl.ai/blog/ai-factory-contributions.webp>)

O desenvolvimento em que os agentes planejam o trabalho, escrevem o código, testam e revisam passou a ser chamado de fábrica de software com IA. As pessoas decidem o que construir e dão a palavra final sobre o que vai ao ar. A nossa funciona assim. Mas, quando passamos o código para os agentes em março, a parte difícil acabou não sendo escrevê-lo. Era saber se o código que os agentes escreviam estava mesmo certo, e se ele aguentava nas cinco plataformas.

Este post é o que aprendemos construindo as verificações para isso. Resumindo: **toda regra que só deixamos por escrito para os agentes foi quebrada.** A maioria durou poucos dias. O que se sustentou foram verificações colocadas exatamente no caminho por onde um erro tinha entrado, e o erro seguinte quase sempre entrava por um caminho que ainda não tinha nenhuma.

## De uma sessão para vinte

Nos primeiros quatro meses, deixávamos uma sessão aberta o dia inteiro, e uma pessoa lia cada diff assim que ele aparecia. Quase tudo ia direto para a main; o repositório tem um único pull request em todo o mês de junho. O limite era a atenção humana. Uma sessão era mais ou menos tudo o que alguém conseguia acompanhar direito.

Em julho, apontamos o [Foxl Code](<https://foxl.ai/pt/code>), nosso agente de programação na nuvem, para o próprio repositório do Foxl. Cada tarefa ganhava sua própria VM na nuvem, e em 22 de julho essa configuração entregou [cinco versões em produção em um dia](<https://foxl.ai/blog/five-releases-one-day>). Só que essas VMs não têm macOS, então tudo o que precisava de Xcode ou do simulador de iPhone ainda tinha que voltar para o Mac.

Em agosto, mudamos o jeito de trabalhar: um git worktree por sessão e um pull request por mudança. As sessões pararam de sobrescrever o trabalho umas das outras, então várias podiam rodar ao mesmo tempo, e os pull requests passaram de 598 em agosto para 946 em setembro e 2.140 em outubro.

![Commits na main por mês em 2026: entre 260 e 435 por mês de março a julho, 1.204 em agosto, quando o trabalho passou para pull requests, 1.985 em setembro, quando começaram os merge trains, 6.400 em outubro, depois que uma sessão coordenadora assumiu, e 4.969 nos primeiros onze dias de novembro. Notas ao lado das barras também marcam as cinco versões de 22 de julho e a falta de memória de 2 de novembro.](<https://foxl.ai/blog/ai-factory-throughput-pt.png>)

Conforme os números cresciam, apareceram problemas novos. As sessões editavam os mesmos arquivos ao mesmo tempo, e faltava memória no Mac. Acima de tudo, o primeiro merge train, em 24 de setembro, mostrou que uma CI verde não significa que um pull request está certo. Voltamos a isso mais abaixo.

## Onde dá para verificar decide onde trabalhamos

Verificar cinco plataformas começa por ter máquinas que consigam rodá-las. Usamos três tipos, e cada um consegue verificar coisas diferentes.

![Uma matriz de seis tipos de verificação contra três máquinas. As três rodam testes unitários e builds web. Só a lane box roda o app de desktop num Windows ou Linux recém-instalado. A lane box e o Mac rodam um emulador de Android. Só o Mac tem Xcode, o simulador de iPhone e o app de desktop no macOS com um navegador de verdade. Só a VM na nuvem pode ser iniciada pelo celular.](<https://foxl.ai/blog/ai-factory-machines-pt.png>)

As VMs na nuvem são boas para trabalho isolado em Linux, e dá para iniciá-las direto pelo celular. Quando uma sessão precisa do app de desktop num Windows ou Linux recém-instalado, ou de um emulador de Android, ela ganha uma instância EC2 descartável que chamamos de lane box. E só o Mac consegue verificar todo o resto: Xcode, o simulador de iPhone, um Chrome de verdade e o app de desktop no macOS.

Por isso a maioria das sessões acabou num único Mac. Ele também é um computador que usamos todo dia, o que significa que todas as sessões dividem a memória de uma única máquina e trabalham bem ao lado de dados reais.

## Iniciar agentes é a parte resolvida

Não faltam ferramentas para rodar muitos agentes ao mesmo tempo. Todas as que olhamos facilitam as execuções em paralelo, e algumas deixam os agentes conversarem entre si. Elas diferem em onde os agentes rodam e em quanto da verificação dos resultados assumem.

### Claude Code e Codex

Estes dois são os agentes em si. O Claude Code roda sessões em segundo plano que continuam depois que o terminal fecha, cada uma no seu próprio worktree (`claude --bg --worktree`), e as sessões podem mandar mensagens umas para as outras ou iniciar subagentes. Também há sessões na nuvem, iniciadas pela web ou pelo celular. O Codex vem como CLI, app de desktop e extensões de IDE, e o Codex Web roda tarefas em contêineres Linux na nuvem da OpenAI.

### Orca

![O app de desktop do Orca: uma barra lateral com projetos e worktrees em dois Macs, no centro o chat de um agente coordenador que iniciou dois workers e conta o que cada um fez, à direita os painéis dos workers, e num canto o app de celular do Orca mostrando a mesma conversa.](<https://foxl.ai/blog/ai-factory-orca.webp>)

O [Orca](<https://github.com/stablyai/orca>) é um app de desktop para macOS, Windows e Linux. Ele roda agentes de CLI como o Claude Code ou o Codex em paralelo, cada um no seu próprio worktree, e, quando você entrega uma tarefa grande, um agente coordenador divide o trabalho entre workers e traz os resultados de volta, que é a cena da captura acima. Os agentes também podem rodar num host SSH ou numa VM na nuvem por worktree, e checks que falham e comentários de revisão voltam para o agente corrigir.

### herdr

![O herdr numa janela de terminal: uma barra lateral com dois espaços de trabalho e uma lista de agentes em que um está idle e o Claude está working, e dois painéis, um com as anotações de um agente sobre o código do herdr e outro com o Claude Code rodando.](<https://foxl.ai/blog/ai-factory-herdr.webp>)

O [herdr](<https://github.com/herdrdev/herdr>) é um runtime de terminal num único binário em Rust. Ele assume os terminais em vez de embrulhar os agentes, então funciona igual com Claude Code, Codex ou OpenCode. Os terminais continuam rodando em segundo plano quando uma conexão SSH cai, cada painel mostra se o agente dele está working, blocked ou idle, e os agentes podem mandar prompts uns aos outros pela CLI e pela API de socket dele.

### Kiro Crew

![O crew board do Kiro Crew: o objetivo de um conductor e seus itens de trabalho, agrupados em needs a decision, working e finished, cada um com o que o worker relatou e o estado do conductor; um item está marcado como sem acceptance criteria, e o concluído diz verified against the bar, accepted.](<https://foxl.ai/blog/ai-factory-kiro-crew.webp>)

O [Kiro Crew](<https://github.com/kirodotdev/KiroCrew>) é um espaço de trabalho que roda no seu próprio hardware, um Mac, um contêiner ou uma máquina remota, e continua trabalhando entre uma conversa e outra. Sessões, memória e checkpoints de tarefas sobrevivem a reinícios, e as correções se acumulam como lições que mudam o que ele faz depois. O crew board dele, acima, mostra cada item que o conductor distribuiu ao lado do que o worker relatou e de se o conductor aceitou o resultado segundo a régua.

### Foxl Code

![O quadro Trabalho do Foxl Code num navegador: as colunas Precisa de você e Concluído estão vazias, e Em andamento tem três tarefas em foxl-ai/acme-web, todas com o Claude Code como agente: uma aguardando início e duas com o agente trabalhando.](<https://foxl.ai/blog/ai-factory-foxl-code-pt.webp>)

O Foxl Code é o produto na nuvem que mencionamos antes, em beta privado para contas convidadas. Você descreve uma tarefa no navegador ou no celular, e um agente como o Claude Code trabalha nela numa VM própria. Um pedido maior é dividido em subtarefas independentes que começam ao mesmo tempo, um pull request para cada uma; o quadro acima é um pedido segundos depois de se dividir em três. O revisor lê o `MERGE-REVIEW.md` do repositório a partir da branch padrão, nunca a partir do pull request, então uma mudança não consegue reescrever a régua com que é avaliada. Mesmo assim, cada pull request é verificado sozinho: para testar vários deles mesclados juntos, você pede um merge train no chat.

Lado a lado:

| Ferramenta | Onde os agentes rodam | Pontos fortes | Limites |
| --- | --- | --- | --- |
| Claude Code | Sua máquina, ou uma sessão na nuvem iniciada pela web ou pelo celular | Sessões em segundo plano nos próprios worktrees, que se listam e trocam mensagens; subagentes | As mensagens só chegam a sessões do Claude Code |
| Codex | Sua máquina, ou a nuvem da OpenAI | Um mesmo agente numa CLI, num app de desktop, em IDEs e na nuvem | As tarefas na nuvem rodam num contêiner Linux, então o trabalho com Xcode fica local |
| Orca | Sua máquina, um host SSH ou uma VM na nuvem por worktree | Qualquer agente de CLI; um coordenador que divide uma tarefa entre workers; app de celular; checks que falham voltam ao agente | Nada na descrição dele testa vários pull requests mesclados juntos |
| herdr | Sua máquina e hosts SSH | Fica por baixo de qualquer agente: terminais que sobrevivem à desconexão, working, blocked ou idle por painel, agentes que trocam prompts | Cuida dos terminais, não do trabalho: não acrescenta nenhuma etapa própria de revisão ou de merge |
| Kiro Crew | Seu Mac, um contêiner ou uma máquina remota | Sessões, memória e checkpoints que sobrevivem a reinícios; lições a partir de correções; um conductor que aceita o trabalho segundo uma régua | Ainda sem canais entre workers |
| Foxl Code | Uma VM por tarefa, na nuvem do Foxl | Começa pelo celular; subtarefas em paralelo, um pull request para cada; um revisor preso à régua de merge do repositório | Beta privado; sem macOS; pull requests só são testados juntos em um merge train que você pede |

Construímos a nossa fábrica sobre as próprias sessões do Claude Code. Ela nasceu de uma única sessão do Claude Code, e as sessões deste Mac já conseguiam se listar e trocar mensagens, bem ao lado do Xcode e dos simuladores.

Duas coisas não mudam, seja qual for a ferramenta que roda os agentes. Os agentes de uma mesma máquina precisam dividir a memória dela, e alguém precisa decidir se o que eles fizeram está certo. O resto deste post é sobre essas duas coisas.

## Vinte sessões e a memória de um só Mac

Na tarde de 17 de outubro, havia dezenove sessões abertas. Um build web ocupa uns 3,5 GB de memória, e em dez minutos quatro sessões pediram um. Duas rodaram verificações de TypeScript, e uma iniciou um simulador de iPhone sem perguntar. Oito sessões tinham mudanças abertas no mesmo arquivo CSS. Naquela tarde, dissemos às sessões que usassem menos memória, esperassem a vez e perguntassem antes de usá-la.

No mesmo dia, uma sessão virou o coordenador. Todas as outras leem, ao começar, um arquivo compartilhado que diz quem cuida de quais arquivos, mandam ao coordenador uma linha com sua tarefa e os arquivos que esperam mexer, e recebem um escopo de volta. Uma sessão que precisa de um arquivo de outra manda a essa sessão a mudança para ela aplicar. Antes de qualquer coisa que consuma muita memória, como um build, uma suíte de testes ou um simulador, ela manda `HEAVY?` com sua estimativa de memória e de minutos e espera o `GO`. O coordenador lê a pressão de memória do Mac antes de cada liberação.

Abaixo está a fila em que o primeiro build deste post esperou. Um benchmark de modelo e execuções no simulador já estavam na fila, e o build só começou depois de esperar 50 minutos.

![Uma linha do tempo de 05:00 a 06:30 UTC com uma linha para cada passo da fila compartilhada de trabalho pesado: um benchmark do modelo do Notes de 05:03 a 05:41; entre 05:41 e 06:07, uma execução no simulador, um build nativo seguido do simulador, uma verificação de capturas que parou assim que abriu e uma medição de tempo no simulador; depois os dois builds do site deste post, de 06:08 a 06:25, na fila desde 05:18, com a cópia antecipada das dependências às 05:57.](<https://foxl.ai/blog/ai-factory-queue-pt.png>)

As regras da fila ficam num único script de shell, `heavy.sh`, e já mudaram mais de uma vez. Em 28 de outubro, estavam rígidas demais: dez tarefas esperaram até 16 minutos enquanto o Mac tinha 43% da memória livre, e tiramos a fila. Em 2 de novembro, estavam frouxas demais. Havia umas 19 sessões abertas, várias com dois a cinco subagentes cada, e a trava não contava nem os subagentes nem um servidor de desenvolvimento que estava no ar havia seis horas. O Mac ficou sem memória, e, quando o harness limpou os shells em segundo plano, os vigias do coordenador caíram junto.

A trava de hoje mede a memória do Mac toda vez que roda. Com espaço, uma tarefa começa na hora; sem espaço, ela é segurada; e nunca rodam mais de quatro tarefas pesadas ao mesmo tempo. A verificação que fica na frente do trabalho pesado é mais ou menos esta:

```
# LOCKS is a directory every session shares; run/<pid> marks a heavy run.
level=$(sysctl -n kern.memorystatus_vm_pressure_level)  # 1 normal, 2 warn, 4 critical
free=$(memory_pressure -Q | awk -F: '/free percentage/ {print int($2)}')
live=0
for f in "$LOCKS"/run/*; do
  [ -e "$f" ] && kill -0 "${f##*/}" 2>/dev/null && live=$((live + 1))
done

hold() {
  [ -e "$LOCKS/STOP" ] || [ "$level" -ge 4 ] ||
  { [ "$level" -ge 2 ] && [ "$live" -ge 2 ]; } ||
  [ "$free" -lt 25 ] || { [ "$free" -lt 30 ] && [ "$live" -ge 1 ]; } ||
  [ "$live" -ge 4 ]
}
# Wait while hold() is true or older tickets fill the free slots (2 at warn, 4 otherwise).
# Then write run/$$, run "$@" as a child, and remove run/$$ when it exits.
```

As tarefas em espera pegam senha por ordem de chegada. Uma vez, com umas 30 esperando, ganhava a que consultava primeiro quando uma vaga abria, e uma tarefa esperou 35 minutos atrás de outras que tinham chegado depois. Também há limites para a máquina toda, no máximo seis subagentes e um simulador, mas esses dois ainda são só regras escritas que a trava não impõe.

## Regras que só existem por escrito se quebram

Cada incidente deste post deixou uma regra, posta por escrito com a data. Três delas mostram o que acontece com uma regra que só existe por escrito.

A primeira são os dados reais. As sessões de agentes iniciadas a partir da cópia do app de desktop do Foxl que usamos de verdade herdam o ambiente do app, incluindo uma variável que aponta para o banco de dados dele. Em 19 de outubro, uma suíte de testes rodada num shell assim gravou 305 conversas falsas no banco de dados real do Foxl. A regra de limpar essa variável entrou no mesmo dia, e a partir de 24 de outubro o `heavy.sh` passou a limpá-la sozinho. O erro voltou mesmo assim: uma verificação rodada direto com npm, scripts avulsos, testes que empacotam o servidor de desktop inteiro, cada vez por um caminho que o wrapper não cobria. Agora o servidor de desktop se recusa a abrir dados reais quando roda sob um executor de testes (`foxl/server/paths.ts`). Só os scripts avulsos ainda dependem da regra escrita.

A segunda é um script que gasta dinheiro de verdade. O `check-remote-input.mjs` fica no meio de dezenas de scripts `check-` que leem o repositório e falham com o que encontram, mas ele inicia tarefas de verdade no serviço de produção do Foxl Code. Em 23 de setembro, uma passada por todos os scripts `check-` iniciou uma. A regra, então, era rodar as verificações uma a uma, pelo nome. Em 18 de outubro, o script entrou de carona numa lista de verificações escolhida com grep, e a cobrança das três tarefas dele deixou negativa a nossa conta de testes. Agora ele não faz nada sem a flag `--live`, e um teste no pr-validate o mantém assim.

A terceira é a trava de push. Os pushes passavam por uma trava que a sessão obtinha criando um diretório. Em 2 de novembro, uma sessão tentou pegá-la à mão, dentro de um lote de chamadas de ferramentas em paralelo. Criar o diretório falhou, porque outra sessão estava com a trava, mas o resto do lote rodou assim mesmo: a sessão deu push e depois apagou a trava da outra sessão. Naquela mesma manhã entrou um script que pega a trava e só libera a sua, mas uma sessão confinada ao próprio worktree não conseguia usá-lo e continuou pegando a trava à mão, um passo de cada vez. O mesmo erro aconteceu de novo em 4 de novembro.

Nenhuma dessas verificações acabou com o seu tipo de erro. Cada uma fechou o caminho por onde veio o último, e até agora o seguinte sempre achou outro.

## O que um check verde prova

Toda a nossa CI roda em runners auto-hospedados, e todo pull request precisa passar por uma trava chamada `pr-validate`. A questão é o que esse check verde prova. Verde quer dizer que o pull request passou nos testes sozinho, e nada mais.

O primeiro merge train, o da v0.7.27 em 24 de setembro, mostrou a diferença. Cinquenta e quatro pull requests estavam verdes cada um na sua própria CI e mesmo assim tinham quatro bloqueios. Um perdia os últimos caracteres digitados com um método de entrada; outro quebrava a resposta pela tela de bloqueio do iPhone. No mesmo dia, o Mac travou de vez com 19 agentes revisores rodando ao mesmo tempo. Desde então os revisores rodam no máximo sete por vez, mas isso também é só uma regra escrita.

Por isso, hoje um train é montado a partir da árvore mesclada de todos os pull requests que estão prontos, e a decisão de merge é tomada sobre essa árvore. Cada agente revisor pega um grupo de pull requests relacionados, com instruções que incluem isto, no inglês original:

> Your job is to REFUTE each PR in your group, not to confirm it. Assume every PR body overclaims until you have reproduced its claim. A green pr-validate on the PR proves little: it ran without the other PRs, and it cannot see UX or cost.

Ou seja: refutar cada pull request, não confirmá-lo; supor que o texto de cada pull request exagera até ter reproduzido o que ele afirma; e saber que um pr-validate verde no pull request prova pouco, porque rodou sem os outros pull requests e não vê nem a experiência de uso nem o custo. Um revisor responde MERGE, MERGE\_WITH\_FIXES com o patch escrito, HOLD ou CLOSE. As correções entram como commits próprios em cima do pull request, e um pull request que não tem conserto fica de fora com a remontagem do train sem ele.

[“Don’t Build Multi-Agents”](<https://cognition.com/blog/dont-build-multi-agents>), da Cognition, argumenta contra dividir uma tarefa entre agentes que não enxergam o trabalho uns dos outros, e a favor de entregá-la a um único agente que tenha todo o contexto. Nós de fato damos a cada sessão uma tarefa inteira. Resta um problema: os agentes confiam demais no próprio trabalho. É por isso que os revisores recebem a ordem de refutar.

Um teste que o agente escreve junto com a funcionalidade é uma evidência especialmente fraca. O teste e o código nascem do mesmo entendimento do problema, então, quando o agente entende errado a API de um fornecedor ou o que foi pedido, os dois carregam o mesmo erro. Isto é o que cada tipo de verificação consegue enxergar:

![Uma matriz de seis tipos de verificação contra cinco tipos de falha. Um typecheck, um teste escrito no mesmo commit, um teste que falha na árvore de antes da correção e a CI no train mesclado pegam só alguns dos casos em que o código está errado; os dois últimos também expõem alguns testes que não testam nada, e a CI no train mesclado pega mudanças que quebram uma à outra. Um revisor que não escreveu a mudança pega o código, o teste e essas interações, e às vezes um sistema externo que se comporta diferente. Só perguntar ao destino mostra se uma versão chegou.](<https://foxl.ai/blog/ai-factory-evidence-pt.png>)

Por isso um teste novo só conta se falhar na árvore de antes da correção, e a trava final é a CI no train mesclado. Para tudo o que acontece fora do repositório, a evidência está nesse sistema externo. Depois da atualização de versão de uma CLI, os terminais remotos de Codex e OpenCode no Foxl Code não aceitaram nenhuma digitação durante dez dias, enquanto todas as travas estavam verdes. Um workflow de versão já informou sucesso enquanto o TestFlight não tinha nenhum build. E em 3 de novembro descobrimos que 34 de 43 harnesses de capturas serviam páginas sem as fontes de verdade, então os revisores vinham julgando letras que o app publicado nem desenha.

## Pergunte ao destino

Uma versão estável é uma única execução de workflow. Essa execução compila e entrega os apps de Windows, Linux, macOS, iOS e Android, os apps web e o servidor relay. Não confiamos no workflow quando ele diz que deu certo: as verificações depois de uma versão perguntam direto a cada destino.

Um script espera até as cinco plataformas terem os seus arquivos antes de publicar a versão. O cask do Homebrew é comparado com a versão publicada, porque já serviu um build de uma semana antes durante quatro versões, enquanto o workflow que o atualiza parecia bem. Os apps web publicados são comparados com a versão lançada, porque um Worker responde 200 com um bundle velho. O TestFlight é consultado pela API da Apple.

## Se você quiser montar algo parecido

Isto é o que funcionou para nós:

- Dê a cada agente seu próprio git worktree. No APFS, `cp -Rc` copia o `node_modules` como um clone copy-on-write que quase não ocupa disco. Nunca ligue um mesmo `node_modules` por symlink a vários worktrees.
- Faça de um agente o coordenador, e guarde o estado compartilhado em arquivos simples que todos os agentes conseguem ler: quem cuida de quais arquivos, quem está rodando o quê, o que está congelado.
- Ponha uma trava no trabalho que consome muita memória com base na memória medida, e conte os subagentes e os servidores de desenvolvimento junto com os builds.
- Leia as refs por SHA, e não pelo nome, porque outras sessões movem `origin/*` o tempo todo.

Antes de montar um merge train, você pode mapear os conflitos dele sem checkout, dobrando cada pull request sobre a main, um de cada vez. Em bash:

```
# Each head as a local ref first: git fetch origin '+refs/pull/*/head:refs/pr/*'
prs=(101 102 103)
acc=$(git rev-parse origin/main)
for pr in "${prs[@]}"; do
  out=$(git merge-tree --write-tree --name-only "$acc" "refs/pr/$pr"); code=$?
  if [ "$code" -eq 0 ]; then
    acc=$(git commit-tree "${out%%$'\n'*}" -p "$acc" -p "refs/pr/$pr" -m "train: #$pr")
  elif [ "$code" -eq 1 ]; then
    echo "#$pr conflicts in:"; echo "$out" | sed -n '2,/^$/p'
  else
    echo "#$pr: merge-tree failed ($code)"; exit "$code"
  fi
done
```

Um arquivo a que todo pull request acrescenta linhas no fim, como um changelog, vai aparecer em quase todo conflito, a menos que você dê a ele um merge union para este comando: `git -c core.attributesFile=<file>`, com `CHANGELOG.md merge=union` nesse arquivo.

## O que as pessoas fazem

Nesta configuração não escrevemos código, e raramente lemos um diff. Um pedido costuma ser uma frase e uma captura de tela. O que lemos é o que volta: as capturas de cada pull request, os veredictos de cada train e o relatório com que cada versão termina, que lista o que saiu, o que cada verificação respondeu e as capturas de todos os pull requests incluídos.

Uma manhã serve de exemplo. Em 3 de novembro, às 04:59 UTC, chegou um pull request com 20 capturas de uma nova janela de edição no cartão que publica uma avaliação. O texto estava em outra fonte, a caixa de texto era a do navegador e três botões desciam pelo cartão, um embaixo do outro. Às 05:04 mandamos duas linhas ao coordenador: que o autor redesenhasse a janela no sistema de design, voltasse o pull request para rascunho e o subisse de novo. Doze segundos depois era um rascunho. Às 09:30 ele voltou no próprio editor de rascunhos do app, com 296 capturas, cada uma feita depois que as fontes do app carregaram, e foi mesclado às 11:50. A outra fonte não era culpa do pull request: o harness de capturas dele nunca servia as fontes do app, e foi investigando o porquê, naquele dia, que achamos os 34 harnesses citados acima.

![O pull request no GitHub como chegou: a seção Screenshots, com tabelas da janela de edição numa mensagem do Telegram e num cartão de avaliação; o cartão de avaliação aparece numa fonte de reserva, com a caixa de texto do navegador e Post, Done e Not now empilhados.](<https://foxl.ai/blog/ai-factory-edit-before.webp>)

![O mesmo pull request no GitHub quando voltou: The real bundle: the Edit window, uma nota de que as fontes do app foram conferidas antes de cada captura e uma tabela de capturas de desktop em quatro estilos, entre elas a janela de edição do cartão de avaliação.](<https://foxl.ai/blog/ai-factory-edit-after.webp>)

Quando algo dá errado, escrevemos a regra que teria pegado o problema no arquivo `CLAUDE.md` daquela área, com a data e o incidente, e depois procuramos o ponto em que um script poderia impô-la. Os agentes tomam as decisões reversíveis a partir do código e anotam o que decidiram. Tudo o que é irreversível, e tudo o que envolve dinheiro, espera por uma pessoa. Um pull request que deixa o Foxl menos prático do que os produtos com que as pessoas o comparam fica segurado, mesmo quando o código dele está certo.

## A parte que ainda não resolvemos

Os revisores são agentes, mas os critérios que eles aplicam foram escritos por pessoas, e são pessoas que ainda leem os veredictos deles. Essa leitura agora é o passo mais lento entre um pull request e uma versão. Por isso estamos escrevendo um critério para cada tipo de afirmação, um que outro agente consiga verificar sem uma pessoa: para uma correção de lógica, um teste que falha antes da correção e passa no train mesclado; para a API de um fornecedor, uma captura do serviço real; para tudo o que uma pessoa vê, capturas de tela do build real com as fontes reais; para um custo, contagens de requisições medidas; para uma versão, a resposta de cada destino. Tudo o que é irreversível, e tudo o que envolve dinheiro, continua com as pessoas.

Ainda não sabemos como saber quando um critério basta. O plano é avaliar os revisores do jeito que se avaliam testes: contar os bloqueios que cada um encontra e que a CI deixou passar, e quantas vezes uma pessoa derruba o veredicto dele. Quando as pessoas pararem de derrubar um revisor num tipo de afirmação, esse critério não vai mais precisar de ninguém. Ainda não temos nenhum dos dois números.

## Referências e leituras complementares

1. [Changelog do Claude Code](<https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md>) - Reference
2. [Codex](<https://github.com/openai/codex>) - Reference
3. [Orca](<https://github.com/stablyai/orca>) - Reference
4. [herdr](<https://github.com/herdrdev/herdr>) - Reference
5. [Kiro Crew](<https://github.com/kirodotdev/KiroCrew>) - Reference
6. [Índice de RFCs do Kiro Crew](<https://github.com/kirodotdev/KiroCrew/blob/main/docs/request-for-change/README.md>) - Reference
7. [Foxl Code](<https://foxl.ai/pt/code>) - Reference
8. [Cognition, Don’t Build Multi-Agents](<https://cognition.com/blog/dont-build-multi-agents>) - Reference