Eindelijk een AI-coderingstool die aanvoelt als een compleet ontwikkelteam

De Vibe Coding Revolutie

Er is een term die de laatste tijd door ontwikkelaarsgemeenschappen echoet: Vibe Coding. Het klinkt bijna mystiek, nietwaar? Alsof je achterover kunt leunen, in menselijke taal beschrijven wat je wilt, en een productie-klare app zien materialiseren. De realiteit is natuurlijk... gecompliceerder geweest.

De afgelopen twee jaar zat ik diep in de loopgraven van AI-ondersteunde ontwikkeling. Ik heb API-credits verbrand, geworsteld met gehallucineerde imports, en hulpeloos toegekeken terwijl een AI-"fix" stilletjes mijn authenticatielaag overschreef. De belofte was er altijd — minder code schrijven, sneller leveren — maar de uitvoering voelde als het spelen van een gokautomaat. Soms win je de jackpot. Vaker krijg je onzin.

En toen kwamen de november-aankondigingen. Google dropte Gemini 3 samen met een nieuwe IDE genaamd Antigravity, en plotseling kristalliseerde het verspreide gefluister over "agentisch coderen" in iets tastbaars. Dit was geen VS Code-extensie met een chat-zijbalk. Dit was iets fundamenteel anders.

Ik herinner me het exacte moment dat het klikte. Ik was een legacy authenticatiemodule aan het refactoren — het soort vervelend, multi-bestand werk dat meestal een middag kost. Ik beschreef aan Antigravity's agent wat ik nodig had. Het genereerde een plan. Creëerde subtaken. Begon te werken over bestanden heen. Voerde de tests uit. Repareerde een bug waarvan ik niet eens wist dat die bestond. En toen toonde het me screenshots van de werkende interface, vragend of dit aan mijn verwachtingen voldeed.

Twintig minuten. Het hele ding duurde twintig minuten. Ik zat daar, koffie koud wordend, en realiseerde me dat er zojuist iets fundamenteels was verschoven.

Wat is Google Antigravity?

Google Antigravity is een AI-aangedreven geïntegreerde ontwikkelomgeving (IDE) die werd aangekondigd op 18 november 2025, samen met de release van Gemini 3. In tegenstelling tot traditionele codeertools die je helpen sneller code te schrijven, helpt Antigravity je codeertaken volledig te delegeren. Zie het als het verschil tussen een spellingchecker en een ghostwriter.

Het platform is gebouwd als een fork van Visual Studio Code — hoewel er enige discussie is over of het een directe fork is of een indirecte via Windsurf (die Google overnam voor $2,4 miljard). Als je eerder VS Code hebt gebruikt, zal de interface direct vertrouwd aanvoelen. Maar de overeenkomsten zijn grotendeels oppervlakkig.

Wat Antigravity fundamenteel anders maakt is de "agent-first" architectuur. De AI suggereert niet alleen code snippets — het is een autonome actor die complexe engineeringtaken kan plannen, uitvoeren, valideren en itereren. De agenten hebben directe toegang tot je editor, terminal en zelfs een browser, waardoor ze autonoom complete features kunnen plannen, uitvoeren en valideren.

Ik heb de sceptische reacties online gezien. "Het is gewoon nog een VS Code fork." "Google zal het over zes maanden stoppen." En ja, Google's kerkhof is legendarisch. Maar na weken met Antigravity te hebben gewerkt, denk ik dat het afdoen een vergissing zou zijn. Dit is geen halfbakken experiment. Dit is Google die groot inzet op waar ontwikkeling naartoe gaat.

Mijn Eerste Indrukken

Installatie was verrassend soepel. Download de installer, doorloop de setup wizard, log in met mijn Google-account, en binnen tien minuten staarde ik naar de Agent Manager — niet een code-editor. Dat is bewust, en het is het eerste signaal dat Antigravity wil dat je anders over ontwikkeling nadenkt.

De interface is verdeeld in twee verschillende weergaves:

De eerste keer dat ik Antigravity opende, werd ik begroet door de Agent Manager, niet een leeg bestand. Dit was geen toeval. Google ontwierp het zodat je taken uitgeeft ("Bouw een gebruikersauthenticatiesysteem met OAuth 2.0") en AI-agenten de implementatie laat afhandelen terwijl jij hun werk reviewt.

