Wat is Google Antigravity?

Google Antigravity is een ontwikkelplatform waarin je met slimme software-agents werkt in plaats van alleen met een simpele AI-assistent. Jij geeft een opdracht, de agent maakt een plan, voert het uit en controleert het resultaat. Het idee is dat jij de richting bepaalt en keuzes maakt, terwijl de agent het meeste uitvoerende werk doet.

Antigravity is gebouwd rond de nieuwste Gemini 3 modellen, die langere en complexere taken aankunnen. Het is geen klein hulpje in je code-editor, maar een soort werkplek waar je al je agent-werk organiseert. Je gebruikt het om projecten te plannen, taken uit te zetten en stap voor stap te laten bouwen.

Je kunt het zien als een combinatie van een slimme collega en een projecttool in één. Jij blijft eindverantwoordelijk, maar je hoeft niet meer elk detail zelf te tikken. Dat kan veel tijd schelen, vooral bij herhaalwerk en klussen waar je zelf niet per se energie van krijgt.

De visie achter Antigravity

De gedachte achter Antigravity is dat je met een goed idee niet vast hoeft te lopen op je eigen tijd of skills. Je hoeft niet alles zelf te kunnen programmeren, zolang je maar duidelijk kunt uitleggen wat je wilt. De agent helpt je dat idee om te zetten in concrete stappen en uiteindelijk in werkende software.

In plaats van dat je de hele dag losse prompts tikt, ga je meer op een hoger niveau werken. Je zegt bijvoorbeeld: “maak een loginpagina met validatie en tests” in plaats van elke regel code apart te vragen. De agent bedenkt dan welke tools nodig zijn, welke stappen logisch zijn en hoe hij controleert of het werkt.

Google is daar redelijk nuchter over: de modellen zijn nog niet zo ver dat ze dagenlang zelfstandig kunnen doorbuffelen zonder jouw ingreep. Maar ze zijn wel goed genoeg om langere klussen grotendeels zelf te doen. Antigravity is precies rond dat punt ontworpen: jij stuurt bij, de agent doet het zware werk.

De vier bouwstenen: vertrouwen, autonomie, feedback en leren

Antigravity draait om vier vaste principes: vertrouwen, autonomie, feedback en zelfverbetering. Dat klinkt groot, maar het gaat om heel praktische dingen waar jij direct mee te maken hebt. Kun je zien wat de agent doet, kun je hem loslaten, kun je makkelijk bijsturen en wordt hij daar op termijn beter van.

Vertrouwen gaat over hoeveel zicht je hebt op het werk van de agent. Je wilt niet verdrinken in details, maar je wilt ook niet dat er van alles gebeurt zonder dat je snapt hoe. Je moet snel kunnen zien wat er gedaan is en waar je even in moet duiken.

Autonomie gaat over hoeveel vrijheid je de agent geeft om zelf beslissingen te nemen. Laat je hem alleen kleine stukjes code schrijven, of mag hij ook zelf een aanpak kiezen, testen draaien en dingen refactoren. Hoe meer autonomie, hoe meer tijd je bespaart, maar ook hoe belangrijker goed overzicht wordt.

Feedback gaat over hoe makkelijk je kunt ingrijpen als iets niet klopt. Je wilt niet steeds opnieuw moeten beginnen, maar gewoon kunnen zeggen: “dit stuk anders” en dan gaat hij verder met die aanpassing. Hoe soepeler dat gaat, hoe fijner het samenwerken voelt.

Leren draait om wat de agent meeneemt naar de volgende klus. Als hij elke keer bij nul begint, schiet je er weinig mee op. Antigravity zorgt dat eerdere oplossingen en aanpakken worden hergebruikt, zodat het werk steeds wat slimmer en sneller gaat.

Hoe Antigravity vertrouwen opbouwt

Veel AI-tools zitten in een van de twee uitersten. Of je ziet elk mini-stapje en elke toolcall, waardoor je tijd kwijt bent aan ruis. Of je ziet alleen het eindresultaat en hebt geen idee hoe de agent daar gekomen is.

Antigravity pakt dat anders aan door werk op taakniveau te tonen. Je ziet duidelijke taken met een omschrijving, voortgang en de belangrijkste uitkomsten. Zo kun je snel scannen wat er gebeurd is en waar je even in wilt kijken.

Daarbij gebruikt Antigravity artifacts: tastbare tussenproducten die je makkelijk kunt controleren. Denk aan takenlijsten, implementatieplannen, stap-voor-stap walkthroughs, screenshots of browseropnames van tests. De agent maakt die niet alleen voor jou, maar ook om zelf te checken of het werk klopt.

