Le nouveau Coder de Google fonctionne pendant que vous dormez.

La gravité a eu une semaine difficile. Wicked 2 est sorti en salles, et Antigravity a atterri discrètement de Google DeepMind aux côtés de Gemini 3 Pro, annonçant non pas un autre assistant de codage, mais une réévaluation complète de ce qu'est réellement un IDE.

Antigravity arrive comme un « tout nouveau IDE issu de Google DeepMind », comme l'a déclaré le responsable produit Kevin Hou devant la foule des ingénieurs en IA, et cela semble constituer une ligne de démarcation. Ce n'est pas un plugin ajouté à VS Code ; c'est le premier IDE entièrement développé par un laboratoire d'IA fondamental, avec des modèles et un éditeur co-conçus comme un système unique.

Cette provenance est importante. Lorsque DeepMind lance un IDE, cela signale que les laboratoires de recherche en IA ne se considèrent plus seulement comme des fournisseurs de modèles, mais comme des fabricants d'outils complets pour les développeurs, possédant tout, des poids de transformateur aux raccourcis clavier.

Antigravity a été lancé la même semaine que Gemini 3 Pro, et cette combinaison n'est pas une coïncidence, mais un choix délibéré. Hou a présenté chaque changement majeur de produit dans les outils de codage—complétion automatique, chat, agents—comme étant « motivé par un changement qui se produit avec les capacités des modèles », et Antigravity est le premier IDE construit autour de ces nouvelles capacités dès le premier jour.

Au lieu de traiter l'IDE comme une coquille statique autour d'un appel d'API, Antigravity considère Gemini 3 comme le système d'exploitation de votre flux de travail de développement. Le produit existe parce que le modèle peut désormais planifier, exécuter et vérifier des tâches de longue durée, et pas seulement compléter la ligne suivante.

Hou appelle Antigravity « sans excuses orienté agent », et cette expression a un véritable impact. Dans son approche, l'IDE n'est plus le centre de gravité ; c'est l'agent qui l'est, et l'éditeur, le navigateur et les terminaux ne sont que des outils qu'il utilise et abandonne.

Cette approche centrée sur l'agent distingue Antigravity de GitHub Copilot, Cursor ou de la liste croissante des éditeurs augmentés par l'IA. Ces outils intègrent l'IA à l'intérieur de l'IDE ; Antigravity intègre l'IDE à l'intérieur de l'IA, et cette inversion pourrait être la véritable histoire de cette version.

Antigravity ne se livre pas sous la forme d'une autocomplétion plus intelligente ajoutée à votre éditeur ; il se présente comme un système à trois surfaces qui traite les agents comme des citoyens de première classe. L'éditeur, le navigateur et le gestionnaire d'agents fonctionnent comme des pairs, avec des agents alimentés par Gemini 3 qui passent entre eux en moins de 100 ms, agissant davantage comme un processus OS distribué que comme un chatbot.

Au niveau du sol se trouve l'Éditeur IA, un environnement VS Code bifurqué qui se comporte exactement comme votre mémoire musculaire s'y attend—onglets, terminaux, points d'arrêt—jusqu'à ce que ça ne soit plus le cas. L'autocomplétion ultra-rapide s'occupe du travail de "taper et suggérer", tandis qu'une barre latérale d'agent reflète le contexte du Gestionnaire d'Agents, vous permettant de transmettre ou de reprendre des tâches sans perdre le fil.

Cette barre latérale transforme l'éditeur en un cockpit pour un travail minutieux. Vous pouvez demander à un agent de refactoriser un composant React complexe, de générer des tests pour un service Go, ou de créer un nouveau point de terminaison API, puis intervenir pour les 20 % restants : affiner les types, corriger les cas particuliers, ou réécrire le texte. Commande-E ou Contrôle-E vous propulse directement vers le Gestionnaire d'Agents, de sorte que le passage d'un fichier unique à la vue mission globale semble instantané.

Là où Antigravity se distingue des IDE traditionnels, c'est par son navigateur contrôlé par l'agent. En arrière-plan, c'est une instance de Chrome que l'agent peut piloter directement—cliquer, faire défiler, remplir des formulaires, exécuter du JavaScript et recharger votre serveur de développement local—en utilisant votre authentification existante, vos cookies et votre accès à Google Docs, aux tableaux de bord GitHub ou aux outils internes.

