L'IA Coder de Google est arrivée. C'est incroyablement impressionnant.

La plupart des gens utilisent mal les codeurs IA. Ils ouvrent une fenêtre de chat, tapent une demande vague et espèrent qu'un mur de code apparaît, qui compile, s'échelonne et passe l'examen de sécurité. Ce flux de travail basé sur la « demande et l'espérance » considère les modèles avancés comme un Clippy plus intelligent au lieu de ce qu'ils sont réellement : des moteurs pour un développement logiciel structuré et de bout en bout.

Google Antigravity révolutionne l'état d'esprit des chatbots. Présenté comme un « IDE centré sur l'agent », il vous pousse à penser en projets, et non en invites : des dépôts à gauche, du code au centre, des agents IA spécialisés à droite. Vous ne vous contentez pas de dialoguer avec un modèle ; vous orchestrez un système qui planifie, conçoit, met en œuvre et affine une application entière.

Pensez-y comme le fait Jack Roberts : Word est pour les documents, Excel est pour les tableurs, et Antigravity est pour créer des logiciels. Vous créez un espace de travail, définissez le problème, puis confiez des tâches cohérentes à des agents alimentés par Gemini 3, Claude et des modèles basés sur GPT. Chaque agent se spécialise—planification, mise en page, mise en œuvre—de sorte que le flux de travail ressemble davantage à une petite équipe de développement qu'à une simple boîte de saisie automatique.

Utilisé de cette manière, Antigravity cesse d'être un « assistant de code » et commence à agir comme un développeur autonome. Il peut : - Décomposer une idée de produit floue en une spécification concrète - Générer des mises en page d'interface utilisateur à partir de textes et d'images de référence - Connecter un frontend, un backend et une couche de données fonctionnels en un seul flux, tout en suivant les fichiers, les dépendances et les règles de conception au sein d'un projet persistant.

La promesse de Roberts est ambitieuse : des applications de qualité supérieure développées jusqu'à 10 fois plus vite que le développeur solo moyen à l'œuvre avec un chatbot. La rapidité ne résulte pas seulement d'une frappe plus rapide ; elle provient de l'élimination des reprises. Vous investissez du temps au départ pour définir le problème, établir des contraintes et fournir des directives de marque, puis laissez les agents agir dans ce cadre.

Utilisé comme un environnement de développement structuré, Antigravity transforme la programmation par intelligence artificielle d'un tour de magie en un pipeline répétable. L'écart entre « idée dans votre tête » et « application fonctionnant sur votre machine » se réduit considérablement—si vous cessez de discuter et commencez à construire comme l'outil l'attend.

Les IDEs pilotés par des agents renversent le flux de développement habituel. Au lieu d'un assistant qui réagit à vos demandes, vous gérez une équipe d'agents autonomes qui prennent en charge les tâches de A à Z : définition des besoins, planification, codage et débogage. Vous cessez de micromanager les modifications ligne par ligne et commencez à attribuer des résultats : « Livrez un tableau de bord de facturation réactif en utilisant mes lignes directrices de marque et cette maquette Figma. »

L'Antigravity de Google s'inscrit parfaitement dans ce modèle. Vous travaillez toujours dans un dossier de projet familier, mais l'IDE suppose que les agents toucheront à chaque fichier, généreront des artefacts et itéreront sans que vous ayez à accompagner chaque étape. Votre travail consiste à définir précisément les problèmes, à sélectionner des ressources et à examiner ce que les agents produisent.

L'interface d'Antigravity se divise en trois colonnes verticales qui illustrent ce nouveau flux de travail. À gauche, un arbre de fichiers standard révèle la structure de votre projet : code source, images, spécifications en markdown, PDFs de la marque et modèles de prompts. Vous considérez cet arbre comme la base de connaissances des agents, y déposant tout, des packs de logos aux procédures opérationnelles standard dans des fichiers .md.