Ik zal eerlijk zijn — de eerste paar sessies voelden desoriënterend. Ik bleef willen springen naar de code, elk detail willen controleren. Maar toen ik mezelf dwong het proces te vertrouwen, gebeurde er iets opmerkelijks. Ik begon na te denken over mijn projecten op een hoger niveau. Architectuur. Gebruikerservaring. Businesslogica. Het saaie werk — de boilerplate, de repetitieve patronen, het dependency management — werd afgehandeld door agenten.

Een ontwikkelaar waarmee ik sprak beschreef het perfect: "Antigravity voelt als het inhuren van een getalenteerde maar onervaren junior ontwikkelaar. Ongelooflijk snel, af en toe roekeloos, en supervisie nodig. Maar zodra je uitzoekt hoe je ze moet aansturen, zijn de productiviteitswinsten echt."

De Agent-First Filosofie

Traditionele AI-codeertools — Copilot, basis Cursor, Windsurf — helpen je sneller code schrijven. Het zijn geavanceerde autocomplete-systemen die de volgende paar tokens voorspellen op basis van context. Google noemt dit "Generatie 1" AI: het tijdperk van de supercharged autocomplete.

Antigravity vertegenwoordigt "Generatie 2": het Agentische Tijdperk. De AI suggereert niet alleen code; het functioneert als een autonome partner die de terminal, de editor en zelfs een live browser kan navigeren om dingen gedaan te krijgen. Het gaat niet meer over sneller code schrijven; het gaat over het orkestreren van een personeelsbestand van digitale agenten om software voor je te bouwen.

Multi-Surface Integratie

Dit is wat Antigravity echt onderscheidt: de agenten hebben toegang tot drie "command surfaces":

Denk na over wat dat betekent. Traditionele AI-codeertools leven alleen in de editor. Ze suggereren autocomplete. Misschien refactoren ze een functie. Maar ze kunnen hun werk niet verifiëren. Antigravity-agenten kunnen code schrijven, uitvoeren, de resultaten zien, problemen oplossen, en je screenshots tonen van de werkende applicatie — allemaal zonder jouw interventie.

Het Artifacts Systeem

Een van de grootste uitdagingen met autonome AI is vertrouwen. Hoe weet je wat de agent daadwerkelijk heeft gedaan? Antigravity lost dit op via een "Artifacts" systeem. In plaats van ruwe tool-aanroepen te dumpen, genereren agenten menselijk leesbare deliverables:

• Takenlijsten: Complexe verzoeken opsplitsen in beheersbare stappen
• Implementatieplannen: Gedetailleerde voorstellen die je kunt reviewen voordat ze worden uitgevoerd
• Screenshots: Visueel bewijs van hoe de app eruitziet
• Browser Opnames: Video walkthroughs van de agent die je UI test
• Walkthroughs: Stap-voor-stap uitleg van wat er is gebouwd

Je kunt feedback direct op artifacts achterlaten, zoals commentaar geven op een Google Doc. De agent verwerkt je feedback en itereert. Het is collaboratief op een manier die chat-gebaseerde AI-tools simpelweg niet zijn.

Ondersteunde Modellen & Kracht

Iets dat me verraste over Antigravity: Google maakte het model-agnostisch. Hoewel het standaard Gemini 3 Pro gebruikt, ondersteunt het ook concurrenten zoals Anthropic's Claude Sonnet 4.5 en Claude Opus 4.5, evenals open-source varianten van OpenAI-modellen (GPT-OSS-120B). Deze flexibiliteit suggereert dat Google het platformworkflow wil bezitten, ongeacht welk model momenteel het slimst is.

Gemini 3: De Motor Die Alles Veranderde

Ik moet specifiek over Gemini 3 praten, want dat is hier de echte ster. Ik gebruik Gemini sinds de vroege 2.0 dagen, en eerlijk gezegd was het altijd "goed genoeg" maar nooit opwindend. Gemini 2.5 Pro was redelijk. Maar Gemini 3? Dit is een heel ander beest.

Het grootste verschil is niet ruwe snelheid — het is redenering. In eerdere versies, als ik om complexe logica vroeg, kreeg ik vaak code die er correct uitzag maar faalde op edge cases. Gemini 3 heeft een "Deep Think" vermogen waarbij het uitvoering lijkt te simuleren voordat code wordt geschreven. De nauwkeurigheidsverbetering is substantieel.

Belangrijker voor Antigravity: Gemini 3 verwerkt native meer dan 1 miljoen tokens. Dat betekent dat Antigravity hele monorepos begrijpt zonder truncatie. Hele-codebase refactoring met volledig architectureel begrip. Nauwkeurige dependency tracking over honderden bestanden. First-attempt nauwkeurigheid bij grootschalige codegeneratie. Concurrerende tools begrenzen effectieve context veel lager, waardoor meerdere iteraties of handmatig context prunen nodig is.