Cela rend le navigateur plus qu'un simple volet d'aperçu. Les agents peuvent lancer votre application, parcourir un processus d'inscription, ajuster le CSS, puis vous remettre un enregistrement vidéo de Chrome avec un curseur bleu montrant chaque action au lieu d'un mur de différences. La vérification devient visuelle : la modal s'est-elle affichée, l'état d'erreur a-t-il été déclenché, l'animation a-t-elle eu des saccades ?

Surplombant tout, se trouve le Gestionnaire d'Agents, le centre de contrôle de la mission Antigravity. Il considère les agents comme des tâches, et non des discussions, vous offrant une fenêtre unique pour lancer des travaux de longue durée, suivre les progrès et examiner les artefacts — plans, différences, enregistrements, captures d'écran — sans avoir à s'attarder dans un seul fichier.

Une vue de boîte de réception met en avant tout ce qui nécessite une décision humaine : commandes terminales destructrices, migrations de schéma, demandes de permission. Les notifications au niveau du système d'exploitation ne vous ramènent que lorsque cela est nécessaire, vous permettant d'orchestrer plusieurs agents s'exécutant à la fois dans l'éditeur et le navigateur pendant que, ironiquement, vous vous éloignez davantage du code.

Les agents cessent d’être des coéquipiers dans Antigravity ; ils deviennent vos nouveaux chefs de projet. Le Chef de Projet Agent se situe au-dessus du code, vous offrant une vue d'ensemble de tout ce que vos travailleurs autonomes réalisent dans l'éditeur, le navigateur et le terminal. Au lieu de faire défiler des différences, vous assistez à des tâches qui se lancent, s'exécutent et font des rapports comme un tableau de bord d'opérations en direct.

Antigravity impose une relation un-à-plusieurs ici : une fenêtre Agent Manager, de nombreux agents se déployant dans votre environnement. Vous pourriez avoir un agent reconfigurant un monolithe TypeScript, un autre mettant en place un nouveau point de route API, et un troisième exécutant des tests d'intégration basés sur le navigateur. Le Manager les maintient tous dans un seul fil d'actualité priorisé, complet avec le statut, les artefacts, et les prochaines actions.

Le contrôle passe par une boîte de réception de haut niveau qui capture tout ce qui est risqué, destructeur ou ambigu avant d'atteindre votre machine. Les commandes terminales, les migrations de base de données et les tâches de longue durée sont mises en pause dans cette file d'attente jusqu'à ce que vous les approuviez ou les refusiez. Ce dispositif prévient le cauchemar d'un agent trop zélé qui supprimerait un répertoire avec `rm -rf` pendant que vous dormez.

Les éléments de la boîte de réception arrivent sous forme de cartes compactes et lisibles par l'homme : commande, justification, fichiers ou services concernés, et résultat attendu. Un clic envoie l'agent en avant ; un autre annule la branche de travail et l'incite à se replanifier. Les notifications au niveau du système d'exploitation signifient que vous n’avez pas besoin de surveiller la fenêtre—Antigravity vous touche à l'épaule uniquement lorsque quelque chose nécessite réellement une décision humaine.

La rapidité est l'autre moitié de l'histoire. Passer de Agent Manager à l'éditeur via Commande+E ou Contrôle+E prend moins de 100 ms, assez rapide pour paraître instantané. Vous pouvez consulter une liste de tâches, approuver une action terminale, puis revenir dans un fichier spécifique pour ajuster une fonction avant que l'agent ne continue.

Ce saut de moins de 100 ms est crucial lorsque vous jonglez avec plusieurs fils : orchestration dans le Manager, retouches précises dans l'éditeur, vérification dans le navigateur contrôlé par l'agent. L'ensemble du système vous pousse à passer plus de temps au niveau stratégique et moins de temps à micro-gérer les invites. Pour une analyse approfondie de ce flux de travail axé sur l'agent, Google maintient des documents et des téléchargements sur le site officiel d'Antigravity.

