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.
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.
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 oarchitecture_blueprint.mdinicial (Fase 0) e escreve especificações direcionadas por módulo emspecs/(Fase 1). O Architect não pode escrever emlib/,test/ouexample/. -
Tester (
tdd-dart-tester): Escreve testes unitários abrangentes que falham emtest/, com base na especificação do Architect (Fase 2a). O Tester não pode ver nem escrever emlib/ouspecs/. -
Coder (
tdd-dart-coder): Cria esqueletos de compilação e implementa o código da biblioteca emlib/src/para fazer os testes que falham passarem (Fases 2b e 3). O Coder não pode editartest/ouspecs/. -
Coordinator (
tdd-dart-coordinator): O agente pai coordenador. O Coordinator gerencia os commits de branch no Git, executa as verificaçõesdart analyze && dart teste 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 agente | Caminho de leitura permitido | Caminho de escrita permitido | Açõ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:
// 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 implementarIterablecomo 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
hasattrem alguns pontos. Precisei refinartdd-dart-architect/SKILL.mdpara 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-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:
// 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!
- Baixe o Antigravity.
- Visite a documentação de introdução ao AGY para aprender a definir seus próprios agentes e skills personalizadas para desenvolvedores.
- Confira os arquivos reais de skill que criei enquanto trabalhava neste projeto, modifique-os para atender às suas necessidades e nos conte como foi!