1. Introdução
Neste codelab, você vai criar um sistema de auditoria de qualidade de código multilíngue e correção automatizada usando a orquestração multiagente paralela no Antigravity. Em vez de uma revisão tradicional, manual e linear de vários diretórios de serviço separados, você vai implantar subagentes de IA especializados para inspecionar diferentes pilhas de linguagem em paralelo.
Você vai criar um agente coordenador para descobrir o layout do projeto, gerenciar subagentes para executar testes de unidade, construir um plano de auditoria, verificar a conformidade, criar um relatório de auditoria e refatorar de forma autônoma problemas de codificação de alta prioridade na base de código.
O que você vai aprender
- Descoberta de projetos:como implantar um agente coordenador para mapear diretórios e detectar linguagens de programação em uma arquitetura complexa de microsserviços.
- Paralelismo orquestrado:como distribuir auditorias de código e testes de unidade em subagentes de IA independentes e específicos de linguagem simultaneamente.
- Supervisão humana no loop:como orientar um agente coordenador para construir um plano de auditoria e pausar com segurança para sua revisão e aprovação antes da execução.
- Correção automatizada:como implantar subagentes de desenvolvedores especializados para refatorar e resolver de forma autônoma problemas de codificação e conformidade de alta prioridade.
- Loops de verificação:como verificar as mudanças de código geradas por IA executando novamente os conjuntos de testes automaticamente para garantir que nenhuma regressão seja introduzida.
O que é necessário
Para este codelab, você vai precisar das seguintes ferramentas instaladas localmente:
- Google Antigravity
- Git
- Uma ou mais das seguintes linguagens configuradas no seu ambiente: Go, Python, C# / .NET, NodeJS, Java
Vamos começar!
2. Configuração do ambiente
Primeiro, verifique se o Antigravity está instalado.
Em segundo lugar, clone o Online Boutique, um aplicativo de demonstração de microsserviços na nuvem:
git clone https://github.com/GoogleCloudPlatform/microservices-demo.git
Crie um novo projeto no Antigravity com o código. No Antigravity, selecione Create New Project em Projects no lado esquerdo:
Selecione a pasta do repositório:
Você pode escolher o modo Default para Agent Security Settings e usar o mesmo nome microservices-demo para o projeto.
3. Discovery
Em uma arquitetura de microsserviços, uma base de código normalmente envolve vários serviços que abrangem várias pastas ou repositórios e pilhas de programação. Isso também é válido para o aplicativo de demonstração Online Boutique.
Antes de iniciar os agentes, vamos descobrir o layout do projeto. Nesta primeira etapa, você vai implantar um agente coordenador com o Antigravity que descobre vários microsserviços em diferentes linguagens em src/ e coordena subagentes específicos de linguagem para trabalhar em cada microsserviço nas etapas posteriores.
Primeiro, peça ao agente coordenador para explorar a base de código e mapear quais serviços existem em quais diretórios e quais linguagens eles usam.
No Antigravity, inicie uma nova conversa no projeto microservices-demo que você criou. Para o modelo, você pode usar o modelo do Gemini mais recente com um nível de raciocínio médio:
Tente este comando:
Identify all the microservices located under the src/ directory,
detect which programming language each service is written in, and
output the list as a clean markdown table showing: Service Name,
Directory, and Primary Language.
No final, o Antigravity vai retornar uma tabela de serviços e a linguagem principal deles, algo semelhante a isto:
4. Escolher idiomas
Agora que você mapeou a base de código, é necessário escolher os idiomas com que quer trabalhar. Verifique se você tem os compiladores/ferramentas necessários para os idiomas escolhidos (por exemplo, a ferramenta dotnet para C#, javac para Java etc.).
Depois de escolher os idiomas com que quer trabalhar, é fundamental verificar a integridade da base de código atual executando os testes de unidade respectivos para esse idioma.
Você pode usar subagentes especializados e paralelos para executar conjuntos de testes em cada idioma. Isso destaca o poder principal de um fluxo de trabalho multiagente: executar testes isolados simultaneamente em espaços de trabalho separados e específicos de linguagem.
Adapte e execute o comando a seguir para seu ambiente:
I have [C#, Python, Go, Java, Node.js] setup locally.
Run the unit tests for services in these languages
in parallel subagents and report back in a clean markdown
on their pass/fail status.
Você vai ver vários agentes executando testes em cada idioma. Revise cada subagente à medida que eles pedem permissões para executar ferramentas, conforme mostrado abaixo:
Quando todos os subagentes terminarem, você vai receber um relatório sobre os testes de unidade, semelhante ao seguinte:
5. Planejar a auditoria
Plano
Em fluxos de trabalho complexos, iniciar mudanças de código sem um plano pode levar a conflitos. Queremos estabelecer um projeto estruturado e transparente do que pretendemos auditar. Você vai pedir ao agente coordenador para criar um plano de auditoria com as verificações de qualidade do código, tratamento de exceções, verificações de higiene de consultas e assim por diante.
Para garantir a supervisão humana (humano no loop), o coordenador vai escrever o plano em um artefato e pausar imediatamente para sua revisão.
Tente este comando para criar um plano de auditoria:
We want to audit these microservices for code quality,
exception handling and database query formatting standards
for the languages I have set up locally. Design an audit plan
detailing what you will check and save it as an Audit Plan artifact.
Do not execute the audit yet. Stop after writing the plan and wait
for my instructions.
Você vai ver um artefato do plano de auditoria na conversa:
Revisar
Agora você vai inspecionar o plano de auditoria gerado para garantir que ele tenha como destino os arquivos e padrões corretos. Opcionalmente, você pode adicionar restrições personalizadas (como verificar comentários inline ou guias de estilo) antes de dar a aprovação para continuar.
Clique no plano de auditoria gerado para ver o plano detalhado:
Opcional: você pode adicionar comentários ao plano (por exemplo, "verifique se todos os métodos públicos estão bem documentados") se quiser fazer mudanças e iterar nele até ficar satisfeito com o plano.
6. Executar a auditoria
Executar
Com o plano de auditoria aprovado, vamos executar a auditoria. O agente coordenador vai gerar subagentes paralelos independentes para cada pilha de linguagem. Cada agente opera simultaneamente na própria pasta de serviço, evitando conflitos de arquivos e acelerando o processo de verificação. O agente coordenador vai mesclar as descobertas em um painel de qualidade unificado.
Confira o comando a seguir:
Execute the audit plan by spawning the parallel language subagents.
Once they finish scanning, collect their findings into an audit
report artifact, sorted by language and then priority. Include the
file paths, line ranges, snippets, and explanation of why it is a
finding. Stop after writing the report.
Você vai ver vários agentes novamente:
Assista a cada subagente e conceda as permissões necessárias para executar a auditoria. No final, você vai ver um artefato do relatório de auditoria:
Revisar
Ao abrir o relatório de auditoria, você também vai ver descobertas detalhadas para cada idioma. Por exemplo, confira um problema de alta prioridade de cartservice em C#:
Confira o restante do relatório de auditoria para ver as descobertas.
7. Correção
Diagnosticar problemas de qualidade do código é apenas metade da batalha. Agora, vamos usar agentes para resolver os problemas. Em vez de escrever o código manualmente, podemos delegar a refatoração a subagentes de desenvolvedores com escopo de linguagem, que podem reescrever o código para estar em conformidade com as práticas recomendadas.
Há diferentes maneiras de tentar isso:
- Você pode gerar um agente por idioma e permitir que todos os agentes corrijam todos os problemas de uma só vez. Isso pode funcionar, mas também pode ser muito difícil de acompanhar e revisar ao mesmo tempo.
- Você pode gerar um agente para um idioma por vez e permitir que ele processe problemas para esse idioma. Isso será mais gerenciável, mas ainda é necessário confiar no agente para fazer várias mudanças em vários arquivos.
- Você pode ter um agente que processa um problema por vez enquanto verifica o resultado antes de passar para o próximo problema. Essa é uma abordagem mais conservadora, mas também garante que você fique no loop de cada mudança.
Vamos usar a abordagem mais conservadora nº 3 com o seguinte comando:
Select the top high-priority finding in [pick a language, e.g., C#]
and remediate the finding. Show me the code changes once complete.
Após alguns segundos, o agente vai trabalhar na prioridade máxima no idioma escolhido e corrigi-la.
No final, você também pode receber um artefato de tutorial mostrando o que o agente mudou:
Opcional:neste ponto, você pode pedir ao agente para mudar a implementação ou, se estiver satisfeito com as mudanças, pedir que ele adicione um novo teste de unidade para cobrir as mudanças.
8. Verificação
No desenvolvimento de software, uma correção não é concluída até ser verificada. Nesta etapa final, podemos pedir ao agente para executar o conjunto de testes para garantir que as mudanças de código não introduzam regressões e executar novamente o scanner de auditoria para verificar se o problema foi totalmente resolvido.
Esta etapa mostra o loop de feedback automatizado completo de planejamento, verificação, correção e verificação.
Execute o seguinte comando:
Rerun the unit tests for the changed language. If they pass, rerun
the relevant audit agent to check if the finding is resolved. If it
is resolved, mark the issue as resolved in the audit report.
Você vai ver um subagente do Test Runner sendo iniciado e executando os testes. Em seguida, um subagente do Auditor vai atualizar o relatório de auditoria. No final, você vai ver o relatório de auditoria atualizado com o status mais recente:
Um problema resolvido! Agora, você pode analisar o restante dos problemas, talvez usando uma abordagem menos conservadora desta vez, em que permite que os agentes façam mais trabalho antes de revisar.
9. Parabéns
Parabéns! Você acabou de concluir um fluxo de trabalho complexo de revisão de código multilíngue e correção automatizada usando o Antigravity.
Ao aproveitar a arquitetura multiagente do Antigravity, você não apenas automatizou as verificações estáticas, mas também orquestrou uma equipe automatizada de garantia de qualidade. Enquanto agentes de linguagem especializados trabalhavam simultaneamente em problemas específicos de linguagem, o agente coordenador compilou um plano e um relatório centralizados e, posteriormente, gerenciou uma refatoração de código direcionada.
Conclusões importantes
- Paralelismo orquestrado: você aprendeu a distribuir auditorias e testes em subagentes independentes e específicos de linguagem em execução paralela, evitando gargalos de revisão linear.
- Human-in-the-Loop: ao revisar e anotar o plano de auditoria gerado antes da execução, você manteve a supervisão das operações autônomas.
- Correção e verificação automatizadas: você viu como os agentes de IA podem não apenas diagnosticar discrepâncias de qualidade do código, mas também refatorar o código e verificar as próprias mudanças em relação aos conjuntos de testes locais.