Voor jou voelt dat als meekijken over de schouder van iemand die voor je aan het werk is. Je ziet niet elke muisklik, maar wel de belangrijke momenten en beslissingen. Dat maakt het makkelijker om de agent te vertrouwen zonder alles zelf te hoeven doen.

Editor en manager: zo werk je met de agent

Antigravity heeft twee hoofdschermen: de editor en de manager. De editor lijkt op een moderne IDE met slimme suggesties, aanvullen van code en een agent in de zijbalk. Handig als je zelf actief aan het coderen bent en af en toe hulp wilt.

De manager is meer een soort missiecentrum. Daar start je agents, volg je hun voortgang en beheer je meerdere projecten of deelklussen naast elkaar. In plaats van dat de agent alleen in je editor leeft, is de editor hier juist een van de hulpmiddelen van de agent.

Je schakelt makkelijk tussen die twee. Je laat in de manager een taak plannen, springt naar de editor om een detail te bekijken of aan te passen, en gaat weer terug naar de manager voor het overzicht. Dat werkt vooral fijn als je langere taken hebt die op de achtergrond doorlopen terwijl jij iets anders doet.

Werken met artifacts en feedback

De echte winst zit in hoe makkelijk je die laatste 20 procent kunt bijsturen. Vaak kost het meer tijd om AI-fouten te herstellen dan om het zelf te doen. Antigravity probeert dat te voorkomen met een feedbacksysteem dat dicht op het werk zit.

Je kunt op bijna elk artifact feedback geven, een beetje zoals opmerkingen in een gedeeld document. Op een plan kun je aangeven dat een bepaalde aanpak niet past bij je bestaande structuur. Op een screenshot kun je een element aanwijzen en zeggen dat de knop anders moet of dat de kleuren niet kloppen.

Die feedback pakt de agent direct op in zijn lopende werk. Je hoeft het proces niet stil te leggen en opnieuw te starten. Je stuurt bij terwijl hij bezig is, waardoor het meer voelt als samenwerken dan als achteraf controleren.

Praktische manieren om feedback te geven

Om je een idee te geven hoe dat er in de praktijk uitziet, kun je denken aan dit soort situaties. Je laat de agent een nieuwe pagina bouwen, hij levert een eerste versie en jij loopt er snel doorheen. Op basis daarvan geef je gerichte opmerkingen mee.

• Bij een takenlijst: vink af wat klopt en voeg concrete punten toe die ontbreken.
• Bij een implementatieplan: geef aan welke stappen je anders wilt en waarom.
• Bij code-artifacts: wijs specifieke functies of bestanden aan die herschreven moeten worden.
• Bij screenshots: markeer onderdelen die qua layout, tekst of gedrag niet goed zijn.
• Bij testresultaten: laat weten welke scenario’s nog missen of scherper moeten.

Hoe concreter je bent, hoe beter de agent je bedoeling snapt. Zie het als feedback geven aan een junior ontwikkelaar: niet alleen zeggen “dit is fout”, maar kort uitleggen wat je anders wilt. Na een paar rondes merk je dat de agent jouw voorkeuren beter gaat aanvoelen.

Hoe de agent zichzelf verbetert

Antigravity ziet leren niet als een bonus, maar als een basisfunctie. Alles wat de agent doet, kan onderdeel worden van een kennisbasis. Daar put hij later weer uit als hij een vergelijkbare taak krijgt.

Een deel van die kennis is heel concreet. Denk aan handige codefragmenten, configuraties of een vaste manier om een bepaalde soort service op te zetten. Een ander deel is meer een patroon: zo migreer je veilig dit soort modules, zo test je deze workflow, zo richt je logging in.

In de agent manager kun je zien wat er geleerd is en hoe dat wordt gebruikt. Dat geeft je grip op wat er onder water gebeurt. Je kunt beoordelen of bepaalde patronen nog bij je huidige manier van werken passen en waar je de agent misschien een andere kant op wilt duwen.

Je eigen voorkeuren laten terugkomen

Als je wilt dat de agent echt bij jouw stijl past, helpt het om bewust met die kennis om te gaan. Je kunt bijvoorbeeld vaste keuzes steeds hetzelfde laten doen, zodat de agent dat patroon oppikt. Denk aan hoe je je mappenstructuur opzet of welke teststrategie je standaard gebruikt.

1. Begin met een paar kleine taken en let op welke keuzes de agent maakt.
2. Geef expliciet feedback als iets anders moet, ook als het “wel oké” is.
3. Gebruik artifacts om je voorkeuren vast te leggen, bijvoorbeeld in een kort richtlijnen-document.
4. Laat de agent dat document zelf samenvatten en toepassen op een nieuwe taak.
5. Check in de manager of die aanpak terugkomt bij latere klussen.

