Arquitetos, testers e programadores: construindo equipes de desenvolvimento multiagente

Como equipes de desenvolvimento multiagente rodando no Antigravity podem portar bibliotecas Python para pacotes Dart idiomáticos usando desenvolvimento orientado a testes.

Uma equipe de Dashes representando arquitetos, testers e programadores de IA colabora em torno de um editor de código Dart.

Quando comecei a experimentar assistentes de programação com IA, eu usava um único agente para tudo: arquitetar código, escrever testes unitários e depurar stack traces. Embora essa abordagem funcionasse bem para tarefas pequenas, ela se degradava rapidamente em problemas complexos de engenharia de software. Conforme o meu histórico de conversa crescia, a janela de contexto do agente ficava saturada com logs e resultados de busca, levando a alucinações, conexões perdidas, código descuidado e bugs.

Algumas semanas atrás, eu topei com um post sobre fluxos de trabalho de programação multiagente com TDD. Já tinha ouvido falar da abordagem, mas nunca tinha tentado. Como o Agent Hub do Antigravity inclui ferramentas para configurações multiagente, decidi colocar a técnica à prova.

Para testar com um desafio real, eu me propus a portar a popular biblioteca python-statemachine para um pacote Dart estaticamente tipado e sem reflection. Embora o pub.dev já tenha boas opções de máquina de estados, python-statemachine foi um benchmark fantástico. Ela depende muito de recursos dinâmicos do Python (como metaclasses e callbacks em tempo de execução) que precisaram ser completamente re-arquitetados para a tipagem estática forte do Dart e para a exigência do Flutter de que dart:mirrors não seja usado.

Diagrama mostrando os papéis e o fluxo de trabalho da equipe de desenvolvimento multiagente
É menos complicado do que parece, eu juro!

Uma das primeiras coisas que aprendi é que a base de uma equipe de agentes eficaz é um conjunto de papéis bem definidos, com restrições específicas sobre o que o agente pode fazer. Para implementar isso, criei uma skill de fluxo de trabalho geral (tdd-dart-workflow) para estabelecer as regras compartilhadas de TDD e as permissões, junto com quatro skills específicas de papel, definindo cada agente:

  • Architect (tdd-dart-architect): Analisa o código-fonte, produz o architecture_blueprint.md inicial (Fase 0) e escreve especificações direcionadas por módulo em specs/ (Fase 1). O Architect não pode escrever em lib/, test/ ou example/.
  • Tester (tdd-dart-tester): Escreve testes unitários abrangentes que falham em test/, com base na especificação do Architect (Fase 2a). O Tester não pode ver nem escrever em lib/ ou specs/.
  • Coder (tdd-dart-coder): Cria esqueletos de compilação e implementa o código da biblioteca em lib/src/ para fazer os testes que falham passarem (Fases 2b e 3). O Coder não pode editar test/ ou specs/.
  • Coordinator (tdd-dart-coordinator): O agente pai coordenador. O Coordinator gerencia os commits de branch no Git, executa as verificações dart analyze && dart test e delega tarefas aos subagentes.

Ao impor uma separação estrita de papéis, nenhum agente único consegue alterar, ao mesmo tempo, as asserções dos testes e o código subjacente. O Coordinator atua como um porteiro, recebendo apenas um breve relatório de conclusão quando um subagente termina a tarefa. Isso cria um "firewall cognitivo". Além de ser uma frase divertida para usar em entrevistas de emprego, significa que o histórico de tokens de tentativa e erro de cada subagente é descartado assim que a tarefa termina. Como resultado, a janela de contexto do Coordinator pai permanece limpa, focada e livre de saturação de tokens.

Para ser claro, há problemas potenciais que estou deixando de lado aqui, como "O que acontece se um subagente ficar preso em um loop?" e "Deveria haver um tempo limite após o qual um subagente é encerrado e recriado, ou um humano é notificado?" Esta é a minha primeira incursão em equipes multiagente, e vou deixar essas questões para um post de acompanhamento!

Para evitar condições de corrida e commits de código não verificado, o acesso de escrita ao sistema de arquivos é restringido em tdd-dart-workflow no nível da ferramenta, com base no papel atribuído a cada agente:

Papel do agenteCaminho de leitura permitidoCaminho de escrita permitidoAções proibidas
Coordinator Qualquer lugar Qualquer lugar Modificações diretas de código (delega ao Coder/Tester)
Architect Qualquer lugar specs/, skills/ Não pode escrever em lib/, test/ ou example/
Tester Qualquer lugar test/, example/ Não pode escrever em lib/ ou specs/
Coder Qualquer lugar lib/, example/ Não pode escrever em test/ ou specs/

Na minha versão, essas restrições estão incluídas nas instruções dos agentes, então é tecnicamente possível que elas sejam violadas. À medida que os sistemas multiagente evoluírem, porém, espero que comecemos a ver formas mais seguras de implementar restrições.

Um exemplo de desafio