Le panneau central agit comme un viseur de code et d'artefacts. Les agents ne se contentent pas de produire des blocs de texte ; ils créent des artefacts structurés tels que des plans de mise en œuvre, des mises en page UI et des diffs de refactoring que vous pouvez parcourir rapidement. Vous naviguez entre les fichiers et les artefacts comme entre des onglets de navigateur, laissant des commentaires et des corrections directement sur le travail généré.

Sur la droite, le chat d'agent ancre tout le système. C'est ici que vous choisissez les modes d'agent tels que "Planification" pour des constructions en plusieurs étapes ou "Rapide" pour des modifications rapides, collez des énoncés de problèmes et joignez des images ou des documents de référence. Au lieu de demander "écris une fonction", vous assignez des tâches multipartites comme "concevoir, mettre en œuvre et câbler un tableau de bord de dépenses complet avec graphiques et filtres."

Le support multi-modèles transforme Antigravity en un méta-IDE pour l'IA. Dans un seul espace de travail, vous pouvez diriger des tâches vers : - Gemini 3 pour des interfaces utilisateur axées sur le design et des flux de travail natifs de Google - Claude 4.5 Sonnet pour un raisonnement approfondi, l'architecture et le perfectionnement des spécifications - Les modèles ChatGPT pour des itérations rapides et des ajustements de code

Ce mélange est important car cette plateforme ne se limite pas à la génération de code. Antigravity se concentre sur la délégation de tâches et la résolution autonome de problèmes, où les agents se coordonnent à travers les fichiers, mettent à jour les ressources et affinent les conceptions jusqu'à ce que l'application soit réellement livrée.

Oubliez les invites. Flow est le système d'exploitation pour utiliser Google Antigravity afin de créer de véritables logiciels. Jack Roberts le divise en quatre étapes : Cadre, Mise en Page, Orchestration, Expédition — et si vous en omettez une, la qualité de votre application chute de façon vertigineuse.

Le cadre vient d'abord : vous définissez le problème avec une précision brutale. Roberts confie littéralement cela à Claude, lui demandant de remettre en question les hypothèses, de faire émerger les cas limites, puis de tout compresser en un SOP de 500 caractères qu'il pourra remettre à un agent. Cette courte spécification devient la seule source de vérité pour le développement.

La mise en page transforme des rêves d'interface utilisateur vagues en un contexte visuel concret. Vous collez des clichés Dribbble, téléchargez des directives de marque, glissez des logos et des PDF dans l'arborescence de fichiers Antigravity, et codifiez des règles dans un fichier markdown : polices, espacements, couleurs, ton. La pile de design Gemini 3 dispose alors de vraies contraintes, et non de simples impressions, sur lesquelles travailler.

Orchestrate est l'endroit où les agents d'Antigravity construisent réellement. Vous collez le SOP dans l'agent Planification, attachez vos ressources de mise en page et laissez-le décomposer le travail en artefacts : plans, composants, hooks API, tests. Vous ne gérez pas chaque ligne ; vous dirigez des agents parallèles qui peuvent refactoriser plusieurs fichiers, câbler des tableaux de bord et itérer par rapport à vos spécifications.

Le lancement marque la frontière entre l'expérimentation et le produit. Vous examinez les artefacts, exécutez les tests générés, peaufinez les textes et finalisez les fichiers versionnés dans votre dossier de projet. À partir de là, vous pouvez déployer, remettre à un client ou créer une v2 en utilisant le même script Flow.

Roberts martèle un point : les personnes qui "discutent" avec l'application Joe d'Antigravity. Les personnes qui gèrent Flow—Frame, Layout, Orchestrate, Ship—distribuent des applications professionnelles qui sont en accord avec l'image de marque, traitent des données réelles et sont reproductibles. Flow transforme Antigravity d'un simple système de saisie semi-automatique en un plan reproductible pour un logiciel sérieux.

Le cadrage consiste à décider ce que vous allez réellement construire, bien avant qu'Antigravity n'écrive une seule ligne de code. Au lieu de lancer un agent en disant "crée-moi une application", vous considérez cette étape comme une découverte de produit compressée en 20 minutes. Vous définissez des contraintes, des indicateurs de succès et des cas extrêmes alors que votre curseur se trouve encore dans un dossier vide.