Les agents ne se contentent pas de lire votre code dans Antigravity ; ils pilotent une instance complète de Chrome comme un ingénieur QA qui ne dort jamais. Google intègre l'IDE dans un navigateur contrôlé par un agent qui fonctionne avec votre profil Chrome normal, vos cookies et vos authentifications, puis laisse les rênes à Gemini 3. Le résultat ressemble moins à une saisie automatique et plus à un travailleur distant vivant dans votre onglet de navigateur.

Parce que le navigateur partage votre authentification, l'agent peut récupérer le contexte en direct des mêmes endroits que vous. Il peut ouvrir des spécifications Google Docs, parcourir vos demandes de tirage GitHub et explorer les systèmes de suivi des bogues ou tableaux de bord internes qui se trouvent derrière le SSO. Au lieu que vous colliez des URL et des jetons dans une invite, l'agent parcourt discrètement ces sites, construit un modèle mental opérationnel de votre système et intègre cela dans ses plans.

La deuxième moitié du truc est l'activation. Antigravity expose des primitives de clic, défilement, clavier et exécution de JavaScript au modèle, afin qu'il puisse : - Cliquer sur des boutons et des menus - Remplir des formulaires et déclencher des flux - Exécuter des extraits de JS dans la console - Capturer des captures d'écran et des enregistrements

Dans la démonstration de Kevin Hou, cette puissance se manifeste dans une application web de suivi de vol apparemment simple. Il ajoute une nouvelle carte modale à un générateur d'œuvres d'art de style Thomas Cole et demande à l'agent de la connecter. Au lieu de renvoyer une multitude de différences, l'agent ouvre le navigateur, rafraîchit la page et déplace un curseur en forme de cercle bleu dans l'interface pour prouver que la fonctionnalité fonctionne réellement.

Cet enregistrement n'est pas une animation fabriquée ; c'est une trace d'événements DOM réels et d'appels réseau. L'agent clique sur la fenêtre modale, vérifie la mise en page, s'assure que les nouveaux vols s'affichent correctement et recharge pour garantir que l'état persiste. Vous recevez un court extrait vidéo joint à la tâche, côte à côte avec les modifications de code qui l'ont produite.

Cela comble le fossé de la « dernière étape » qui a hanté les outils de codage IA pendant deux ans. Les générateurs de code peuvent produire des composants React et des gestionnaires d'API, mais ils s'arrêtent généralement juste avant un vrai navigateur, de vrais cookies et de vraies données. L'agent de navigateur d'Antigravity franchit cette frontière, transformant « ça a l'air correct dans le diff » en « ça fonctionne dans l'application » par défaut.

Les artefacts se situent au cœur de la manière dont Antigravity souhaite que vous évaluiez le travail d'une IA. Au lieu de vous fier à un mur de résultats de modèle ou à un mystérieux badge "tâche accomplie", vous obtenez des objets concrets, vérifiables que l'agent laisse derrière lui pendant son travail.

Les outils de codage IA à l'ancienne vous demandaient de réviser des différences de code et peut-être un transcript de discussion. Antigravity inverse cela : l'agent assemble des plans de mise en œuvre, des décompositions de tâches étape par étape, des captures d'écran, et des enregistrements de navigateur qui montrent exactement comment il a exécuté le changement.

Vous obtenez toujours des différences dans l'éditeur, mais elles ne sont plus l'interface principale. Le Gestionnaire d'Agents vous élève à un niveau supérieur, où les artefacts par défaut sont : - Un plan d'attaque en langage naturel - Des modifications de code liées - Des preuves visuelles provenant du navigateur contrôlé par l'agent

L'enregistrement du navigateur est la pièce maîtresse. Lorsque l'agent a terminé de câbler une fonctionnalité ou de corriger un bogue, il peut joindre une vidéo de lui-même pilotant une instance complète de Chrome : point de curseur bleu se déplaçant, clics déclenchés, défilements, remplissages de formulaires et exécution de JavaScript sur votre application réelle.

Au lieu de parcourir 20 fichiers modifiés pour vérifier si un modal fonctionne, vous appuyez sur play. Vous regardez l'agent rafraîchir votre générateur d'œuvres d'art aléatoires, déclencher la nouvelle carte modal et vérifier que l'interface utilisateur se comporte correctement dans des conditions réelles du DOM et du réseau.

