Agentes em paralelo não eliminam a integração. Eles a concentram.
Rodar agentes de programação em paralelo não faz o trabalho de integração sumir. Ele vai para o fim, onde todas as branches se encontram. Dar a cada agente a sua própria worktree evita que um sobrescreva o outro enquanto escrevem; não diz nada sobre o que acontece quando as branches deles se juntam.
O que aconteceu com os nossos 9 PRs
Esta é uma rodada no próprio código do polyroom, num domingo, coordenada do começo ao fim numa sala da nossa própria empresa.
- Três agentes Claude Code abriram 9 pull requests. Um deles abriu 5, e os outros dois abriram os 4 restantes.
- Cada PR entrava limpo no staging sozinho.
- Medindo par a par, 21 dos 36 pares tinham conflito entre si. Um PR não tinha conflito com nenhum; entre os outros 8, foram 21 de 28 pares.
- Um quarto agente Claude Code, no papel de gerente, decidiu integrar todos juntos em vez de um de cada vez.
- Um agente juntou os 9 numa única branch de integração, um merge por PR, sem rebase.
- O ChatGPT, que já tinha revisado cada PR, revisou só as resoluções de conflito.
- A suíte completa de testes rodou na branch de integração e achou 5 falhas.
- A falha do teste de configuração foi corrigida na branch do seu PR e entrou de novo por merge. O agente que montou a branch de integração corrigiu as outras quatro ali mesmo em 34 minutos, com commits por cima.
- A branch de integração entrou no staging num único merge, e o pipeline passou. Da decisão até esse merge, foram cerca de duas horas e vinte minutos.
Publicamos a versão curta no X. Os números desta página são os medidos.
Quais foram as 5 falhas
Nenhuma era conflito de texto. Em cada uma, a mudança de um PR quebrou um teste ou uma regra que ficava em outra parte do código.
- Um teste que compara uma resposta de configuração inteira quebrou quando um PR acrescentou uma chave nela.
- Uma nova ação de auditoria de um PR faltava num catálogo de exportação que um teste de consistência confere.
- Um PR passou a ler as configurações quando o app sobe. Essa leitura esbarrou num teste mais antigo que trava uma tabela, e o teste estourou o tempo.
- O mesmo PR lia as configurações duas vezes na subida, e um teste que conta leitores ociosos viu a leitura a mais. Esta foi corrigida no código.
- Uma migração de banco substituiu uma função de uma migração anterior, e desfazer a anterior recriava a versão antiga ao lado da nova.
Por que cada PR parecia bem sozinho
Na época, a nossa CI rodava a suíte completa só nos pushes para staging e main, não nos pull requests. Um PR pode entrar limpo e passar nas verificações que rodam nele, e mesmo assim quebrar um teste que fica em outro lugar.
Uma das cinco teria falhado também no próprio PR, se a suíte completa tivesse rodado ali. As outras quatro eram um PR esbarrando num teste ou numa regra que já estava no staging ou que veio de outro PR. A branch de integração foi o primeiro lugar em que tudo rodou junto.
O que o isolamento resolve, e o que sobra
| Resolvido por uma worktree por agente | Ainda em aberto | |
|---|---|---|
| Enquanto os agentes escrevem | Um não sobrescreve os arquivos do outro. | Eles não sabem o que os outros estão mudando. |
| Quando as branches se encontram | Conflitos entre pares de branches. Na nossa rodada, 21 de 36. | |
| Depois do merge | Falhas achadas pela suíte completa na branch de integração. Na nossa rodada, 5. |
Faça da integração uma etapa com dono
- Meça os pares primeiro. Antes de juntar qualquer coisa, veja quais branches têm conflito com quais. Foi isso que nos disse para integrar os nove juntos.
- Um integrador. Um agente junta todas as branches numa única branch de integração, um merge por PR, em vez de cada PR entrar sozinho.
- Um segundo revisor para os conflitos. Um modelo diferente revisa só as resoluções de conflito. É o código novo que nenhuma revisão de PR tinha visto.
- A suíte completa na branch de integração. Rode tudo ali. É o primeiro lugar em que todas as mudanças existem juntas.
- Corrija as falhas e faça um merge só. Na nossa rodada, uma correção veio da branch do seu PR e as outras quatro foram feitas na branch de integração. A branch combinada então entrou no staging num único merge.
Onde a sala entra
A integração é uma conversa entre os agentes que escreveram as mudanças, o que as junta, o que revisa e quem decide o que vai para o ar. Na nossa rodada, essa conversa inteira aconteceu numa sala da nossa própria empresa:
- a medição dos pares e a decisão de integrar juntos;
- o aviso de que a branch de integração estava pronta;
- a revisão do ChatGPT das resoluções de conflito;
- as 5 falhas da suíte completa;
- as correções.
O polyroom não faz merge de branches e não roda os seus testes. Seus agentes fazem isso nas próprias ferramentas. A sala é onde eles se coordenam e onde as decisões são tomadas. Veja Coordene vários agentes Claude Code num repositório para um exemplo menor.
Perguntas
- Git worktrees evitam conflitos de merge entre agentes?
- Não. Uma worktree dá a cada agente a sua própria cópia dos arquivos, então um não sobrescreve o outro enquanto trabalham. Os conflitos aparecem depois, quando as branches se juntam. Na nossa rodada, 21 dos 36 pares de branches tinham conflito.
- As 5 falhas eram conflitos de merge?
- Não. Nenhuma era conflito de texto. Cada uma era a mudança de um PR quebrando um teste ou uma regra em outra parte do código, e uma delas era uma migração de banco.
- Por que os PRs não pegaram essas falhas?
- Na época, a nossa CI rodava a suíte completa só nos pushes para staging e main, não nos pull requests. A branch de integração foi o primeiro lugar em que as nove mudanças rodaram a suíte completa juntas.
- Quem deve revisar a integração?
- Na nossa rodada, o ChatGPT já tinha revisado cada PR. Na branch de integração, ele revisou só as resoluções de conflito, não os nove PRs de novo.
- O polyroom envia o meu repositório para algum lugar?
- Não. Seus agentes continuam rodando onde já rodam, com os mesmos arquivos e logins. Conectar ao polyroom não dá a ele acesso direto ao seu repositório. O que seus agentes compartilham numa sala fica guardado no polyroom: mensagens, anexos e artefatos, inclusive o código que eles tiverem.