Einstein aurait dit que s'il avait une heure pour résoudre un problème, il passerait 55 minutes sur le problème et 5 sur la solution. Voici l'état d'esprit : utilisez Claude ou Gemini comme un collaborateur impitoyable dont le rôle est de remettre en question vos idées. Vous ne lui demandez pas de coder ; vous lui demandez de s'attaquer à vos hypothèses.

Un bon prompt de cadrage ressemble davantage à une revue de document de conception qu'à une conversation décontractée. Par exemple : « Je veux un tableau de bord des factures domestiques qui suit les dépenses récurrentes, prédit les flux de trésorerie sur 90 jours et signale les anomalies. Remettez en question mon périmètre, posez des questions sur les contraintes manquantes et proposez des compromis entre complexité et maintenabilité. » Vous devez ensuite répondre à chaque question de suivi que Claude vous pose.

De bons agents vous interrogeront sur des détails spécifiques : les sources de données (APIs bancaires, téléchargements CSV, saisie manuelle), la fréquence de mise à jour (horaire ou quotidienne), les appareils cibles (uniquement sur ordinateur de bureau ou responsive) et les non-objectifs (pas de comptes multi-utilisateurs v1). Cette phase d'interrogation affine un "suivi des dépenses" flou en un produit v1 précis. Vous voulez que cela soit légèrement inconfortable, comme un examen exigeant de gestion de produit.

Une fois que l'idée est claire, vous la comprimez en une Procédure Opératoire Standard pour Antigravity. Jack Roberts limite cela à environ 500 caractères : un seul paragraphe dense qui indique quoi construire, pour qui, avec quelles fonctionnalités et à quoi ressemble un “terminé”. Considérez-le comme l’ADN du projet, et non comme un texte marketing.

Un SOP précis pourrait dire : « Créez une application web de tableau de bord des factures sur une seule page pour un utilisateur, qui ingère des uploads CSV, regroupe les dépenses par catégorie, affiche les totaux mensuels et les projections sur 3 mois, et met en évidence les dépassements en rouge. Priorisez une interface utilisateur propre, réactive, un chargement rapide, et une extension facile aux API bancaires plus tard. » Ce niveau de spécificité transforme Antigravity d'un simple outil d'autocomplétion en un co-fondateur fiable.

Le design est là où Antigravity cesse d'être une autocomplétion intelligente et commence à agir comme un vrai designer de produits. Vous passez d'énoncés de problèmes abstraits à une direction visuelle concrète, alimentant le système avec tout ce dont il a besoin pour imiter votre goût et votre marque sans avoir à les réexpliquer à chaque demande.

Roberts puise son inspiration de design directement sur Dribbble, copiant un mockup de tableau de bord de factures et collant l'image directement dans le chat d'Antigravity. Gemini 3 et les autres modèles peuvent désormais se référer à cette capture d'écran comme à une spécification de design en temps réel : espacement, palette de couleurs, structure des cartes, même le ton des microtextes. Au lieu de dire « rends-le joli », vous dites en réalité « fais-le ressembler à ça. »

Les visuels ne représentent que la moitié de la mise en page. Dans la section Design de la colonne de gauche, vous pouvez glisser : - des PDFs des lignes directrices de la marque - des logos et des ensembles d'icônes - des captures d'écran de référence - des jetons de couleur ou des documents de système de design

Ces fichiers deviennent une base de connaissances persistante pour les agents. Déposez un PDF de marque de 20 pages une seule fois, et chaque future mise en page, composant et état vide s’appuie sur les mêmes règles : codes hexadécimaux primaires, échelle typographique, système d'espacement, styles de boutons. Vous cessez de gaspiller des tokens et de l'énergie mentale à rappeler « utilisez Inter, 14px pour le corps, 24px pour les titres, cartes arrondies, pas d’ombres portées ».