Review-Driven Development

Toen ik voor het eerst Antigravity's instellingen opende, viel me een standaardoptie op genaamd "Review-driven development." Deze term was nieuw voor mij — ik had gehoord van Test-driven development (TDD), waarbij unit tests het ontwikkelproces sturen. Maar Review-driven development?

Het concept is eenvoudig maar diepgaand: ontwikkeling wordt nu gestuurd door het reviewproces. Je schrijft geen code; je reviewt code die AI genereert. Jouw taak is te verifiëren dat de AI-output overeenkomt met je intentie, fouten te vangen, verfijningen te begeleiden.

Dit mapt direct naar het Vibe Coding concept waar iedereen het over heeft. We bewegen door projecten via conversatie, dingen stap voor stap vooruitduwend, in plaats van verloren te raken in implementatiedetails. De rol van de programmeur evolueert richting product manager, architect, projectleider — iemand die richting en oordeel biedt in plaats van elke puntkomma te typen.

Of Antigravity deze terminologie heeft uitgevonden of gewoon iets heeft benoemd dat al aan het gebeuren was, het feit dat het in de IDE is ingebakken stuurt een duidelijke boodschap: dit is hoe Google de toekomst van ontwikkeling ziet.

Killer Features Diepgaand

Parallelle Agent Orkestratie

Dit is waar Antigravity's architectuur een belangrijke beperking van eerdere IDE's aanpakt. Traditionele chat-interfaces zijn lineair en synchroon — je wacht tot de AI klaar is voordat je de volgende vraag stelt. In Antigravity's Manager View kun je tot vijf verschillende agenten tegelijkertijd op vijf verschillende taken zetten.

Echt voorbeeld uit mijn workflow: Terwijl een agent de authenticatiemodule aan het refactoren was, had ik een andere integratietests laten schrijven, een derde documentatie laten updaten, en een vierde databasequeries laten optimaliseren. Allemaal parallel draaiend, allemaal artifacts producerend die ik op mijn gemak kon reviewen. Het is als een klein dev team hebben, behalve dat ze nooit moe worden, nooit koffiepauzes nodig hebben, en nooit klagen over onduidelijke requirements (ze vragen gewoon om verduidelijking).

Browser Subagenten

Ik kan niet genoeg benadrukken hoe transformatief de browserintegratie is. Antigravity bevat een ingebouwde Chrome browser waar agenten:

• Je applicatie kunnen lanceren
• Door de UI kunnen klikken
• Screenshots kunnen maken
• Video walkthroughs kunnen opnemen
• Visuele problemen kunnen identificeren
• CSS-problemen kunnen debuggen op basis van wat ze zien

In een memorabele sessie vroeg ik een agent om een simpel dashboard te bouwen. Het schreef de code, startte de dev server, opende de browser, merkte op dat een knop niet goed was uitgelijnd, ging terug en repareerde de CSS, herlaadde de pagina, verifieerde de fix, en toonde me toen een screenshot vragend of dit was wat ik wilde. Allemaal autonoom.

Automatische Walkthrough Generatie

Als je zoals ik bent, is het meest uitputtende deel van elke sprint niet de code — het is de huishouding. Je maakt een feature af, en besteedt dan uren aan screenshots maken en gedetailleerde how-to gidsen schrijven voor QA en gebruikers. Antigravity-agenten genereren walkthroughs automatisch. Ze documenteren wat ze hebben gebouwd, hoe het werkt, en hoe je het gebruikt.

Knowledge Items & Geheugen

Agenten leren van je feedback en eerdere werk, en verbeteren hun begrip van je codeerstijl en projectvereisten over tijd. Je kunt ook "Knowledge Items" creëren — persistente context die agenten helpt je specifieke projectconventies, architecturale beslissingen en voorkeuren te begrijpen.

Workflows & Custom Prompts

Antigravity ondersteunt opgeslagen prompts genaamd "Workflows." Typ / in de chat om toegang te krijgen tot voorgedefinieerde workflows zoals unit tests genereren of documentatie creëren. Je kunt je eigen workflows maken voor repetitieve taken, in feite programmerend hoe je wilt dat de agent zich gedraagt.

/generate-unit-tests

Toetsenbordsneltoetsen