Ces enregistrements s'accumulent aux côtés d'instantanés statiques et d'artefacts textuels. Pour une tâche complexe, vous pourriez voir une chaîne : document de conception initial, plan de mise en œuvre, modifications de code, journaux de terminal et une vidéo finale du navigateur prouvant que le flux de bout en bout fonctionne.

La validation devient visuelle et temporelle plutôt que uniquement textuelle. Vous confirmez qu'un test de régression s'exécute, que l'authentification réussit avec vos véritables cookies, qu'un clic sur un bouton met effectivement à jour l'état, le tout sans avoir à reconstruire la logique uniquement à partir des différences.

La confiance grandit parce que les artefacts correspondent à la manière dont les humains déboguent et révisent le travail. Les ingénieurs se tournent naturellement vers les partages d’écran, les vidéos Loom et les URL de staging ; Antigravity intègre cet instinct dans le produit et permet à l'agent de produire ces ressources automatiquement.

Alors que des modèles comme Gemini 3 Pro s'améliorent dans les tâches à long terme, ces artefacts deviennent les barrières de sécurité. Vous laissez l'agent fonctionner toute la nuit, puis vous revenez à une boîte de réception organisée de plans, de correctifs et d'enregistrements que vous pouvez examiner en quelques minutes au lieu de plusieurs heures.

L’antigravité existe parce que les modèles sous-jacents ont enfin franchi un seuil. Le Gemini 3 Pro n'est pas une mise à niveau marginale par rapport au Gemini 1.5 ou au Gemini 2 ; au sein de DeepMind, les équipes le décrivent comme un changement révolutionnaire en termes de pouvoir de raisonnement et de fiabilité. Le mantra de Kevin Hou - "le produit n'est jamais meilleur que les modèles qui l'alimentent" - se retrouve dans presque chaque décision de conception.

Les précédents copilotes de codage ont apporté des améliorations limitées : d'abord l'autocomplétion de courte durée, puis le chat avec apprentissage par renforcement humain, et enfin les "agents" fragiles qui s'effondraient lors de tâches prolongées. Gemini 3 Pro dépasse cela en gardant des plans plus vastes en mémoire, en coordonnant les outils sur des heures au lieu de minutes, et en se remettant de ses propres erreurs. Ce changement rend un IDE axé sur les agents, comme Antigravity, non seulement possible, mais nécessaire.

Quatre améliorations de modèle sont les plus importantes. Premièrement, intelligence avancée : Gemini 3 Pro peut décomposer une demande de fonctionnalité en des dizaines de sous-tâches, suivre les dépendances et mettre à jour le plan lorsque des tests échouent ou que des API changent. Deuxièmement, utilisation nuancée des outils : le modèle peut décider quand toucher le système de fichiers, quand ouvrir un navigateur, quand exécuter une commande terminal et quand vous consulter avant d'effectuer l'une de ces actions.

Troisièmement, Gemini 3 Pro gère les tâches de longue durée sans perdre le fil. Au lieu de se déconnecter après quelques appels d'outils, il peut orchestrer des refontes de plusieurs heures, des exécutions CI et des tests de bout en bout, ne faisant remonter que les étapes nécessitant un examen humain. Quatrièmement, la multimodalité native signifie qu'il peut lire directement des captures d'écran d'interface utilisateur, des maquettes de design, des journaux et de la documentation, puis les intégrer dans du code et des tests.

Ces capacités brisent la métaphore de la fenêtre de chat. Une seule conversation qui défile ne peut pas représenter 15 agents fonctionnant dans un éditeur, un navigateur et un terminal, chacun avec ses propres états et artefacts. Vous avez besoin d'un plan de contrôle asynchrone qui considère le chat comme l'une des nombreuses vues d'un système en direct.

C'est pourquoi Antigravity expédie un Agent Manager avec des boîtes de réception, des notifications et des artefacts au lieu d'une simple zone de texte améliorée. L'interface utilisateur s'aligne sur ce que Gemini 3 Pro peut réellement faire : gérer le travail pendant que vous dormez, puis présenter des résultats vérifiables—différences, enregistrements, plans—lorsque vous revenez. Pour une exploration plus approfondie de cette architecture, Google détaille l'empilement dans Build with Antigravity - Google Developers Blog.