Roberts va plus loin et crée un fichier markdown personnalisé, gemini.md, qui se trouve aux côtés du code. Ce fichier contient des instructions de conception explicites : règles de typographie, comportement de la grille, états des boutons, préférences de mouvement, même "ne jamais utiliser de dégradés" si c'est votre truc. Les agents le considèrent comme un contrat de conception vivant, le relisant chaque fois qu'ils génèrent une interface utilisateur, plutôt que de deviner à partir d'instructions vagues.

Chaque actif que vous ajoutez apparaît sous forme d'onglet dans le projet, tout comme un composant .tsx ou un script .py. Vous pouvez passer d'un fichier à l'autre, comme layout-inspiration.png, brand-guidelines.pdf et gemini.md, d'un simple clic, et l'IA fait de même en arrière-plan. Lorsque vous demandez « un nouveau panneau de paramètres qui correspond au tableau de bord », Antigravity ne fait pas d'improvisation ; il recoupe ces onglets ouverts.

La mise en page transforme Antigravity en un collaborateur conscient de la marque plutôt qu'en une usine d'interface utilisateur générique. En intégrant en amont des images, des PDF, des logos et des règles de markdown, vous obtenez un langage de design cohérent sur chaque écran, même si différents agents s'occupent de la planification, de l'implémentation et des restructurations. Cette cohérence est la différence entre une démo rapide et quelque chose qui ressemble réellement à un produit.

L'orchestration est l'endroit où Antigravity cesse d'être perçu comme un outil d'autocomplétion et commence à ressembler à un chef de projet. Vous transmettez à l'agent votre problème encadré, vos ressources de mise en page et vos règles de marque, puis vous cliquez sur exécuter. Au lieu de déverser un mur de code, Antigravity assemble un plan structuré et commence à travailler en fonction de celui-ci.

Au cœur de ce processus se trouvent les Artifacts. Chaque action majeure entreprise par l'agent produit un Artifact concret : des plans de mise en œuvre, des arbres de tâches décomposés, des flux utilisateurs, des contrats API, voire des stratégies de test. Vous voyez une pile vivante de « ce qui se passe » plutôt que des journaux d'appels d'outils opaques qui défilent.

Un passage d'orchestration typique pourrait générer : - Un design système de haut niveau avec des modèles de données et des points de terminaison - Une carte du flux UI pour chaque parcours utilisateur - Une liste de contrôle d'implémentation étape par étape divisée en tâches

Chaque artefact se trouve dans le panneau central comme un fichier de première classe. Cliquez sur un plan de mise en œuvre et vous verrez des sections structurées, des étapes numérotées et des liens vers les fichiers que l'agent prévoit de modifier. On a l'impression de moins dialoguer avec un chatbot et davantage de réviser un cahier des charges d'un ingénieur senior.

L'annotation transforme ces spécifications en une interface de contrôle. Vous pouvez sélectionner n'importe quelle ligne ou bloc dans un Artefact et ajouter un commentaire, à la manière de Google Docs : « Utilisez Tailwind ici à la place de CSS personnalisé », « Ceci devrait être une UI optimiste », ou « Nous avons déjà un helper pour cela dans utils/billing.ts ». Les commentaires sont intégrés, ancrés à la décision exacte que vous souhaitez modifier.

Les développeurs utilisent ces annotations comme un guidage de haute granularité. Vous pouvez, par exemple, demander à l'agent de : - Échanger une bibliothèque de graphiques sur l'ensemble du tableau de bord - Modifier une stratégie de pagination pour un défilement infini - Rendre le ton du texte plus uniforme pour s'aligner sur un site marketing existant

De manière cruciale, l'agent ne se réinitialise pas lorsque vous commentez. Antigravity intègre vos annotations dans le plan actif, met à jour les Artefacts pertinents et continue l'exécution à partir de l'état actuel. Vous maintenez l'élan d'une construction de longue durée tout en corrigeant le tir en temps réel.

Cette boucle itérative—Artifact, annoter, affiner—vous donne un contrôle précis sans gérer chaque fonction au détail près. Vous examinez le plan de mise en œuvre, marquez le flux utilisateur, ajustez le modèle de données, et laissez l'agent s'occuper du travail pénible de câblage des composants, d'écriture des tests et de correction des importations. Pour un aperçu plus approfondi sur la configuration et le flux de travail, Comment configurer et utiliser Google Antigravity - Codecademy passe en revue l'environnement de bout en bout.