Cmd + L (Mac) / Ctrl + L (Win)  → Toggle agent paneel
Ctrl + `                         → Toggle terminal
@ + bestandsnaam                 → Include bestandscontext
/ + workflow naam                → Trigger opgeslagen workflow

Prijzen & Rate Limits

Hier is de kop die iedereen deed opkijken: Antigravity is gratis. Tijdens de public preview krijg je toegang tot Gemini 3 Pro, Claude Sonnet 4.5, en andere premium modellen zonder iets te betalen.

De Rate Limit Realiteit

Laat me eerlijk zijn over de beperkingen. Sommige early adopters melden dat ze na ongeveer 20 minuten intensief gebruik op de gratis tier door hun credits heen zijn. Als je serieus ontwikkelwerk doet — complexe multi-bestand refactors, continue agent-interacties — zul je rate limits raken.

Betaalde Google AI Pro abonnees krijgen veel generieuzere limits, met quota's die elke 5 uur refreshen in plaats van wekelijks. Het Pro abonnement (ongeveer $20/maand via Google One) geeft je niet alleen toegang tot Antigravity maar ook tot Gemini in chat, Veo 3 videogeneratie, en Nano Banana beeldbewerking.

De economie hier is eigenlijk vrij gunstig. Claude Pro is $20/maand. ChatGPT Plus is $20/maand. Cursor Pro is $20/maand. Met Google AI Pro krijg je Antigravity plus het hele Google AI-ecosysteem. En de gratis tier is echt bruikbaar voor licht tot matig gebruik.

Antigravity Tools - Het Geheime Wapen

Nu wil ik iets delen dat essentieel is geworden voor mijn workflow — een community-gebouwde tool die veel meer aandacht verdient dan het krijgt. Antigravity Tools (ook bekend als Antigravity Manager) is een open-source desktop applicatie gemaakt door een briljante Chinese ontwikkelaar genaamd lbjlaq.

Het probleem dat het oplost: Antigravity's modellen zijn ongelooflijk, maar ze zitten opgesloten in de Antigravity editor. Wat als je Claude Code CLI wilt gebruiken? Wat als je meerdere Google-accounts hebt en quota's over hen wilt beheren? Wat als je requests wilt routeren via een standaard API die werkt met elke AI-client?

Waarom Dit Belangrijk Is

Claude Code is waarschijnlijk de beste codeeragent voor terminal-gebaseerde workflows. Maar het vereist een Anthropic API-abonnement. Met Antigravity Tools kun je Claude Code CLI gebruiken aangedreven door je gratis Antigravity-quota. De proxy handelt alle protocolvertaling naadloos af.

# Stel omgevingsvariabelen in
export ANTHROPIC_BASE_URL="http://localhost:8080"
export ANTHROPIC_API_KEY="sk-antigravity"

# Draai Claude Code normaal
claude

Multi-Account Load Balancing

Hier wordt het echt slim. Als je meerdere Google-accounts hebt (persoonlijk, werk, misschien een paar die je hebt aangemaakt voor testen), kun je ze allemaal toevoegen aan Antigravity Tools. Het systeem:

• Trackt quota voor elk account apart
• Schakelt automatisch naar accounts met beschikbare quota wanneer één rate-limited is
• Detecteert 403 verboden accounts (zonder Gemini Code Assist permissies) en slaat ze over
• Beveelt het "beste" account aan op basis van huidige quota levels

Voor ontwikkelaars in regio's waar AI-diensten beperkt zijn, of iedereen die gratis gebruik wil maximaliseren, is dit een game-changer.

Antigravity vs Cursor

De vraag die iedereen stelt: "Moet ik switchen van Cursor?" Laat me je een eerlijke vergelijking geven gebaseerd op weken van gebruik van beide.

Filosofieverschil

Cursor is een AI-first editor. Het neemt een VS Code-omgeving en legt krachtige code-assistentie eroverheen. Je schrijft nog steeds code; de AI is er om je te deblokkeren. Wanneer je vastzit, vraag je om hulp. Maar je behoudt controle over elke wijziging.

Antigravity is agent-first. Je schrijft geen code; je delegeert taken. De AI plant, voert uit en valideert. Jij reviewt artifacts en geeft feedback. Je bent een architect, geen typist.

Performance Benchmarks

Volgens community testing voltooit Antigravity een typische Next.js + Supabase feature in 42 seconden versus Cursor's 68 seconden. Op codebase navigatie over 100k+ regel repositories, lost Antigravity queries 40% sneller op dan Cursor 2.0. Refactoring nauwkeurigheid: Antigravity haalt 94%, Cursor haalt 78%.

Maar snelheid is niet alles. Cursor's proprietary Composer model genereert code met 250 tokens/seconde en wordt vaak verkozen voor ruwe codeertaken. Cursor 2.0 introduceerde Debug Mode, Visual Editor, en kan tot 8 parallelle agenten draaien.

Mijn aanbeveling? Gebruik beide. Cursor voor productiewerk waar je controle en betrouwbaarheid nodig hebt. Antigravity voor alles anders — prototypes, experimenten, nieuwe frameworks leren, side projects bouwen — is Antigravity onmisbaar geworden.

Pro Tips & Power User Geheimen

Weken van dagelijks gebruik hebben me workflows geleerd die de Antigravity-ervaring dramatisch verbeteren. Hier is alles wat ik had gewild te weten vanaf dag één:

De Ruwe Kantjes

Ik heb dit hele artikel Antigravity geprezen, dus laat me even eerlijk zijn over de problemen. Dit is nog steeds een public preview, en dat is te merken.

Rate Limits Zijn Echt

Voor intensief ontwikkelwerk zul je rate limits raken. Verwacht geblokkeerd te worden midden in een sessie als je serieus werk doet op de gratis tier. Google schaalt capaciteit op, maar momenteel is het een echte beperking.

Model Validatie Verwarring

De model validatieresultaten tonen soms andere modellen dan wat ik selecteerde. Ik weet nog steeds niet zeker of dit een UI-bug is of dat er achter de schermen automatische modelroutering plaatsvindt. Het is verwarrend en ondermijnt vertrouwen.

Project Directory Problemen

Als je een Antigravity project directory maakt en deze ergens anders op het systeem verplaatst, gaan dingen stilletjes kapot. Knowledge Items laden misschien niet. Context kan verloren gaan. Er is geen duidelijke manier om dit te fixen behalve de workspace opnieuw te creëren.

Agent Fouten

Werken met agentische AI is niet kogelvrij. In mijn testen maakten agenten af en toe:

• Hele secties code gedupliceerd
• Wijzigingen aan het verkeerde bestand gemaakt
• Vastgelopen in loops met ambigue requirements
• Beweerd "corrupte code" te hebben gefixt die ze eigenlijk zelf hadden gebroken

De agenten vangen de meeste van hun eigen fouten, maar niet altijd. Menselijke review is essentieel.

Legacy Codebase Worstelingen

Antigravity blinkt uit bij greenfield projecten en prototyping. Complexe legacy codebases met ingewikkelde dependencies? Daar worstelt het mee. De agenten kunnen "vastlopen" terwijl ze verwarde architecturen proberen te begrijpen.

Privacy Overwegingen

Je code wordt verwerkt op Google's servers. Als je werk wettelijk verplichte lokale dataverwerking omvat, is Antigravity niet jouw tool. Voor enterprise of compliance-gevoelig werk, overweeg directe API-toegang tot specifieke providers in plaats daarvan.

Extensie Frictie

Antigravity gebruikt de Open VSX registry in plaats van de VS Code marketplace. Veel extensies werken prima, maar sommige populaire VS Code extensies zijn niet beschikbaar of hebben compatibiliteitsproblemen. Dit is een echt pijnpunt voor ontwikkelaars met sterk aangepaste VS Code setups.

Wie Moet Antigravity Gebruiken?

Eindoordeel

Na weken van intensief gebruik is mijn oordeel duidelijk: Google Antigravity vertegenwoordigt een echte paradigmaverschuiving. Het is niet perfect — de rate limits frustreren, de agenten maken fouten, de enterprise-gereedheid is er nog niet. Maar de kernvisie is juist. De toekomst van ontwikkeling gaat niet over sneller typen. Het gaat over denken op een hoger niveau en AI de implementatiedetails laten afhandelen.

Cursor is nog steeds mijn go-to voor productiewerk waar ik controle en betrouwbaarheid nodig heb. Maar voor al het andere — prototypes, experimenten, nieuwe frameworks leren, side projects bouwen — is Antigravity onmisbaar geworden. Het gevoel van beschrijven wat ik wil en autonome agenten het zien bouwen, testen, en screenshots tonen van het werkende resultaat? Dat is geen incrementele verbetering. Dat is een glimp van waar alle softwareontwikkeling naartoe gaat.

Als je een ontwikkelaar bent in 2025 en Antigravity nog niet hebt geprobeerd, ben je het aan jezelf verschuldigd deze verschuiving uit de eerste hand te ervaren. Download het. Geef het een echt project. Duw door de initiële leercurve. En vertel me dan of je ooit terug kunt naar elke regel zelf typen.

Ik kan dat zeker niet.