Google Antigravity : une avancée pour les agents IA

L'ère de l'intelligence artificielle centrée sur les agents est bel et bien arrivée, et Google Antigravity se positionne comme un acteur clé dans cette révolution. Cet outil offre des possibilités inédites pour construire des agents IA hautement personnalisables, en s'appuyant sur trois concepts fondamentaux : les règles, les compétences et les workflows.

Explorer les concepts clés de Google Antigravity

Règles : Les règles sont les contraintes de base qui dictent le comportement des agents. Elles permettent d'adapter l'agent à des normes spécifiques, comme le formatage du code selon les standards PEP 8. Ces règles sont définies dans des fichiers markdown, ce qui facilite leur gestion et leur mise à jour. Par exemple, une règle pourrait stipuler que tout code doit être formaté avec l'outil black, et que seules des bibliothèques open-source peuvent être utilisées pour garantir la compatibilité du projet.

Compétences : Les compétences représentent des ensembles de connaissances que l'agent utilise pour accomplir des tâches spécifiques. Par exemple, une compétence peut être dédiée à la génération de tests pour le code Python. Ces compétences sont stockées dans un dossier dédié contenant un fichier SKILL.md, ce qui permet de les réutiliser facilement dans différents projets. Une compétence pourrait inclure la capacité de générer des tests unitaires à l'aide de Pytest, un outil populaire dans le développement Python.

Workflows : Les workflows orchestrent l'ensemble des actions de l'agent, guidant celui-ci à travers un plan d'action bien structuré. Ils sont invoqués par des commandes spécifiques, telles que /deploy, et permettent d'automatiser des tâches complexes sans perte de précision. Un workflow typique pourrait inclure plusieurs étapes, telles que la révision du code, sa refactorisation, et la génération de tests, le tout coordonné de manière fluide par l'agent.

Mise en pratique : configurer un agent QA pour le code

Pour illustrer l'efficacité de Google Antigravity, nous allons configurer un workflow d'agent d'assurance qualité (QA) pour le code Python. Avant de commencer, il est essentiel de télécharger et d'installer Google Antigravity sur votre ordinateur. Une fois l'installation terminée, ouvrez l'application de bureau et créez un dossier de projet Python.

Dans la racine du répertoire du projet, créez un dossier nommé .agents. À l'intérieur de ce dossier, créez deux sous-dossiers : rules et skills. Ces dossiers serviront à définir les règles et les compétences de notre agent.

Définir une règle de style Python

Commençons par définir une règle qui garantira l'adhésion de l'agent aux normes de formatage Python. Créez un fichier nommé python-style.md dans le sous-dossier rules et collez-y le contenu suivant :

# Règle de Style Python

Toujours utiliser les normes PEP 8. Lors de la fourniture ou de la refactorisation de code, supposez que nous utilisons black pour le formatage. Gardez les dépendances strictement aux bibliothèques libres et open-source pour garantir que notre projet reste compatible avec le libre.

Pour personnaliser cette règle, ouvrez le panneau de personnalisation de l'agent et sélectionnez la règle que vous venez de définir. Réglez le modèle d'activation sur "glob" et spécifiez le motif glob : **/*.py.

### Enseigner des compétences à l'agent

Ensuite, nous allons enseigner à l'agent une compétence essentielle : réaliser des tests robustes sur le code Python. Dans le sous-dossier **skills**, créez un dossier nommé **pytest-generator**. À l'intérieur, créez un fichier **SKILL.md** avec le contenu suivant :

Compétence : Générateur de tests Pytest

Cette compétence permet à l'agent de générer des tests unitaires complets pour le code Python, en utilisant le framework Pytest.

### Intégrer les éléments et exécuter l'agent

Pour mettre en œuvre ces éléments, nous allons créer un fichier Python contenant du code "de mauvaise qualité" dans notre espace de travail. Par exemple, créez un fichier nommé **flawed_division.py** avec le code suivant :

```python
def divide_numbers(x, y):

Ce code est intentionnellement désordonné pour tester les capacités de notre agent. Créez un nouveau workflow nommé qa-check avec le contenu suivant :

# Titre : Vérification QA Python

# Description : Automatise la révision de code et la génération de tests pour les fichiers Python.

- Étape 1 : Réviser le fichier Python actuellement ouvert pour détecter les bogues et les problèmes de style, en respectant notre règle de style Python.
- Étape 2 : Refactoriser tout code inefficace.
- Étape 3 : Appeler la compétence **pytest-generator** pour écrire des tests unitaires complets pour le code refactorisé.
- Étape 4 : Sortir le code de test final et suggérer d'exécuter **pytest** dans le terminal.

Avec le fichier Python désordonné ouvert, activez l'agent en tapant la commande qa-check et en appuyant sur Entrée pour exécuter le workflow.

Résultats obtenus par l'agent

Après l'exécution, l'agent révisera le code et proposera automatiquement une nouvelle version dans le fichier Python. De plus, il générera des tests unitaires complets que vous pourrez utiliser pour exécuter différents types de tests avec pytest. Voici un exemple de ce que ces tests pourraient inclure :

from flawed_division import divide_numbers

def test_divide_numbers_normal():
    assert divide_numbers(10, 2) == 5.0
    assert divide_numbers(9, 3) == 3.0

def test_divide_numbers_negative():
    assert divide_numbers(-10, 2) == -5.0
    assert divide_numbers(10, -2) == -5.0
    assert divide_numbers(-10, -2) == 5.0

def test_divide_numbers_float():
    assert divide_numbers(5.0, 2.0) == 2.5

def test_divide_numbers_zero_numerator():
    assert divide_numbers(0, 5) == 0.0

def test_divide_numbers_zero_denominator():
    with pytest.raises(ValueError, match="Cannot divide by zero"):
        divide_numbers(10, 0)

En conclusion, Google Antigravity permet de transformer des agents génériques en outils spécialisés, capables de gérer efficacement des tâches complexes et répétitives dans le développement logiciel. Grâce à l'intégration de règles, de compétences et de workflows, les développeurs peuvent désormais automatiser des processus entiers, améliorant ainsi la qualité et l'efficacité de leurs projets.