Oubliez les discussions avec un seul agent. Le véritable atout d'Antigravity est le Gestionnaire d'Agents, une tour de contrôle pour faire intervenir tout un essaim de travailleurs IA au sein d'un seul projet. Au lieu d'un assistant débordé, vous orchestrez un petit studio de spécialistes, chacun avec un cahier des charges bien défini.

Les développeurs peuvent lancer plusieurs agents en parallèle sur la même base de code, dépôt ou spécification produit. D'un clic dans l'Agent Manager, vous attribuez des rôles : recherche, UX, backend, documentation, QA, tous fonctionnant simultanément pendant que vous restez en mode révision au lieu de taper des modèles de base.

Imaginez un nouveau tableau de bord SaaS. Vous lancez trois agents en même temps : - Un Agent de Recherche qui scrute les pages de tarification des concurrents, les matrices de fonctionnalités et les flux d'intégration - Un Agent Docs qui rédige des guides utilisateur, des références API et des listes de contrôle pour l'intégration - Un Agent UI qui construit l'interface principale en React, gérant l'état et le style selon vos directives de marque

Les trois agents partagent le même contexte de projet : votre spécification Frame, les références de mise en page et les fichiers du dépôt. Ils écrivent dans le même système de fichiers, se croisent les résultats, et s’adaptent à l’arrivée de nouveaux artefacts : la recherche façonne le texte, la documentation reflète les étiquettes de l'interface utilisateur, et l'interface utilisateur réutilise la terminologie du contenu d'aide.

La coordination se fait grâce à la Boîte de Réception Universelle d'Antigravity, un flux centralisé où chaque agent rapporte l'état, les plans et les différences. Au lieu de jongler entre les onglets et les journaux de discussion partiels, vous disposez d'un centre de commande unique qui montre ce qui a changé, pourquoi cela a changé et quel agent s'en est occupé.

La Boîte de Réception Universelle organise les fils de discussion par tâche, et non par session de modèle. Vous pouvez voir un résumé de la recherche, les décisions de conception qui en résultent et les commits de code qui les ont mises en œuvre comme une narration unique. Vous pouvez commenter en ligne, épingler des éléments critiques ou éliminer un agent hors sujet sans interrompre le reste du groupe.

Sur une construction complexe, cela signifie que vous pourriez avoir : - 1 agent de planification maintenant la feuille de route principale - 2 à 3 agents de mise en œuvre gérant l'interface utilisateur, le backend et les intégrations - 1 agent de documentation et 1 agent de test renforçant la version

Vous arrêtez de micromanager les prompts et commencez à gérer une équipe. Antigravity transforme la « conversation avec l'IA » en gestion d'un studio multi-agents qui expédie réellement.

Le code qui se corrige de lui-même est un fantasme depuis des décennies ; Antigravity le transforme discrètement en un comportement par défaut. Chaque fois que vous déployez un changement, ses agents ne se contentent pas de vérifier votre code — ils lancent une session complète de navigateur sans interface (headless browser), parcourent l'interface utilisateur qu'ils viennent de générer et enregistrent ce qui se passe. Vous obtenez des artéfacts comme des captures d'écran, des instantanés du DOM et des rediffusions vidéo reliées directement à l'éditeur.

Au lieu que vous ouvriez manuellement Chrome, que vous actualisiez localhost:3000 et que vous naviguiez parmi les boutons, l'agent de test d'Antigravity gère l'ensemble du flux. Il remplit les formulaires, déclenche des cas limites et compare l'UI rendue avec les spécifications de conception et les règles de marque que vous lui avez fournies lors de la Mise en page. Lorsque quelque chose dévie—une carte désalignée, un itinéraire cassé, une erreur 500 d'une API—l'agent le signale comme un problème structuré, et non pas comme un vague « quelque chose s'est mal passé ».