Multimodal Gemini transforme l'Antigravité d'un modèle de saisie semi-automatique intelligent en un véritable collaborateur en design. Grâce à la compréhension native du texte, du code, des images et des mises en page UI par Gemini 3 Pro dans une seule fenêtre contextuelle, l'agent peut raisonner sur vos composants React, votre export Figma et vos variables CSS comme un seul artefact cohérent plutôt que comme des fichiers séparés.

La démo du mockup d'Antigravity montre ce que cela ressent vraiment. Vous demandez à l'agent de « concevoir une page d'atterrissage pour une startup d’authentification sans mot de passe », et il ne se contente pas de cracher du HTML — il génère un artefact d'image haute fidélité de la page directement dans l'IDE, à côté du code qui pourrait la rendre.

La partie sauvage vient ensuite : vous commentez cette maquette comme dans un document Google. Vous pouvez ajouter des commentaires flottants directement sur l'image principale, encercler le bouton d'appel à l'action, ou surligner le tableau des prix et écrire : « Rendre cela plus orienté entreprise, moins start-up », et l'agent alimenté par Gemini interprète ces indices spatiaux et ces notes en langage naturel ensemble.

Au lieu de considérer ces commentaires comme des suggestions vagues, Antigravity les traite comme des entrées structurées. L'agent lit l'image, comprend où chaque commentaire se situe sur le canevas, cartographie ces régions en code de mise en page et en jetons de design, puis génère un nouvel artefact de maquette ainsi qu'un diff correspondant dans votre code.

Cette boucle — image → commentaires → nouvelle image plus code — s'exécute entièrement dans l'IDE. Vous ne passez jamais à Figma, vous n'exportez jamais de PNG, vous ne copiez jamais manuellement le CSS. Le Agent Manager suit chaque itération comme un artefact distinct, vous permettant de revenir à « Version 2 avec un CTA bleu » ou de comparer des mises en page comme vous le feriez pour comparer des commits.

Le développement logiciel est devenu multimodal en toute discrétion il y a des années. Les équipes modernes jonglent déjà avec : - Code et fichiers de configuration - Diagrammes d'architecture et graphiques de séquence - Maquettes UI, systèmes de design et captures d'écran - Traces de journaux, tableaux de bord et enregistrements de navigateur

La plupart des outils regroupent encore ceux-ci dans des applications séparées ; Antigravity est le premier IDE grand public qui les considère comme un espace de travail continu. En s'appuyant sur le Gemini multimodal dès le départ, il permet au même agent de raisonner à travers des diagrammes, des interfaces utilisateur et des chemins de code, ce qui fait que « concevoir avec l'IA » ressemble moins à une conversation avec un bot et plus à une collaboration avec un designer produit full-stack qui ne dort jamais.

La conception axée sur l'agent signifie qu'Antigravity considère l'IA comme l'opérateur principal de votre environnement de développement, et non comme un assistant vivant dans une barre latérale. Le produit suppose que les agents liront, écriront, cliqueront et testeront dans votre pile pendant que vous êtes absent, puis ne mettront en avant que les décisions et les points de contrôle nécessitant votre jugement. Les humains deviennent des examinateurs, et non des exécutants manuels de chaque étape.

La plupart des outils « assistés par l'IA » gravitent encore autour d'un workflow centré sur l'humain. Vous écrivez du code, puis appuyez sur une touche de raccourci pour l'autocomplétion, une réponse de chat ou une suggestion de refactorisation ; le modèle ne réagit qu'à votre curseur. Même lorsqu'ils brandissent des fonctionnalités comme des « agents », ces systèmes restent généralement bloqués dans un seul onglet d'IDE, limités par votre prochaine invite.

Les flips antigravitationnels renversent cette hiérarchie. Le Responsable des Agents se trouve au-dessus de l'éditeur et du navigateur, agissant comme un véritable centre de contrôle, conçu pour suivre les objectifs, les branches de travail et les tâches de plusieurs heures plutôt que des différences individuelles. À tout moment, il y a exactement une fenêtre de Responsable des Agents qui coordonne de nombreux agents et de nombreuses interfaces.

Les décisions UI et UX découlent de cette hypothèse d'autonomie. L'éditeur, l'instance Chrome contrôlée par l'agent et le terminal sont tous présentés comme des outils pour l'agent, et non comme des outils pour vous. Un raccourci (Command-E ou Control-E) vous permet de passer de Manager à l'éditeur en moins de 100 ms, renforçant ainsi l'idée que votre vue principale est celle des progrès de l'agent, et non de vos propres frappes.