Operar uma equipe multiagente em uma linguagem compilada como o Dart trouxe um desafio interessante: a tensão entre a compilação estática e a necessidade de escrever testes para código que ainda não existe. Em linguagens dinâmicas como Python, o TDD começa com um teste que falha (Red) e lança um erro em tempo de execução. Em linguagens estáticas, porém, escrever testes unitários para métodos que ainda não existem causa uma falha de compilação. O compilador aborta, impedindo o executor de testes de rodar e provar que o próprio teste é válido.

Minha equipe de agentes resolveu isso dentro do loop da Fase Red. Primeiro, o Tester escreve os testes direcionados à especificação do Architect. Em seguida, o Coder cria um esqueleto de compilação em lib/src/, com stubs de classes e métodos que retornam valores fictícios ou lançam UnimplementedError. Assim que o esqueleto satisfaz o compilador, o Coordinator roda dart analyze && dart test para verificar se os testes falham pelos motivos certos (lógica não implementada, e não erros de sintaxe ou de import). Delimitadores de comentário garantem que os stubs temporários fiquem isolados dos utilitários de teste permanentes, permitindo que o Coordinator os limpe automaticamente quando o Coder concluir a fase Green:

dart
// TEST UTILITIES - KEEP PERMANENTLY
class MockListener extends Mock implements StateMachineListener {}
​
// SKELETON STUBS FOR COMPILATION - DELETE ONCE SKELETON IS IMPLEMENTED
class StateMachine<T extends StateModel> {
  dynamic get currentState => throw UnimplementedError();
  dynamic get currentStateValue => throw UnimplementedError();
  void send(String eventId) => throw UnimplementedError();
}

O que não deu certo: pontos de atrito e atualizações de skills no meio do caminho

Usar agentes certamente tornou o processo de portar a biblioteca mais rápido, mas isso traz desafios próprios. Os momentos em que o fluxo de trabalho quebrou, porém, foram os que mais renderam lições de engenharia. No meio do processo de porte, precisei pausar e atualizar meus arquivos de skill (SKILL.md) para resolver três problemas:

  • Exclusão acidental de utilitários de teste: Depois que o Coder implementou as classes reais da biblioteca em lib/src/, o Coordinator precisou limpar os stubs de compilação temporários deixados nos arquivos de teste. Ele vivia confundindo os stubs com a implementação real, então foi preciso exigir cabeçalhos de comentário claros para deixar a implementação real distinta.
  • Incompatibilidades de tipo no operador spread (...): Python e Dart lidam com tipos de formas diferentes, e coisas que são iteráveis por padrão no Python não necessariamente são no Dart. Precisei adicionar instruções explícitas sobre o que precisava implementar Iterable como resultado.
  • Tipagem dinâmica com “sotaque estrangeiro”: Aqui, de novo, os diferentes sistemas de tipos causaram problemas. A biblioteca original em Python usava verificações hasattr em alguns pontos. Precisei refinar tdd-dart-architect/SKILL.md para forçar o Architect a usar Dart idiomático e delegates de callback explícitos, em vez de buscas dinâmicas de propriedade.

Esses refinamentos de skill moldaram diretamente o design final. O pacote Dart resultante (state_machine) mantém todo o conjunto de recursos de python-statemachine, com o Coder implementando builders fluentes para dar suporte ao operador spread nativo do Dart (...). Abaixo está uma comparação entre a definição de classe original em Python e a máquina de estados final em Dart, produzida pela equipe de agentes:

O jeito antigo:

python
# python-statemachine syntax (declarative via metaclasses)
from statemachine import StateMachine, State
​
class TrafficLightMachine(StateMachine):
    green = State("Green", initial=True)
    yellow = State("Yellow")
    red = State("Red")
​
    cycle = green.to(yellow) | yellow.to(red) | red.to(green)
​
    def on_enter_green(self):
        print("Entered Green state")

O jeito novo:

dart
// state_machine Dart syntax (declarative constructor DSL)
import 'package:state_machine/state_machine.dart';
​
class TrafficLightMachine extends StateMachine<TrafficLightModel> {
  final green = State('green', initial: true);
  final yellow = State('yellow');
  final red = State('red');
​
  late final Event cycle;
​
  TrafficLightMachine(TrafficLightModel model) : super(model: model) {
    cycle = event('cycle');
​
    initialize(
      states: [green, yellow, red],
      transitions: [
        ...green.to(yellow).on(cycle).transitions,
        ...yellow.to(red).on(cycle).transitions,
        ...red.to(green).on(cycle).transitions,
      ],
    );
​
    green.onEnter((EventData data) {
      print('Entered Green state');
    });
  }
}

O objetivo de tudo isso era produzir um conjunto de skills reutilizáveis para mim mesmo, e não criar e publicar um novo pacote Dart. Não estou em posição de acompanhar issues reportadas nem de manter isso ao longo do tempo. Não consigo garantir todo o código que foi criado (embora tenha funcionado quando testei), e já existem vários pacotes bem mantidos no ecossistema. Ainda assim, espero que isso tenha dado uma ideia do que sistemas multiagente rodando no Antigravity podem fazer por desenvolvedores Dart e Flutter.

Se você quiser explorar fluxos de trabalho multiagente nos seus próprios projetos, vá em frente!

Mais do Flutter