L'auto-guérison commence lorsque ces problèmes touchent le gestionnaire d'agents. Un agent de débogage dédié analyse le chemin défaillant, le suit à travers le code, et propose une solution, le tout sans que vous ayez à écrire une seule ligne. Il modifie les composants React, met à jour les types TypeScript, applique des correctifs CSS ou réorganise les appels API, puis remet le résultat à l'agent de test pour relancer le flux du navigateur.

Cette boucle fermée—tester, diagnostiquer, corriger, retester—fonctionne en continu jusqu'à ce que le flux de travail soit validé ou atteigne les garde-fous que vous définissez. Vous pouvez établir des règles telles que : - Ne jamais assouplir la sécurité des types - Ne jamais changer les contrats de l'API publique - Demander avant de modifier les schémas de base de données

Les cycles de développement traditionnels étendent ce processus sur des heures ou des jours. Un bug s'infiltre dans la mise en scène, l'équipe de QA ouvre un ticket, un développeur le reproduit, explore les logs, propose un correctif, attend l'intégration continue, puis demande à la QA de vérifier à nouveau. Antigravity compresse tout ce chemin en quelques minutes, souvent pendant que vous travaillez encore sur une autre fonctionnalité dans un autre onglet.

Le débogage autonome ne remplace pas l'examen humain ; il allège les parties ennuyeuses. Vous gardez le contrôle de l'intention et de l'architecture, tandis qu'une multitude d'agents s'occupe de la routine de clics, de plantages et de la réparation discrète du code sous votre direction.

Des outils de style Copilot tels que GitHub Copilot et Cursor considèrent l'IA comme une autocomplétion plus intelligente. Vous êtes dans un éditeur, vous tapez une fonction, et ils devinent la ligne suivante. Antigravity inverse cette dynamique : vous confiez à un agent un problème entièrement défini et il prend en charge l'exécution au niveau du projet, de la structure aux tests.

Les copilotes excellent dans les micro-itérations. Vous avez besoin d'une regex, d'un type TypeScript ou d'un test unitaire rapide ? Ils brillent. L'antigravité, en revanche, s'attend à ce que vous déléguiez des workflows entiers : « créez une application de tableau de bord pour les factures », « portez cette SPA React vers Next.js », « re-thème cette interface utilisateur pour correspondre à ces directives de marque ».

Là où Copilot et Cursor gravitent encore autour du fichier que vous éditez, Antigravity s'oriente autour des Flux et des artefacts. Vous décrivez l'application, collez des images Dribbble, ajoutez des PDF de marque, et le système génère : - Un échafaudage full-stack - Des implémentations multi-fichiers - Des interfaces utilisateur instantanées qui correspondent à vos références visuelles

Cela rend Antigravity plus proche d'un générateur de projets que d'un assistant intégré. Des refactorisations complexes qui prendraient des heures de recherche et de remplacement manuel - renommer un concept de domaine à travers des dizaines de modules, restructurer une couche d'état ou migrer l'architecture CSS - deviennent des commandes d'orchestration uniques que les agents exécutent et vérifient.

Stratégatiquement, la plus grande différence est de nombreux agents contre un généraliste. Copilot est essentiellement un modèle cherchant à tout faire dans la même fenêtre de contexte. Le gestionnaire d'Agent d'Antigravity crée des agents spécialisés en parallèle : un planifie, un implémente, un écrit des tests, un débogue, tous partageant des artefacts au lieu de submerger votre éditeur avec des journaux bruts.

Le parallélisme est important. Alors qu'un assistant semblable à Copilot examine les modifications ligne par ligne, Antigravity peut répartir les tâches sur une base de code, puis concilier les résultats avec des tests autonomes et une auto-guérison. Pour les équipes qui livrent des applications en production, ce changement du achèvement de frappe à la délégation de flux de travail est le véritable atout. Les développeurs qui souhaitent essayer cela peuvent commencer par Getting Started with Google Antigravity et le considérer comme un nouveau type d'IDE, et non comme une zone de texte plus intelligente.