Zo bouw je stap voor stap een soort huisstijl op voor je projecten. De agent wordt dan minder een generieke AI en meer een verlengstuk van hoe jij graag werkt.

Praktische zaken: modellen, platformen en kosten

Antigravity is in een publieke preview gratis te gebruiken voor individuele gebruikers. Je krijgt ruime limieten op krachtige modellen zoals Gemini 3 Pro. Dat geeft je de ruimte om het rustig in je eigen werk uit te proberen zonder meteen een budget te regelen.

Het platform werkt op macOS, Linux en Windows. De meeste ontwikkelomgevingen zijn dus gewoon gedekt. Google legt de nadruk op lokale werking, zodat een groot deel van het werk van de agent op je eigen machine gebeurt.

Dat heeft twee voordelen: het voelt sneller en het geeft vaak een veiliger gevoel dan wanneer alles alleen in de cloud draait. Qua modellen zit je niet vast aan één aanbieder. Naast Gemini 3 kun je ook modellen gebruiken zoals Claude Sonnet 4.5 van Anthropic en GPT-modellen van OpenAI.

Je kunt per project of taak kiezen wat handig is. Voor een simpele klus pak je misschien een lichter model, voor een grote refactor een zwaarder. Het platform is daar flexibel in, zodat je niet alles op één kaart hoeft te zetten.

Antigravity slim inzetten in je dagelijkse werk

Je hoeft je hele manier van werken niet om te gooien om Antigravity te gebruiken. Begin klein, met klussen die je nu al uitstelt omdat ze saai of tijdrovend zijn. Laat de agent bijvoorbeeld eerst een duidelijke takenlijst en een implementatieplan maken voor een nieuwe feature.

Jij kijkt dat plan na, geeft feedback via de artifacts en laat hem daarna pas de code schrijven. Voor dingen als een simpele pagina bouwen, een basis-API opzetten of een afgebakend stuk code refactoren komt het platform goed tot zijn recht. De agent kan zelf een lokale server draaien, in de browser testen en met screenshots laten zien wat er gebeurt.

Het is slim om de agent niet meteen de volledige controle over je hele project te geven. Begin met losse, overzichtelijke klussen. Houd de artifacts goed in de gaten, geef actief feedback en kijk hoe de kennisbasis zich vult. Zo groei je vanzelf naar een manier van werken waarin de agent echt meewerkt in plaats van dat je hem achteraf moet corrigeren.

Antigravity in je bestaande ontwikkelproces

Als je al een vaste manier van werken hebt, wil je Antigravity daar waarschijnlijk netjes in laten passen. Je kunt het zien als een extra laag bovenop je bestaande tools. Je versiebeheer, je issue-tracker en je CI blijven gewoon bestaan.

Een praktische aanpak is om de agent te koppelen aan concrete tickets of user stories. Je maakt in je eigen systeem een taak aan en vertaalt die in Antigravity naar een duidelijke opdracht. De artifacts die daaruit komen, gebruik je weer als onderbouwing in je bestaande workflow.

Zo houd je je huidige structuur in stand, maar laat je het uitvoerende werk meer door de agent doen. Je kunt bijvoorbeeld:

• Voor elk ticket een Antigravity-taak laten maken met een plan en subtaken.
• Artifacts gebruiken als bijlage bij code reviews, zodat collega’s zien hoe iets tot stand is gekomen.
• De agent standaard tests laten schrijven en draaien voordat jij een pull request opent.
• Refactor-klussen die al lang op je lijst staan aan de agent uitbesteden, met duidelijke grenzen.

Op die manier blijft je proces herkenbaar, maar schuif je steeds meer werk naar de agent toe. Jij houdt de regie en bepaalt waar de grens ligt.

Antigravity en samenwerken in een team

Ook in een team kan Antigravity handig zijn, al begin je misschien eerst zelf. De artifacts maken het makkelijker om elkaars werk te begrijpen. Je ziet niet alleen de uiteindelijke code, maar ook de plannen, keuzes en testresultaten die erbij horen.

Dat helpt bijvoorbeeld als iemand anders jouw taak overneemt. Die kan in de manager zien wat de agent al gedaan heeft en welke feedback jij gegeven hebt. Je hoeft dan minder mondeling over te dragen en toch blijft de context bewaard.

Je kunt er ook voor kiezen om een paar vaste “teamregels” vast te leggen in artifacts. Denk aan hoe je omgaat met foutafhandeling, logging of beveiliging. Laat de agent die regels steeds toepassen en pas ze aan als jullie manier van werken verandert. Zo groeit Antigravity mee met je team, in plaats van dat iedereen zijn eigen losse AI-hulpje gebruikt.