La supervision remplace la microgestion. La boîte de réception du Responsable des Agents regroupe les événements nécessitant une attention—exécuter une commande terminal risquée, fusionner une grande refonte, mettre à jour la configuration de production—afin que vous puissiez approuver ou rejeter d'un simple clic. Les notifications au niveau du système vous ramènent uniquement lorsque quelque chose franchit une limite de sécurité que l'équipe ne souhaite pas que l'agent dépasse seul.

Les artefacts rendent cette confiance auditable. Au lieu d'exposer des appels d'outils bruts, les agents produisent des artefacts tels que des plans de mise en œuvre, des présentations de code, des captures d'écran et des enregistrements complets de Chrome avec un curseur visible. Vous passez en revue ce que l'agent a fait dans l'éditeur et le navigateur comme si vous regardiez un collègue partager son écran.

Cette architecture centrée sur les agents distingue Antigravity de ses concurrents qui intègrent encore l'IA dans des IDE centrés sur l'humain. Alors que des modèles comme Gemini 3 Pro s'échelonnent en longueur de contexte, fiabilité et utilisation d'outils, la hiérarchie d'Antigravity part déjà du principe que les agents géreront la majeure partie du flux de travail pendant que les humains superviseront les aspects qui comptent vraiment.

Cursor, Replit et GitHub Copilot Workspace ont tous promis un programmeur pair IA vivant à l'intérieur de votre éditeur. Antigravity inverse ce concept, proposant un espace de travail agentique où l'IDE n'est qu'une surface et l'agent est le système d'exploitation de votre travail. Au lieu d'une saisie semi-automatique complétée par un chat, Google vend un environnement d'automatisation complet qui englobe l'éditeur, le navigateur et la couche d'orchestration.

Les concurrents possèdent des éléments de cela. Cursor insiste fortement sur les refactorisations en éditeur et le contexte à l'échelle du dépôt ; les prototypes de Copilot Workspace “spécifications-vers-PR” fonctionnent dans le cloud. Antigravity fusionne ces idées en un plan de contrôle local et multi-surface qui peut ouvrir Chrome, naviguer à travers les tableaux de bord et expédier des artefacts pendant que vous dormez.

L'avantage réel de Google se trouve en amont de l'interface utilisateur. En intégrant l'équipe produit Antigravity au sein de DeepMind, le groupe de Kevin Hou a testé Gemini 3 mois avant son lancement, façonnant à la fois les API d'appel d'outils du modèle et les comportements de l'agent du produit. Ce cycle étroit signifie que la recherche peut corriger les modes de défaillance — comme la planification instable à long terme — directement dans le modèle au lieu de les masquer avec des astuces commerciales.

La pile de DeepMind permet également à Google d'optimiser spécifiquement pour les charges de travail des agents, et pas seulement pour des critères de chat. Le contexte long, l'utilisation d'outils plus robuste et le raisonnement multimodal de Gemini 3 Pro ont été calibrés pour l'architecture à trois surfaces d'Antigravity, et non ajoutés par la suite. Les concurrents qui s'appuient sur des API publiques n'ont pas ce type de privilège de co-conception.

Puis est venu l'erreur de la "pénurie mondiale de puces". Lorsque Antigravity a atteint les listes d'attente cette semaine, un mur de capacité a déclenché une bannière de panne humoristique qui s'est répandue sur X et Hacker News en quelques heures. Le message servait également de graphique de croissance : la demande pour des agents toujours actifs qui compilent, naviguent et testent en arrière-plan écrase déjà les accélérateurs de Google.

Ce moment viral a également mis en lumière le coût computationnel derrière ce paradigme. Un agent qui exécute des tests de navigateur, gère des terminaux et maintient des artefacts pendant des heures se comporte davantage comme un petit service backend que comme une solution ponctuelle. La volonté de Google d'absorber ce coût souligne l'importance qu'il accorde aux agents dans sa stratégie cloud.

L'antigravité, vu de cette manière, est moins un IDE et plus le modèle de Google pour le bureau des développeurs de nouvelle génération. Commencer avec Antigravity - Google Codelabs ressemble moins à une intégration pour un plugin et plus à une formation pour un nouveau modèle opérationnel : votre code, votre navigateur et vos agents partageant tous le même espace de travail.

