1. Introduction
Dans cet atelier de programmation, vous allez créer un système d'audit de la qualité du code multilingue et de correction automatisée à l'aide de l'orchestration multi-agents parallèle dans Antigravity. Au lieu d'examiner manuellement et de manière linéaire plusieurs répertoires de services distincts, vous déployez des sous-agents d'IA spécialisés pour inspecter différentes piles de langages en parallèle.
Vous allez créer un agent coordinateur pour découvrir la mise en page du projet, gérer les sous-agents pour exécuter les tests unitaires, élaborer un plan d'audit, rechercher la conformité, créer un rapport d'audit et refactoriser de manière autonome les problèmes de codage de haute priorité dans la codebase.
Points abordés
- Découverte de projet : découvrez comment déployer un agent coordinateur pour cartographier les répertoires et détecter les langages de programmation dans une architecture de microservices complexe.
- Parallélisme orchestré : découvrez comment répartir les audits de code et les tests unitaires sur des sous-agents d'IA indépendants et spécifiques à une langue, de manière simultanée.
- Supervision avec intervention humaine : découvrez comment guider un agent coordinateur pour qu'il élabore un plan d'audit et le mette en pause de manière sécurisée pour que vous puissiez l'examiner et l'approuver avant son exécution.
- Correction automatisée : découvrez comment déployer des sous-agents développeurs spécialisés pour refactoriser et résoudre de manière autonome les problèmes de codage et de conformité de haute priorité.
- Boucles de validation : découvrez comment valider les modifications de code générées par l'IA en réexécutant automatiquement les suites de tests pour vous assurer qu'aucune régression n'a été introduite.
Prérequis
Pour cet atelier de programmation, vous aurez besoin des outils suivants installés en local :
- Google Antigravity
- Git
- Un ou plusieurs des langages suivants configurés dans votre environnement : Go, Python, C# / .NET, NodeJS, Java
C'est parti !
2. Configuration de l'environnement
Tout d'abord, assurez-vous d'avoir installé Antigravity.
Ensuite, clonez Online Boutique, une application de démonstration de microservices cloud :
git clone https://github.com/GoogleCloudPlatform/microservices-demo.git
Créez un projet dans Antigravity avec le code. Dans Antigravity, sélectionnez Create New Project sous Projects sur la gauche :
Sélectionnez le dossier du dépôt :
Vous pouvez choisir le mode Default pour Agent Security Settings et utiliser le même nom microservices-demo pour le projet.
3. Discovery
Dans une architecture de microservices, une base de code implique généralement plusieurs services répartis sur plusieurs dossiers ou dépôts et piles de programmation. Cela vaut également pour l'application de démonstration Online Boutique.
Avant de lancer les agents, découvrons la structure du projet. Dans cette première étape, vous allez déployer un agent coordinateur avec Antigravity qui découvre différents microservices dans différentes langues sous src/ et coordonne les sous-agents spécifiques à la langue pour qu'ils travaillent sur chaque microservice lors des étapes ultérieures.
Commençons par demander à l'agent coordinateur d'explorer la base de code et de cartographier les services existants dans les répertoires, ainsi que les langages qu'ils utilisent.
Dans Antigravity, lancez une nouvelle conversation dans le projet microservices-demo que vous avez créé précédemment. Pour le modèle, vous pouvez choisir le dernier modèle Gemini avec un niveau de réflexion moyen :
Essayez ce prompt :
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.
À la fin, Antigravity devrait renvoyer un tableau des services et de leur langue principale, comme celui-ci :
4. Sélectionner des langues
Maintenant que vous avez cartographié la base de code, vous devez choisir les langues avec lesquelles vous souhaitez travailler. Vous devez vous assurer de disposer des compilateurs/outils nécessaires pour les langages que vous choisissez (par exemple, l'outil dotnet pour C#, javac pour Java, etc.).
Une fois que vous avez choisi les langues avec lesquelles vous souhaitez travailler, il est essentiel de vérifier l'état de la base de code actuelle en exécutant les tests unitaires correspondants pour cette langue.
Vous pouvez utiliser des sous-agents spécialisés et parallèles pour exécuter des suites de tests dans chaque langue. Cela met en évidence la puissance d'un workflow multi-agent : exécuter des tests isolés simultanément dans des espaces de travail distincts spécifiques à une langue.
Adaptez et exécutez le prompt suivant pour votre environnement :
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.
Vous devriez voir plusieurs agents exécuter des tests dans chaque langue. Assurez-vous d'examiner chaque sous-agent lorsqu'il demande l'autorisation d'exécuter des outils, comme indiqué ci-dessous :
Une fois que tous les sous-agents ont terminé, vous devriez recevoir un rapport détaillé sur les tests unitaires, semblable à celui-ci :
5. Planifier l'audit
Plan
Dans les workflows complexes, le lancement de modifications de code sans plan peut entraîner des conflits. Nous souhaitons établir un plan structuré et transparent de ce que nous avons l'intention d'auditer. Vous demanderez à l'agent coordinateur de concevoir un plan d'audit avec des vérifications de la qualité du code, de la gestion des exceptions, de l'hygiène des requêtes, etc.
Pour garantir une supervision humaine (human-in-the-loop), le coordinateur rédige le plan dans un artefact et le met immédiatement en pause pour que vous puissiez l'examiner.
Essayez ce prompt pour élaborer un plan d'audit :
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.
Un artefact de plan d'audit devrait s'afficher dans le chat :
Récapitulatif
Vous allez maintenant inspecter le plan d'audit généré pour vous assurer qu'il cible les fichiers et les normes appropriés. Si vous le souhaitez, vous pouvez ajouter des contraintes personnalisées (par exemple, vérifier les commentaires intégrés ou les guides de style) avant de donner votre accord pour continuer.
Cliquez sur le plan d'audit généré pour afficher le plan détaillé :
Facultatif : Vous pouvez ajouter des commentaires au plan (par exemple, "assurez-vous que toutes les méthodes publiques sont bien documentées") si vous souhaitez apporter des modifications et les répéter jusqu'à ce que le plan vous convienne.
6. Exécuter l'audit
Exécuter
Une fois le plan d'audit approuvé, passons à l'exécution de l'audit. L'agent coordinateur générera des sous-agents parallèles indépendants pour chaque pile de langages. Chaque agent fonctionne simultanément dans son propre dossier de service, ce qui évite les conflits de fichiers et accélère le processus d'analyse. L'agent coordinateur fusionnera les résultats dans un tableau de bord de qualité unifié.
Voici le prompt à essayer ensuite :
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.
Vous devriez à nouveau voir plusieurs agents :
Assurez-vous de surveiller chaque sous-agent et de lui accorder les autorisations dont il a besoin pour exécuter son audit. À la fin, vous devriez voir un artefact de rapport d'audit :
Récapitulatif
Une fois le rapport d'audit ouvert, vous devriez également voir des résultats détaillés pour chaque langue. Par exemple, voici un problème de priorité élevée provenant de cartservice en C# :
Consultez le reste du rapport d'audit pour découvrir les résultats.
7. Correction
Diagnostiquer les problèmes de qualité du code ne représente que la moitié du travail. Nous allons maintenant utiliser des agents pour résoudre les problèmes. Au lieu d'écrire du code manuellement, nous pouvons déléguer la refactorisation à des sous-agents de développement spécifiques à la langue, qui peuvent réécrire le code pour qu'il respecte les bonnes pratiques.
Voici différentes façons de procéder :
- Vous pouvez générer un agent par langue et laisser tous les agents résoudre tous les problèmes à la fois. Cette méthode peut fonctionner, mais il peut être difficile de tout suivre et d'examiner en même temps.
- Vous pouvez générer un agent pour une langue à la fois et le laisser gérer les problèmes pour cette langue. Cela sera plus facile à gérer, mais vous devez toujours pouvoir faire confiance à l'agent pour effectuer plusieurs modifications sur plusieurs fichiers.
- Vous pouvez demander à un agent de traiter un problème à la fois, puis vérifier le résultat avant de passer au problème suivant. Cette approche est plus prudente, mais elle vous permet également de rester informé de chaque modification.
Nous allons choisir l'approche 3, plus prudente, avec la requête suivante :
Select the top high-priority finding in [pick a language, e.g., C#]
and remediate the finding. Show me the code changes once complete.
Au bout de quelques secondes, l'agent devrait s'occuper du problème le plus urgent dans la langue de votre choix et le résoudre.
Enfin, vous pouvez également obtenir un artefact Procédure pas à pas qui vous montre ce que l'agent a modifié :
Facultatif : À ce stade, vous pouvez demander à l'agent de modifier l'implémentation. Si vous êtes satisfait des modifications, vous pouvez lui demander d'ajouter un test unitaire pour les couvrir.
8. Validation
Dans le développement logiciel, une correction n'est pas terminée tant qu'elle n'a pas été vérifiée. Dans cette dernière étape, nous pouvons demander à l'agent d'exécuter la suite de tests pour nous assurer que les modifications apportées au code n'ont pas introduit de régression, et de relancer l'outil d'analyse d'audit pour vérifier que le problème est entièrement résolu.
Cette étape montre la boucle de rétroaction automatisée complète de la planification, de l'analyse, de la correction et de la vérification.
Exécutez la requête suivante :
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.
Un sous-agent Test Runner devrait se lancer et exécuter les tests, puis un sous-agent Auditor devrait mettre à jour le rapport d'audit. Au final, le rapport d'audit devrait être mis à jour avec le dernier état :
Un problème de moins ! Vous pouvez maintenant passer en revue le reste des problèmes, en adoptant peut-être une approche moins conservatrice cette fois-ci, où vous laissez les agents faire plus de travail avant de les examiner.
9. Félicitations
Félicitations ! Vous venez de terminer un workflow complexe de révision de code multilingue et de correction automatisée à l'aide d'Antigravity.
Grâce à l'architecture multi-agents d'Antigravity, vous n'avez pas seulement automatisé les vérifications statiques, vous avez orchestré une équipe d'assurance qualité automatisée. Pendant que des agents linguistiques spécialisés travaillaient simultanément sur des problèmes spécifiques à la langue, votre agent coordinateur compilait un plan et un rapport centralisés, puis gérait une refactorisation ciblée du code.
Points clés à retenir
- Parallélisme orchestré : vous avez appris à distribuer les audits et les tests sur des sous-agents indépendants et spécifiques à une langue, qui s'exécutent en parallèle, ce qui permet d'éviter les goulots d'étranglement liés à l'examen linéaire.
- Human-in-the-Loop : en examinant et en annotant le plan d'audit généré avant son exécution, vous avez conservé la supervision des opérations autonomes.
- Correction et validation automatiques : vous avez vu comment les agents d'IA peuvent non seulement diagnostiquer les différences de qualité du code, mais aussi refactoriser le code et valider leurs propres modifications par rapport aux suites de tests locales.