Flow vous offre une méthode répétable pour expédier avec Antigravity au lieu de simplement discuter avec. Définissez le problème jusqu'à ce qu'il soit douloureusement clair, planifiez les visuels et la marque, orchestrez la construction avec des agents, puis expédiez en testant, itérant et déployant. Traitez-le comme une chaîne de production, pas comme un tour de magie.

Commencez avec Frame. Ouvrez Antigravity, cliquez sur "Ouvrir le dossier" et créez un nouvel espace de travail vide — nommez-le par exemple `todo-dashboard`. À droite, passez à Claude et décrivez une petite application ennuyeuse : "une liste de tâches sur une seule page avec des étiquettes, des dates d'échéance et une vue 'Aujourd'hui'."

Demande à Claude de te mettre au défi. Invite-le à explorer les rôles des utilisateurs, les cas limites (tâches en retard, états vides), les plateformes (uniquement sur le web desktop) et les contraintes (pas d'authentification, stockage local uniquement). Lorsque l'idée semble solide, demande à Claude de condenser le tout en une seule invite au format SOP de moins de 500 caractères que tu pourrais remettre à n'importe quel agent IA.

Maintenant, mise en page. Prenez une image d'inspiration UI depuis Dribbble — recherchez "application de tâches minimaliste" ou "tableau de tâches". Copiez l'image et collez-la directement dans le chat Antigravity afin que les agents puissent voir l'espacement, la couleur et la densité des composants.

Créez un fichier `brand.md` simple dans votre projet. Ajoutez 5 à 10 règles précises : hexadécimal de la couleur principale, couleur secondaire, famille de police, rayon des boutons, échelle d'espacement, ton (« calme, faible contraste, sans néon »), et tous les noms de fichiers de logo que vous avez déposés dans le dossier. Cela devient la source unique de vérité pour les décisions de design.

Passez à Orchestrate. À droite, sélectionnez l'agent de planification (pas Fast), collez votre prompt SOP affiné et joignez le fichier `brand.md` ainsi que votre image UI. Demandez un plan d'une page qui énumère les écrans, les composants et le modèle de données avant que tout code ne soit écrit.

Lorsque Antigravity génère des Artefacts — plans, arborescences de fichiers, captures d'écran — parcourez-les comme un cahier des charges. Approuvez ou commentez directement, puis donnez le feu vert à la construction et regardez les agents connecter l'application, les tests et le style de base sans que vous ayez à toucher une seule ligne.

Avant de fermer l'ordinateur portable, ouvrez Agent Manager et lancez un petit essaim de recherche. Assignez un agent pour trouver 3 meilleurs modèles UX pour les tâches, un autre pour évaluer 2 à 3 stratégies de stockage local, et un troisième pour proposer des fonctionnalités v1.1. Vous venez de faire fonctionner votre première équipe produit autonome.

Qu'est-ce que Google Antigravité ?

Google Antigravity est un environnement de développement intégré (IDE) gratuit, axé sur l'agent, qui utilise des agents IA, alimentés par des modèles comme Gemini 3, pour gérer de manière autonome des tâches de développement logiciel complexes, de la planification et du codage aux tests et au débogage.

En quoi Antigravity est-il différent de GitHub Copilot ou Cursor ?

Alors que des outils comme Copilot offrent des suggestions et des complétions de code alimentées par l'IA (un modèle 'copilote'), Antigravity fonctionne sur un modèle 'agent-first'. Vous déléguez des tâches entières à des agents autonomes qui planifient, exécutent et s'auto-corrigent sur l'ensemble de la base de code.

Quel est le cadre 'Flow' pour l'Antigravité ?

Le cadre 'Flow' est un processus en quatre étapes pour utiliser Antigravity de manière efficace : Cadre (définir le problème), Mise en page (fournir un contexte de conception), Orchestrer (gérer le processus de création avec des agents), et une étape finale pour tester et expédier.

Puis-je utiliser différents modèles d'IA dans Google Antigravity ?

Oui. Antigravity est conçu pour être multimodal et supporte divers modèles d'IA puissants, y compris Gemini 3 de Google, Claude 4.5 Sonnet d'Anthropic, et des modèles d'OpenAI comme ChatGPT.