De tijd die wordt besteed aan het handmatig opsporen van een bug of het bijwerken van documentatie, gaat ten koste van het uitbrengen van nieuwe functies. Goed presterende teams maken al gebruik van AI om deze tijd terug te winnen en zien in willekeurige veldproeven een toename van 26% in de voltooiing van taken.
Ook u kunt zich bij dit groeiende aantal aansluiten door Google Antigravity-toepassingen te implementeren, zoals de automatisering van het verhelpen van bugs, het snel maken van UI-prototypes en het uitvoeren van controles voor de veiligheid. In deze handleiding leert u hoe u Antigravity van Google kunt gebruiken en wordt uitgelegd hoe u deze werkstroom kunt integreren in uw bestaande tools.
TL;DR: Antigravity is de beste keuze voor werk dat je kunt definiëren, uitbesteden en vervolgens uit het oog kunt verliezen. Het is de minst geschikte keuze voor werk waarbij je je weg zelf moet vinden.
Vijf toepassingsvoorbeelden bewijzen hun nut: automatisering van taken via agents, het maken van UI-prototypes met feedback via de browser, analyse van de code, controles voor veiligheid en coördinatie tussen verschillende tools. De keuze van het platform bepaalt het resultaat. Antigravity 2.0 voor parallelle coördinatie, CLI voor headless-werk, IDE voor het coderen naast een agent en SDK voor aangepaste agents.
De beslissing om Antigravity in te zetten draait niet echt om Antigravity zelf. Het gaat erom of je team een plek heeft waar de output van de agents terechtkomt, iemand die verantwoordelijk is voor het doorlezen ervan, en een manier om te signaleren wanneer goedkeuringen slordig worden uitgevoerd. Teams die dit als eerste opzetten, profiteren van een steeds groter wordend rendement. Teams die dit overslaan, belanden sneller bij een codebase die niemand meer begrijpt.
Wat is Google Antigravity?
Google Antigravity is het ‘agent-first’-ontwikkelingsplatform van Google. Het zet autonome AI-agenten in die meerstaps taken plannen en uitvoeren in je editor, terminal en browser. Beschrijf wat je nodig hebt, en de agenten doen het werk, zodat je niet langer hoeft te schakelen tussen een code-editor, een terminal en je documenten om één taak af te ronden.
Het werd gelanceerd als openbare preview samen met Gemini 3, waarmee de weg werd vrijgemaakt voor de nieuwe update, Antigravity 2.0. Die release verdeelde één IDE in vier werkruimten. Wat je kiest, bepaalt hoe de onderstaande toepassingsvoorbeelden uitpakken:
- Antigravity 2.0: Coördineer meerdere autonome agents in afzonderlijke projecten vanuit een zelfstandige desktop-app zonder gekoppelde editor
- Antigravity CLI: Voer agents rechtstreeks vanuit de terminal uit voor command-line- en headless-werkstroomen
- Antigravity IDE: Schrijf code naast een agent in de oorspronkelijke editor
- Antigravity SDK: Bouw aangepaste agents op het Antigravity-platform met behulp van een Python-bibliotheek
De agent zelf draait op Gemini 3.6 en 3.5 Flash, Gemini 3.1 Pro, Claude Sonnet 4.6 en Claude Opus 4.6, waarbij ook GPT-OSS-120b kan worden geselecteerd. (De beschikbaarheid van modellen verandert regelmatig; raadpleeg de officiële Antigravity-documentatie voor de actuele lijst.)
Top 5 toepassingen van Google Antigravity voor ontwikkelteams
Ontwikkelteams halen het meeste uit Antigravity op vijf gebieden: automatisering van taken door agents, het maken van UI-prototypes, analyse van de codebase, controles voor veiligheid en automatisering van tooloverschrijdende werkstroomen. Elk gebied neemt een ander soort repetitief werk uit handen, variërend van standaardcode voor één ontwikkelaar tot taken die binnen het hele team worden overgedragen.
1. Agentische ontwikkeling en automatisering van Taak-processen
Antigravity neemt de uitvoeringslussen over die ontwikkelaars uit hun geconcentreerde werk halen: het schrijven van standaardcode, het uitvoeren van testsuites en het implementeren naar de staging-omgeving. Die lussen zijn op zichzelf al traag en leiden tot contextwisselingen, wat de productiviteit telkens weer omlaag haalt wanneer de aandacht wordt afgeleid.
Door die uitvoering in meerdere stappen aan de agent te delegeren, kunnen ontwikkelaars zich concentreren op de architectuur en het oplossen van problemen. Enkele voorbeelden:
- Het verhelpen van bugs automatiseren: Laat een agent de bug opsporen, de oplossing schrijven, de tests uitvoeren en u een schone patch ter beoordeling aanbieden
- Code direct opzetten: Beschrijf een functie in gewone taal en laat een agent de volledige bestandsstructuur en de eerste implementatie genereren
- CI/CD-taken afhandelen: Stel agents in om builds te triggeren en logbestanden te monitoren, zodat u alleen hoeft in te grijpen als er daadwerkelijk een fout optreedt
Leuk weetje: De eerste computerbug was letterlijk een mot, die in 1947 vastzat in een relais van de Harvard Mark II-computer en als bewijs in het logboek werd geplakt.
2. Snel prototypen en UI-iteratie
Frontend-werk verloopt hier sneller omdat de agent kan zien wat hij heeft gebouwd. De Antigravity IDE maakt gebruik van een ‘browser-in-the-loop’-functie. In plaats van dat u een pixel aanpast, de pagina vernieuwt en dit herhaalt, leest de agent de weergegeven gebruikersinterface en past de code aan op basis van visuele feedback.
Dit overbrugt de kloof tussen mock-up en browser op drie manieren:
- Mock-ups omzetten in code: Voer een schermafbeelding of ontwerpbestand in bij de agent om direct functionele frontend-code te genereren
- Componenten aanpassen: Geef de agent de opdracht om de opvulling of het lettertype aan te passen en zie hoe de wijzigingen direct worden weergegeven in de live weergave van de browser
- Voer visuele tests uit: Gebruik agents om automatisch te scannen op weergaveverschillen tussen verschillende browsers
3. Analyse en onderhoud van de codebase
Een Antigravity-agent is een permanente gids voor je opslagplaats. Dit is belangrijk bij verouderde bestanden, waarbij zelfs ervaren engineers de thread kwijtraken. Een gebrek aan duidelijkheid vertraagt de ontwikkeling van nieuwe functies en vergroot je technische schuld.
- Onderzoek de codebase: Vraag de agent hoe een specifieke verificatie-werkstroom werkt en krijg een duidelijke, stapsgewijze uitleg van de logica
- Documentatie genereren: Laat de agent uw scripts analyseren om automatisch technische README's en nuttige inline-opmerkingen te genereren
- Code-problemen opsporen: Gebruik de agent om delen van de code te vinden die voor refactoring in aanmerking komen en laat de agent zuiverdere implementaties voorstellen die u vervolgens kunt goedkeuren
Bekijk hoe engineeringteams technische schulden bijhouden, prioriteren en aflossen met behulp van AI-ondersteunde refactoring en backlog-grooming:
4. Controle van de veiligheid en het opsporen van kwetsbaarheden
Veiligheid vormt geen belemmering meer voor releases wanneer agents de code scannen voordat deze wordt vastgelegd. Antigravity signaleert kwetsbaarheden en stelt oplossingen voor tijdens de ontwikkelingsfase. Hierdoor wordt de handmatige controle, die vroeger uw cyclus vertraagde, een continu proces op de achtergrond.
Agents kunnen:
- Scannen op kwetsbaarheden: Identificeer veelvoorkomende risico's zoals SQL-injectie of cross-site scripting (XSS)
- Afhankelijkheden controleren: Controleer pakketten van derden op bekende risico's, zodat u geen kwetsbaarheden overneemt van externe bibliotheken
- Veiligheidsoplossingen genereren: Bekijk voorgestelde wijzigingen in de code die gedetecteerde fouten verhelpen
5. Integratie van tools uit verschillende functies
Antigravity fungeert als een brug tussen alle onderdelen van uw stack. Het stelt agents in staat taken uit te voeren, waardoor u niet meer heen en weer hoeft te schakelen tussen terminals, browsers en tools voor projectmanagement. Voorbeelden van werkstroommodellen voor AI-orkestratie:
- Automatiseer de cyclus tussen terminal en browser: laat een agent een build uitvoeren, deze in de browser testen en de resultaten naar je teamkanaal sturen
- Losstaande gegevens koppelen: Haal informatie op uit een externe API, werk je database bij en genereer een samenvattend rapport in één werkstroom
- Koppel je AI-tools aan elkaar: koppel Antigravity aan gespecialiseerde tools om geautomatiseerde end-to-end-pijplijnen te bouwen
Uit ons onderzoek blijkt dat bijna 54% van de teams met verspreide systemen werkt, terwijl 49% zelden context tussen tools deelt. Zo ziet het eruit als silo’s daadwerkelijk met elkaar worden verbonden:
Belangrijkste functies die deze toepassingen mogelijk maken
Vier functies werken in uw voordeel: agentmanager, visuele feedback, autonome planning en het genereren van artefacten. Samen laten ze zien hoe Antigravity zelfstandig meerstapswerkzaamheden uitvoert, terwijl u het laatste woord behoudt.
- Agentmanager: Houd meerdere actieve agents in de gaten vanuit één controlepaneel en houd de voortgang binnen verschillende projecten bij
- Visuele feedback: Bekijk UI-wijzigingen en interacties met de browser in realtime terwijl de agents de frontend-code automatisch aanpassen
- Autonome planning: Keur het implementatieplan van een agent goed of pas het aan voordat deze ook maar één regel code schrijft
- Het genereren van artefacten: Controleer concrete deliverables, zoals codepatches of video-walkthroughs, om te bevestigen dat elke actie van een agent aan uw normen voldoet
Antigravity zorgt ervoor dat uw ontwikkelaars zich niet langer bezighouden met het schrijven van code, maar met het beoordelen van ontwerpen
De agents van Antigravity zorgen voor de implementatie. Het is de taak van uw ontwikkelaar om het plan van de agent te beoordelen voordat er ook maar één regel code wordt geschreven. Dat is een andere vaardigheid dan codereview, waarbij wordt bepaald hoe snel het werk wordt opgeleverd.
De twee lijken op elkaar, maar zijn toch verschillend. Bij een codereview wordt gevraagd: ‘Doet deze code wat hij hoort te doen?’ De bedoeling stond al vast voordat iemand de editor opende.
Bij een planbeoordeling wordt gevraagd: ‘Is de intentie zelf correct?’, en je moet die beslissing nemen zonder dat je je gedachtegang aan de hand van code kunt toetsen. De meeste engineers hebben hier geen ervaring mee, omdat dit niet wordt beloond in hun loopbaanontwikkeling. Bovendien is het moeilijker aan te leren dan het oplossen van bugs.
Het ontwerp van Antigravity houdt hier rekening mee. Goedkeuring van plannen en het toestemmingssysteem met drie lijsten ( Weigeren > Vragen > Toestaan ) zijn kernonderdelen van het product, geen optionele instellingen. Google heeft het platform ontwikkeld vanuit de veronderstelling dat het de taak van een mens is om toestemming te verlenen.
Het addertje onder het gras is dat je niet kunt vertrouwen op het gevoel van je team over hoe goed ze hun code autoriseren. Uit een causaal onderzoek naar het gebruik van Cursor in open-sourceprojecten bleek dat de ontwikkelingssnelheid onmiddellijk toenam nadat ontwikkelaars AI gingen gebruiken. Maar de complexiteit van de code en het aantal waarschuwingen uit statische analyses stegen tegelijkertijd ook.
Ontwikkelaars hadden het gevoel dat ze sneller werkten, maar de codebase ging achteruit. Niemand had het door, totdat de gegevens dat aantoonden.
Dit is waarom snelheid niet de juiste maatstaf is om bij te houden. Agenten verhogen de snelheid onmiddellijk, maar dat zegt niets over de kwaliteit van het goedgekeurde werk. De regels voor toestemming, beoordelingen van artefacten en menselijke controlepunten in de rest van deze gids zijn bedoeld om de kwaliteit van uw goedkeuringen te waarborgen. Dat nummer bepaalt of agentgebaseerde ontwikkeling loont.
Antigravity vs. Cursor vs. Claude Code vs. GitHub Copilot
Er zijn vier serieuze kanshebbers op het gebied van agentgebaseerde ontwikkeling: Google Antigravity (een speciaal platform voor agents), Cursor (in je editor), Claude Code (in je terminal) en GitHub Copilot (in je pull-aanvragen). De locatie van de agent bepaalt in wiens wachtrij de output terechtkomt, en dat is het aspect waarmee je team dagelijks te maken heeft.
| Tool | Sterke punten | Limiet | Meest geschikt voor | Prijzen* |
|---|---|---|---|---|
| Google Antigravity | Agents controleren hun eigen weergegeven gebruikersinterface | De uitvoer staat op een plek waar niemand al kijkt | Teams die parallel achtergrondwerk uitvoeren | Individueel – Gratis; AI Pro ~$20/maand, Ultra $100–$250/maand |
| Cursor | De kortste weg tussen intentie en bewerking | Twee identieke zetels kunnen heel verschillend in prijs zijn | Ontwikkelaars die in de editor werken | $20/maand Pro |
| Claude Code | Zorgt voor een samenhangende logica in tientallen bestanden | Geen visueel werkvlak voor frontend-werk | Senior engineers die grote migraties uitvoeren | Gebruiksgebaseerde abonnementen via Anthropic |
| GitHub Copilot | Zet je werk om in resultaten binnen de kaders die je al hebt gecreëerd | Het voordeel verdwijnt buiten GitHub | Organisaties waarvan de review volledig op GitHub plaatsvindt | $10/maand voor particulieren, $19+ voor Business |
Google Antigravity
Antigravity geeft elke agent de meeste ruimte om te werken. Je keurt een plan goed, en het werkt zich door bestanden, de terminal en de browser heen terwijl jij iets anders doet. De andere drie houden een mens dichterbij door hun ontwerp, wat goed werkt totdat je twaalf dingen tegelijk wilt laten gebeuren.
Wat goed werkt:
- Agents die hun eigen uitvoer kunnen zien: Richt er één op een weergegeven pagina en hij corrigeert zijn eigen CSS op basis van wat de browser weergeeft
- Eén weergave van meerdere agents: Bekijk hoe verschillende agents tegelijkertijd afzonderlijke projecten uitvoeren en stap alleen in als er een vastloopt
- Terugkerende taken die je steeds weer vergeet: Laat de nachtelijke testrondes of controles van de afhankelijkheden over aan de geplande taken en bekijk de resultaten 's ochtends
Beperkingen:
- De output komt terecht waar niemand vanzelf kijkt: Copilot plaatst het werk in pull-aanvragen, en Cursor laat het achter in je editor. De artefacten van Antigravity wachten op een plek die iemand bewust moet openen, en de toestemmingsengine regelt de uitvoering zonder de beoordeling bij te houden, zodat een backlog onzichtbaar blijft totdat er iets defect wordt uitgebracht
- Modellen van derden vallen weg in het Enterprise-pakket: Claude Sonnet 4.6, Claude Opus 4.6 en GPT-OSS-120b zijn beschikbaar in de gratis en consumentenabonnementen, maar niet via het Gemini Enterprise Agent Platform. De mix van modellen waarmee uw team proefprojecten uitvoert, is dus niet dezelfde mix die u krijgt nadat de inkoopafdeling het contract heeft getekend.
Sla dit over als: je wilt voelen hoe de agent reageert terwijl je typt. Deze is bedoeld om batches door te geven en vervolgens weg te lopen.
Meest geschikt voor: Teams die langdurige, parallelle achtergrondtaken uitvoeren, met name frontend-iteraties, waarbij een agent zijn eigen weergave controleert en zo beoordelingscycli bespaart.
Cursor
Cursor houdt de agent zo dicht mogelijk bij je vingertoppen. Het leest je cursorpositie en opent buffers. Daardoor is de kloof tussen intentie en uitvoering de kleinste van de vier, en kan een VS Code-team binnen een middag overstappen.
Het voert ook werk uit buiten je eigen computer om via Cloud Agents, dus de oude kritiek dat het ‘aan de editor gebonden’ zou zijn, gaat niet meer op. Wat wel blijft gelden, is dat het product de vorm heeft van een ontwikkelaar die in een sessie zit. Het delegeren van een hele reeks taken is mogelijk; het is alleen niet waarvoor de interface in de eerste plaats is gebouwd.
Wat goed werkt:
- Meerdere bestanden bewerken zonder herhaalde vragen: Geef Hand Composer 2.5 een uitgebreide Taak, en het voert zelfstandig bestandsbewerkingen en terminalopdrachten uit
- Een eerste beoordelaar vóór je eigen beoordelaar: Bugbot geeft commentaar op je vertakking, zodat voor de hand liggende fouten nooit in de wachtrij van een mens terechtkomen
- Veiligheidsmaatregelen voor elke gebruiker: pas de privacy-modus organisatiebreed toe en bekijk het gebruik per ontwikkelaar vanuit één weergave voor beheerders
Beperkingen:
- Twee identieke zetels kunnen heel verschillend in prijs zijn: De keuze van het model bepaalt hoe snel een ontwikkelaar zijn capaciteit verbruikt
- Delegeren kost je de context die het juist snel maakt: De kracht van de cursor zit hem in het lezen van je geopende buffers en de cursorpositie. Een Cloud Agent die werkt op basis van een geschreven opdracht, beschikt daar niet over. Dat betekent dat voor dezelfde Taak een veel explicietere opdrachtomschrijving nodig is
Sla dit over als: je knelpunt ligt in het draaien van veel agents in veel opslagplaatsen, en niet in het versnellen van het werk van één ontwikkelaar in één enkel bestand.
Meest geschikt voor: Ontwikkelaars die een agent in hun cyclus van bewerking willen integreren, met name teams die al gestandaardiseerd zijn op VS Code.
Claude Code
Claude Code is dé oplossing voor een migratie waar niemand aan wil beginnen. Hernoem een functie die op zestig plaatsen wordt gebruikt, en het programma houdt de aanroepketen bij, werkt de tests bij en spoort de twee plekken op waar de handtekening is gewijzigd. Dit alles gebeurt zonder dat er ook maar iets wordt weergegeven in de weergave.
Het begint in de terminal en reikt door tot in IDE’s, Slack, het web en GitHub. Dit betekent dat het naadloos aansluit op de bestaande werkomgevingen van je team, zonder deze te vervangen. Daarom is het de gemakkelijkste van de vier om in te passen, maar ook de moeilijkste om uit te leggen aan iemand die niet in een shell werkt.
Wat goed werkt:
- Werkstroommen die u volgend kwartaal opnieuw kunt uitvoeren: Laat de agent een script schrijven dat meerdere subagenten parallel aanstuurt
- Parallelle agents die elkaar niet in de weg zitten: Agent Teams geven elke agent een eigen werkboom, zodat meerdere agents aan dezelfde opslagplaats kunnen werken zonder elkaars werk te overschrijven
- Consistentie tijdens de gehele migratie: Geef het een Taak die tientallen bestanden omvat, en de logica blijft van begin tot eind consistent
Beperkingen:
- Frontend-werk gebeurt ‘blind’: Omdat er nog niets wordt weergegeven, moet je bij het oplossen van een UI-probleem beschrijven wat er mis is in plaats van het te laten zien. Dit voegt een extra stap toe aan elke visuele wijziging
- De mogelijkheden verschillen per provider: Toegang via een cloudprovider biedt niet dezelfde functies als bij de eigen provider. Daarom moet bij een implementatie binnen een onderneming eerst worden gecontroleerd of de functionaliteit gelijkwaardig is.
Sla dit over als: je werk voornamelijk bestaat uit visuele iteratie, of als de mensen die de agent het hardst nodig hebben liever geen terminal openen.
Meest geschikt voor: Senior engineers die complexe refactoring- en migratieprojecten uitvoeren waarbij de kwaliteit van de redenering bepalend is voor het resultaat.
GitHub Copilot
GitHub Copilot onderscheidt zich meer door de integratie dan door pure functionaliteit. De agent werkt binnen je pull-aanvragen, problemen en acties. De output verschijnt in de wachtrij die je team elke ochtend al opent.
De opzet lost ook een governanceprobleem op dat de andere drie onopgelost laten. Het werk van de agents omzeilt vertakkingbeveiligingen, verplichte reviews en CODEOWNERS. Dit betekent dat de controles die u jarenlang hebt geconfigureerd, blijven werken zonder dat er ook maar één nieuw beleid nodig is.
Wat goed werkt:
- Echte pull-aanvragen, geen losse patches: Wijs een probleem toe, en de cloudagent opent een pull-aanvraag met dezelfde beveiligingsmaatregelen als die voor de vertakking van een mens zouden gelden
- Agents van andere leveranciers in dezelfde werkstroom: stuur een Taak vanuit Copilot door naar Claude Code of Codex zonder GitHub te verlaten
- Een eerste doorloop van elke diff: Laat het programma stijlfouten en voor de hand liggende fouten afhandelen, zodat reviewers hun aandacht kunnen richten op ontwerpbeslissingen
Beperkingen:
- Het voordeel verdwijnt buiten GitHub: als reviews plaatsvinden in GitLab of je CI elders draait, moet je de mogelijkheden van de agents op zichzelf vergelijken, net als bij elke andere tool
- De Taak moet eerst als een probleem worden vormgegeven: De agent werkt op basis van een duidelijk afgebakend probleem en genereert een diff. Voor verkennend werk is het dus nodig dat een mens het te leveren resultaat definieert voordat ermee kan worden begonnen
Sla dit over als: je een agent zoekt met uitgebreide lokale controle over je terminal, browser en bestandssysteem.
Meest geschikt voor: Teams waarvan het reviewproces al volledig op GitHub draait en die AI in die werkstroom willen integreren in plaats van ernaast.
Aan de slag met Google Antigravity
De installatie verloopt in zes stappen: kies uw platform, installeer en synchroniseer, koppel uw werkruimte, stel uw agentmodel in, schakel de Browser Agent in en wijs een eerste taak met laag risico toe. Het Individual-abonnement is gratis en bevat alle functies, zodat u echte agents kunt inzetten nog voordat iemand een bestelling ondertekent. Hier volgt de volgorde.
- Kies uw platform: Kies Antigravity 2.0 voor parallelle agent-coördinatie, de CLI voor headless- en terminal-werkstroomen, of de IDE als uw ontwikkelaars in de editor willen blijven werken. De SDK is bedoeld voor het bouwen van aangepaste agents
- Installeren en synchroniseren: Download de software via antigravity.google op macOS, Linux of Windows. Importeer je bestaande VS Code- of Cursor-instellingen voor een soepele overgang
- Koppel je werkruimte: Open een lokale projectmap en geef de agent een paar minuten de tijd om de opslagplaats te indexeren, zodat hij je logica en structuur begrijpt
- Stel je agentmodel in: Begin met Gemini 3.5 Flash voor snelheid bij routinematig werk. Schakel over naar Gemini 3.1 Pro voor zwaardere redeneertaaken, zoals refactoring van meerdere bestanden
- Schakel de browseragent in: Trigger een eenvoudige Taak om de eenmalige installatie van de Chrome-extensie te triggeren, waarmee visuele feedback wordt ontgrendeld
- Wijs een taak met een laag risico toe: Begin met een README voor één module of unit-tests voor één functie, niet voor uw factureringsdienst
Hoe haal je betrouwbare resultaten uit Google Antigravity?
Betrouwbare resultaten zijn afhankelijk van vijf werkwijzen voor een succesvolle implementatie van AI: duidelijke instructies, vooraf geconfigureerde toestemmingen, controle van artefacten vóór het samenvoegen, starttaken met een laag risico en het bijhouden van iteraties. Sla er ook maar één over, en de output van de agent verslechtert zonder een notificatie. Hier is uw handleiding.
- Schrijf duidelijke, volledige instructies: Geef de agent context over de codebase, het uitvoerformat en eventuele beperkingen. Vage instructies leiden tot vage resultaten
- Stel toestemmingen in voordat je autonomie toekent: Sorteer elke gevoelige actie over de drie toestemmingslisten van Antigravity. Destructieve commando’s horen thuis in ‘Deny’, toestemming voor inloggegevens en de productieomgeving in ‘Ask’, en ‘Allow’ is uitsluitend bedoeld voor routinematige bewerkingen zoals het lezen van bestanden van de opslagplaats of het uitvoeren van tests
- Controleer artefacten voordat je ze samenvoegt: Behandel door agents gegenereerde code alsof het een pull-aanvraag van een junior ontwikkelaar is. Toets de code aan de hand van een checklist voor codereview, zodat een mens de logica valideert, en niet alleen de verschillen (diff).
- Begin met taken met een laag risico: Besteed eerst documentatie, unit-tests voor bestaande code en codebase-analyses uit. Daarmee bouw je vertrouwen op zonder risico’s te lopen, en je factureringsdienst is geen geschikte kandidaat voor de eerste dag.
- Monitoren en itereren: Houd bij welke prompts slagen, bij welke taken de agents steeds falen en waar mensen het vaakst ingrijpen. Die interventiepunten geven aan wat je vervolgens moet aanpassen, of dat nu de prompt, de regel voor toestemming of de taak zelf is
Pro-tip: Stel je toestemmingslisten in vóór de uitvoering, niet tijdens de uitvoering. Toestemmingen die halverwege een taak worden goedgekeurd, worden automatisch goedgekeurd, omdat je, zodra een agent bij de vierde prompt pauzeert, op ‘Toestaan’ klikt om hem aan de gang te houden. Dezelfde logica geldt voor plannen: bekijk ze op verkeerde aannames in plaats van op bugs, aangezien een verkeerde aanname code oplevert die perfect werkt maar het verkeerde probleem oplost, en de diff er intern consistent uitziet.
Hoe u rekening kunt houden met de limieten van Google Antigravity
Antigravity kent vijf beperkingen waarmee u rekening moet houden bij de planning: betrouwbare maar onjuiste uitvoer, wekelijkse quotumlimieten, latentie bij uitsluitend asynchrone verwerking, ongelijkmatige functionaliteitspariteit tussen verschillende platforms en onopgeloste compliancekwesties voor gevoelige code. Als u hiervan van tevoren op de hoogte bent, blijven de verwachtingen realistisch en voorkomt u verrassingen halverwege het project.
- Controleer elke door een agent aangebrachte wijziging: Houd rekening met onjuiste code, verkeerd geïnterpreteerde vereisten en fouten die zelfverzekerd klinken. Er zit nog steeds een LLM-agent achter. Beschouw de output als een concept totdat deze is getest
- Houd rekening met quotumlimieten: Houd rekening met wekelijkse limieten waardoor u tijdelijk geen toegang meer hebt totdat het quotum weer is aangevuld. Houd er ook rekening mee dat extra capaciteit wordt geleverd via AI-credits die apart worden verkocht aan Pro- en Ultra-abonnees. Google maakt niet bekend hoeveel werk u voor één krediet krijgt, dus het inschatten van de kosten per ontwikkelaar blijft giswerk.
- Ontwerp voor asynchroon werk, niet voor pair programming: Zet agents in de wachtrij op de achtergrond en voer taken in batches uit, in plaats van realtime reacties te verwachten terwijl je samen met hen codeert
- Controleer of de functies op alle platforms gelijk zijn: Vergelijk de desktop-app, CLI, IDE en SDK voordat u uw team op één platform standaardiseert. Dit is belangrijk omdat ze niet allemaal dezelfde mogelijkheden bieden
- Controleer de naleving voordat u gevoelige code toevoegt: Beoordeel of Antigravity voldoet aan de vereisten voor veiligheid en gegevensprivacy van uw organisatie voordat u het op uw eigen opslagplaatsen aansluit
Hoe je Antigravity-agenten in ClickUp kunt coördineren
De toestemming-engine van Antigravity bepaalt wat een agent tijdens een run mag doen. Het regelt niet wat er daarna met de output gebeurt: wie deze beoordeelt, hoe lang de toestemming duurt of of iemand een verkeerde aanname opmerkt voordat deze wordt vrijgegeven. Dat is een kwestie van teamcoördinatie, en agentplatforms lossen teamcoördinatie niet op.
ClickUp werkt aan beide kanten van het proces. Codegen haalt de volledige context rond een taak op (beschrijving, acceptatiecriteria, gekoppelde specificaties, opmerkingenhistorie) en geeft deze door aan de agent voordat de uitvoering begint. Dat is een andere invoer dan een prompt die in een terminal wordt getypt. De uitvoer komt terug als een gekoppelde PR waarbij de status, de toegewezen persoon en de deadline al zijn ingevuld.
Voor plannen die buiten ClickUp zijn opgesteld, plakt u er een in een taakbeschrijving, waarna ClickUp Brain deze vergelijkt met actuele sprintgegevens: waarmee er deze week conflicten zijn, welke patches van agents deze maand zijn teruggedraaid en wat ze gemeen hebben, en waar de subtaaken voor de beoordeling moeten worden ondergebracht.
Brain biedt ook toegang tot Claude, GPT en Gemini via één abonnement. U kiest zelf het model dat het beste bij de taak past.
's Nachts is de grootste uitdaging. De geplande taken van Antigravity leveren patches af, ongeacht of je wachtrij leeg is of niet. Superagenten in ClickUp toetsen elk binnenkomend plan aan de Sprint-omvang, rangschikken het op basis van risico en wijzen items met een hoog risico toe aan je meest ervaren beoordelaar. Alles wat na 24 uur nog niet is beoordeeld, wordt geëscaleerd. Je opent 's ochtends een geprioriteerde wachtrij met bijbehorende motivering.
Mariah Wilcox, stafchef van de CBO en CMO bij Seismic, vertelt over agents in ClickUp:
Vroeger bestond onze marketingintake uit eindeloos heen-en-weer-gepraat tussen de aanvrager en de producent, waarbij het proces steeds vastliep als iemand afwezig was. Nu bekijkt een medewerker in ClickUp elke aanvraag, brengt de vereisten in kaart en controleert de capaciteit voordat de opdracht wordt overgedragen. Ons creatieve team gaat direct aan de slag en kan zich volledig richten op het ontwikkelen, in plaats van achter intakeformulieren aan te jagen. Medewerkers nemen geen verlof op!
Vroeger bestond onze marketingintake uit eindeloos heen-en-weer-gepraat tussen de aanvrager en de producent, waarbij het proces steeds vastliep als iemand afwezig was. Nu bekijkt een medewerker in ClickUp elke aanvraag, brengt de vereisten in kaart en controleert de capaciteit voordat de opdracht wordt overgedragen. Ons creatieve team gaat direct aan de slag en kan zich volledig richten op het ontwikkelen, in plaats van achter intakeformulieren aan te jagen. Medewerkers nemen geen verlof op!
Wat werkt specifiek goed voor het beheren van de output van agents:
- Elke patch van een agent komt automatisch in je beoordelingspijplijn terecht: Wanneer een agent een pull-aanvraag opent, worden ClickUp-automatiseringen geactiveerd via de GitHub-integratie. Hierdoor wordt er een taak aangemaakt in je agent-uitvoerlijst, met de pull-aanvraag gekoppeld, de status ingesteld op ‘Beoordeling plannen’ en een deadline toegewezen. Dezelfde automatiseringen voorkomen dat de status naar ‘Goedgekeurd’ verandert, tenzij het veld voor de beoordelaar is ingevuld
- Je kunt precies nagaan wie wat heeft goedgekeurd en waarom: Sla implementatieplannen op in Docs, koppel ze aan de taak en markeer ze als wiki. De versiegeschiedenis registreert elke wijziging; opmerkingen van beoordelaars en tijdstempels van de status worden bij de taak bijgehouden
- Capaciteits- en kwaliteitsproblemen komen aan het licht voordat iemand ze meldt: Houd de gemiddelde verblijftijd in de status ‘Plan Review’ en ‘Code Review’ bij op de ClickUp Dashboards-kaart. Een kaart waarop taken naar achteren zijn verschoven, duidt op een probleem met de doorlooptijd. Wanneer het eerste nummer stijgt terwijl de doorvoer gelijk blijft, heb je een capaciteitsprobleem. Wanneer het tweede nummer stijgt, heb je een probleem met de doorlooptijd.
De eerlijke limiet: ClickUp verzorgt de coördinatie rond de output van de agents. Specifiek voor Antigravity-runs is de verbinding het GitHub-integratiepunt, dus teams waarvan de agents pull-requests openen, krijgen dit automatisch; alle anderen moeten zelf de Taak aanmaken of een webhook instellen.
Voor wie is dit geschikt: Teams die meerdere agents parallel draaien, waarbij de vraag niet langer is ‘kunnen agents dit werk doen’, maar ‘kunnen we het controleren bijhouden’. Een ontwikkelaar die twee agents draait voor nevenprojecten heeft dit niet nodig. De agentmanager van Antigravity is dan voldoende.
Bekijk hoe de werkstroom van een agent verloopt, van trigger tot gecontroleerde output, binnen ClickUp:
Stroomlijn je AI-ontwikkelingswerkstroom met ClickUp
De toepassingsvoorbeelden van Google Antigravity bieden u een duidelijk pad naar het verminderen van handmatige overhead door middel van automatisering van bugfixes en snelle prototyping. Uw succes hangt echter niet alleen af van de technologie. U hebt duidelijke aanwijzingen, sterke veiligheidsmaatregelen en consistent menselijk toezicht nodig om uw codebase stabiel te houden.
Waarschijnlijk verspil je veel te veel tijd aan het wisselen tussen verschillende taken. En hoewel agentgebaseerde platforms een oplossing bieden, werken ze alleen in combinatie met degelijke werkstroombeheer. Het is belangrijk om te leren hoe je AI-agenten sneller aan de slag kunt laten gaan, zodat je eindelijk tijd overhoudt voor creatief werk.
Als je klaar bent om je AI-ontwikkeling en projectmanagement op één plek samen te brengen, begin dan gratis met ClickUp. Ontdek zelf hoe een geïntegreerde werkruimte een einde maakt aan de wildgroei aan tools en ervoor zorgt dat je roadmap op koers blijft.
Veelgestelde vragen over de toepassingsmogelijkheden van Google Antigravity
Wat is er veranderd in Antigravity 2.0?
Antigravity 2.0 bevat een vernieuwde desktop-app, een opdrachtregelinterface en een SDK voor aangepaste agent-werkstroomen. Met de desktop-app kun je meerdere agents tegelijk aansturen, aangepaste werkstroomen voor subagents ontwerpen en taken plannen die op de achtergrond worden uitgevoerd, met integraties voor Google AI Studio, Android en Firebase. Dit markeert een verschuiving van een enkele IDE naar een breder platform voor het aansturen van agents.
Waarvoor kun je Google Antigravity nog meer gebruiken, behalve voor het schrijven van code?
Google beschrijft expliciet werkstroomen voor niet-ontwikkelaars, waaronder concurrentie- en webonderzoek, documentatie en wetenschappelijk werk. De agents beheersen meer dan 20 belangrijke wetenschappelijke databases, waaronder de AlphaFold Database, UniProt, PubChem en ChEMBL, plus baanbrekende modellen zoals AlphaGenome. In het eigen CLI-codelab van Google zijn de oefeningen onderverdeeld in taken voor ontwikkelaars en niet-ontwikkelaars.
Waarom geeft Antigravity aan dat ik mijn quotum heb bereikt, en hoe krijg ik meer?
Antigravity hanteert zowel een basisquotum als wekelijkse limieten. Het basisquotum wordt elke vijf uur vernieuwd bij Google AI Pro en Ultra; als het wekelijkse maximum wordt bereikt, wordt het model geblokkeerd totdat de periode opnieuw begint. Pro- en Ultra-abonnees kunnen AI-kredieten kopen voor extra gebruik, tegen een prijs van $ 25 voor 2.500 kredieten. Google maakt niet bekend hoeveel werk je voor één krediet krijgt, dus het blijft bij een schatting per ontwikkelaar.
Kunnen teams en ondernemingen Google Antigravity gebruiken?
Ja, teams en ondernemingen kunnen Google Antigravity gebruiken. Het is beschikbaar voor Google Cloud-klanten via het Gemini Enterprise Agent Platform, los van de individuele abonnementsniveaus voor Google AI. Individuele accounts vallen onder de gebruiksvoorwaarden voor consumenten van Google; teamimplementaties vallen onder de voorwaarden van Google Cloud. Beoordeel of het voldoet aan uw eigen vereisten op het gebied van veiligheid en gegevensprivacy voordat u agents toegang geeft tot eigen opslagplaatsen.
Waarin verschilt Antigravity van Gemini CLI?
Antigravity CLI heeft Gemini CLI vervangen. Google heeft de Antigravity CLI gelanceerd, een op Go gebaseerde terminal die gebruikmaakt van het Antigravity-agentframework, en heeft de Gemini CLI voor gebruikers buiten gebruik gesteld. Het praktische verschil: Gemini CLI was een lichtere, sessiegebaseerde terminalagent, terwijl Antigravity CLI autonome agents uitvoert, shell-commando's uitvoert en subagents op de achtergrond beheert onder dezelfde toestemming-engine als de desktop-app.