TL;DR

La plupart des erreurs des agents IA ne viennent pas du code. Elles viennent des suppositions.

Dans Antigravity, la commande /grill-me force l’agent à arrêter d’exécuter… pour commencer à réfléchir.

Au lieu de générer du code immédiatement, l’agent :

• pose des questions,
• clarifie les besoins,
• identifie les zones floues,
• challenge les choix techniques,
• valide l’architecture avant d’écrire une seule ligne.

Et honnêtement ?

C’est probablement l’une des meilleures habitudes à adopter quand on travaille avec des agents IA.

🤖 Le vrai problème des agents IA

Les agents modernes sont impressionnants.

Tu leur donnes :

“Crée-moi un module PrestaShop avec synchronisation API et dashboard admin.”

Et ils partent immédiatement en production.

Le problème : ils partent souvent… dans leur propre direction.

Pourquoi ?

Parce qu’un agent IA :

• complète les blancs,
• interprète les intentions,
• suppose des contraintes,
• imagine des comportements métier.

Résultat : tu récupères parfois :

• une mauvaise architecture,
• des hypothèses métier erronées,
• une stack non désirée,
• des choix techniques impossibles à maintenir,
• ou simplement… quelque chose qui ne correspond pas à ton besoin réel.

Le pire ? Le code peut être techniquement bon.

Mais totalement hors sujet.

🔥 /grill-me inverse complètement la dynamique

La commande /grill-me change le comportement de l’agent.

Au lieu de :

“On code immédiatement.”

L’agent passe en mode :

“On vais d’abord comprendre exactement ce que tu veux.”

C’est littéralement un interrogatoire technique.

L’agent commence alors à :

• poser des questions ciblées,
• demander des exemples,
• clarifier les cas limites,
• vérifier les contraintes,
• identifier les ambiguïtés,
• valider les priorités,
• anticiper les problèmes d’architecture.

Et ça change tout.

🧠 Pourquoi cette approche est extrêmement puissante

1. Elle réduit les hallucinations métier

Un agent IA hallucine rarement la syntaxe.

Il hallucine surtout :

• les intentions,
• les besoins,
• les workflows,
• les règles métier implicites.

/grill-me réduit énormément ce problème.

2. Elle force la clarification des specs

La majorité des projets ont des specs floues.

Et souvent : le développeur humain lui-même n’a pas encore totalement clarifié son besoin.

Le mode /grill-me agit alors comme :

• un architecte,
• un Product Owner,
• un lead technique,
• un challenger fonctionnel.

L’agent devient un outil de raffinage des exigences.

3. Elle évite les mauvais départs

Un mauvais départ IA coûte cher :

• refactoring,
• réécriture,
• perte de contexte,
• dette technique,
• architecture fragile.

Quelques minutes de questions intelligentes peuvent éviter des heures de correction.

⚙️ Exemple concret

Tu demandes :

“Crée-moi un système de synchronisation ERP pour PrestaShop.”

Sans /grill-me, l’agent pourrait :

• choisir la mauvaise stratégie de sync,
• supposer un flux temps réel,
• ignorer les contraintes volumétriques,
• créer une architecture non scalable,
• oublier les retries,
• ignorer les conflits de données.

Avec /grill-me, l’agent pourrait demander :

• Quelle est la source de vérité ?
• La sync est-elle bidirectionnelle ?
• Quel volume produit ?
• Temps réel ou batch ?
• Gestion des conflits ?
• SLA attendu ?
• Multi-boutique ?
• Compatibilité PrestaShop cible ?
• API REST ou SOAP ?
• Gestion des retries ?
• Queue système ?
• Idempotence requise ?
• Tolérance aux pannes ?

Et soudain : on ne parle plus simplement de “générer du code”.

On parle de : concevoir correctement un système.

🚀 Les autres commandes essentielles dans Antigravity

/goal

/goal fait exactement l’inverse de /grill-me.

Ici : l’agent reçoit un objectif final et avance en autonomie complète jusqu’à ce qu’il soit atteint.

Exemple :

/goal Corrige tous les tests cassés et stabilise la CI

L’agent :

• planifie,
• exécute,
• corrige,
• itère,
• valide.

Sans demander de validation intermédiaire.

C’est extrêmement puissant pour :

• les refactorings,
• les fixes CI/CD,
• les migrations,
• les tâches répétitives,
• les workflows bien cadrés.

/schedule

Cette commande permet de lancer des tâches en arrière-plan.

Typiquement :

• jobs planifiés,
• exécutions différées,
• automatisations récurrentes,
• cron jobs IA.

Exemple :

/schedule Analyse les logs chaque nuit à 2h

Très utile pour :

• monitoring,
• QA automatique,
• audits,
• veille technique,
• maintenance proactive.

/browser

Cette commande force explicitement l’usage du sous-agent web.

L’agent peut alors :

• naviguer,
• interagir avec des pages,
• tester des interfaces,
• faire des recherches,
• inspecter un rendu.

Exemple :

/browser Teste le checkout mobile du site

Très pratique pour :

• QA frontend,
• scraping,
• debugging UI,
• vérification SEO,
• tests utilisateurs automatisés.

🏗️ Le vrai changement : passer du “prompting” à l’orchestration

Les développeurs qui performent avec les agents IA ne sont plus simplement ceux qui “écrivent de bons prompts”.

Ce sont ceux qui savent :

• orchestrer,
• cadrer,
• découper,
• superviser,
• valider les hypothèses,
• contrôler le contexte.

/grill-me est intéressant parce qu’il formalise cette idée.

Le développeur ne devient pas moins important.

Au contraire.

Son rôle évolue vers :

• l’arbitrage,
• la clarification,
• l’architecture,
• la supervision stratégique.

L’agent exécute. L’humain pilote.

✅ Quand utiliser /grill-me

Utilise-le systématiquement pour :

• les architectures complexes,
• les modules e-commerce,
• les workflows métier,
• les intégrations API,
• les systèmes multi-services,
• les migrations,
• les projets IA,
• les pipelines automation,
• les sujets où une mauvaise hypothèse coûte cher.

❌ Quand éviter /grill-me

Pas nécessaire pour :

• une petite fonction isolée,
• un fix trivial,
• une tâche ultra cadrée,
• une opération mécanique simple.

Dans ces cas-là : /goal sera souvent plus rapide.

🎯 Conclusion

Le plus gros risque avec les agents IA n’est pas qu’ils codent mal.

C’est qu’ils codent vite… dans la mauvaise direction.

/grill-me agit comme un garde-fou intelligent :

• il ralentit volontairement le démarrage,
• pour accélérer tout le reste du projet.

Et plus les agents deviennent autonomes, plus cette étape de clarification devient critique.

Parce qu’au final :

Un agent IA très rapide avec de mauvaises hypothèses reste… un accélérateur d’erreurs.

— Nicolas Dabène