Les développeurs sont désormais confrontés à une question directe : si un agent peut refactoriser une base de code, connecter OAuth, accéder à votre API de staging et naviguer dans l'interface utilisateur pendant que vous dormez, quel est donc votre rôle ? Antigravity répond en redéfinissant silencieusement ce rôle. Vous cessez d'agir en tant qu'implémenteur ligne par ligne et commencez à agir en tant que personne qui décide ce qui doit être construit, pourquoi, et selon quelle norme.

Au lieu de craindre d'être remplacés, les développeurs qui s'adaptent deviennent architectes et chefs d'orchestre. Le gestionnaire d'agents transforme le travail en un portefeuille de missions déléguées : « Expédier un système de drapeaux de fonctionnalité », « Migrer ce service vers gRPC », « Concevoir une matrice de tests pour mobile ». Votre valeur se déplace vers le choix des bonnes missions, leur séquençage et le jugement de la qualité des artefacts résultants pour savoir s'ils sont réellement suffisamment bons à expédier.

Ce changement exige de nouvelles compétences. La décomposition des problèmes à un haut niveau devient non négociable : vous devez transformer une demande de produit vague en tâches concrètes, de taille adéquate pour l'agent, avec des critères de succès clairs, des dépendances et des limites. Si vous ne pouvez pas décrire le système en anglais clair et avec des schémas, vous n'aimerez pas ce que l'agent produira en code.

Le prompting cesse d'être un mème et devient l'ingénierie des exigences. De bons prompts dans Antigravity ressemblent à de mini documents de conception : entrées et sorties explicites, cas limites, non-objectifs, contraintes de performance, et comment vérifier le résultat. Vous écrirez moins de boucles for et plus de spécifications qui se lisent comme suit : “Étant donné ces SLO de latence et ce schéma, concevez un plan de déploiement avec des canaris et un rollback automatisé.”

La validation devient la seconde moitié du travail. Les artéfacts d'Antigravity—enregistrements de navigateur, plans, différences, exécutions de tests—se transforment en votre surface de révision. Vous apprendrez à : - Lire le plan d'un agent et repérer les modes de défaillance manquants - Utiliser le navigateur contrôlé par l'agent pour explorer des états d'interface utilisateur étranges - Annotations des artéfacts avec des retours ciblés sur lesquels l'agent peut itérer de manière autonome

Des outils comme Antigravity ne réduiront pas le nombre de développeurs ; ils les rendront plus ambitieux. Lorsque qu'un seul ingénieur peut coordonner des agents pour mettre en place des services, réaliser des tests de bout en bout et itérer sur l'expérience utilisateur du jour au lendemain, le goulot d'étranglement ne devient plus « Quelle rapidité puis-je avoir en codant ? », mais « Quelle audace puis-je avoir concernant ce que nous construisons ensuite ? »

Qu'est-ce que Google Antigravity ?

Google Antigravity est un nouvel Environnement de Développement Intégré (IDE) "axé sur les agents" développé par Google DeepMind. Il utilise des agents d'IA autonomes pour gérer, écrire et vérifier du code sur plusieurs surfaces, y compris un éditeur, un navigateur et un gestionnaire central d'agents.

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

Alors que des outils comme Copilot se concentrent sur l'achèvement de code assisté par l'IA et le chat dans l'éditeur, Antigravity est conçu pour des agents autonomes qui exécutent des tâches complexes et de longue durée. Il élève le développeur à un rôle d'orchestration, gérant des agents qui peuvent travailler simultanément dans un éditeur de code et un navigateur web.

Est-ce que Google Antigravity est gratuit ?

Oui, selon les détails de lancement initiaux, Google Antigravity est proposé gratuitement aux développeurs individuels sur macOS, Linux et Windows.

Quels modèles d'IA Antigravity utilise-t-il ?

Antigravity a été lancé en conjonction avec Gemini 3 Pro et est profondément intégré à ses capacités. La plateforme prend également en charge l'optionnalité des modèles, permettant aux développeurs d'utiliser d'autres modèles tels que Claude Sonnet 4.5 et GPT-4.