Vibecoden deel 2:
met een Agent

Omdat ik tijdens mijn eerste experiment met vibecoden toch al een beetje lui begon te worden, ben ik nog een stap verder gegaan: vibecoden met een Agent.

In mijn vorige artikel beschreef ik hoe ik Post 1, mijn eigen webmailclient, bouwde door voortdurend met AI te chatten. Ik legde uit wat ik wilde, kreeg code terug, probeerde die uit en gaf daarna de volgende opdracht. De AI programmeerde, maar ik bleef degene die het project in kleine stappen opdeelde. Ik bepaalde steeds wat er vervolgens moest gebeuren.

Met een Agent veranderde dat. Ik hoefde niet meer precies te vertellen welke bestanden aangepast moesten worden of welke stap als eerste gezet moest worden. In plaats daarvan beschreef ik vooral het einddoel. De Agent onderzocht vervolgens zelfstandig mijn project, zocht uit hoe de bestaande onderdelen met elkaar samenhingen en maakte een plan om de opdracht uit te voeren.

Dat plan kon ik eerst laten reviewen en aanpassen. Pas daarna begon de Agent daadwerkelijk aan de code. Waar ik bij chatten steeds de volgende afslag aanwees, hoefde ik nu vooral te vertellen waar ik uiteindelijk wilde uitkomen.

Eerst het hele project onderzoeken

Het opvallendste verschil merkte ik voordat er ook maar één regel code werd aangepast. De Agent begon met het doorzoeken van mijn project. Hij opende bestanden, volgde functies, onderzocht de databaseopzet en probeerde te begrijpen waarom bepaalde onderdelen waren gebouwd zoals ze waren gebouwd.

Vervolgens kwam hij met een eigen stappenplan. Niet alleen een herhaling van wat ik had gevraagd, maar een technische vertaling daarvan: welke onderdelen gewijzigd moesten worden, in welke volgorde dat het beste kon en welke bestaande functies opnieuw gebruikt konden worden.

Dat voelde wezenlijk anders dan chatten. De AI reageerde niet meer alleen op mijn laatste vraag, maar leek een groter besef te hebben van het einddoel. Voor het eerst had ik het gevoel dat ik niet samen met AI aan het programmeren was, maar werk aan een programmeur had gedelegeerd.

Is hij nog bezig?

Daarmee ontstond ook meteen een probleem dat bij delegeren hoort: ik wilde af en toe wel weten hoe het ermee stond.

Een Agent kan behoorlijk lang met een opdracht bezig zijn zonder tussendoor iets van zich te laten horen. In het begin wachtte ik gewoon af, maar na verloop van tijd werd dat onhandig. Het voelde soms alsof hij was vastgelopen. Ik wist niet of de Agent nog aan het nadenken was, code aan het schrijven was of daadwerkelijk ergens niet meer uitkwam.

Juist doordat hij zo zelfstandig werkte, verloor ik zicht op wat er ondertussen gebeurde. Bij chatten waren de stappen korter. Ik stelde een vraag, kreeg antwoord en kon weer verder. Bij de Agent kon er achter één opdracht een lange reeks handelingen schuilgaan, zonder dat ik precies zag waar hij mee bezig was.

Ik merkte ook dat een te grote opdracht niet altijd beter werkt. Een Agent die eerst uitgebreid onderzoek laat doen, een groot plan opstelt en daarna alles in één keer probeert uit te voeren, kan lang onderweg zijn. Soms is het nog steeds handiger om een probleem kleiner te maken of tijdelijk terug te schakelen naar Chat.

Verslavend goed

Toch moet ik toegeven dat werken met een Agent behoorlijk verslavend is. Niet omdat ik nu achterover kan leunen en helemaal niets meer hoef te doen, maar omdat het daadwerkelijk werkt.

Ik beschrijf een functie die ik voor ogen heb, de Agent onderzoekt wat daarvoor nodig is en enige tijd later staat er iets wat verrassend dicht in de buurt komt van wat ik bedoelde. Als dat lukt, is de verleiding groot om meteen de volgende opdracht te geven. En daarna nog één. Iedere geslaagde aanpassing maakt het aantrekkelijker om een groter deel van het project uit handen te geven.

Het resultaat is tot nu toe indrukwekkend. Ik ben nauwelijks echt vastgelopen en krijg behoorlijk precies wat ik voor ogen heb. Ondertussen kan Post 1 bijlagen verwerken, gesprekken goed tonen en met verschillende afzenderprofielen werken. Het begint steeds meer op een serieus product te lijken.

Toch betekent dit niet dat mijn eigen kennis overbodig is geworden. Ik moet nog steeds veel input geven. Ik moet kunnen uitleggen wat ik wil bereiken, welke onderdelen belangrijk zijn, hoe gebruikers ermee moeten werken en wanneer een voorgestelde oplossing niet bij mijn project past. Daarvoor moet ik wel degelijk begrijpen wat ik aan het bouwen ben.

Misschien verschuift de benodigde kennis. Ik hoef niet meer iedere regel code zelf te schrijven, maar ik moet het probleem wel goed kunnen ontleden. Ik moet eisen formuleren, keuzes maken, uitzonderingen herkennen en het resultaat beoordelen. Zonder die kennis kan een Agent iets bouwen wat technisch werkt, maar niet noodzakelijk het juiste probleem oplost.

Dat vind ik ergens geruststellend. De Agent neemt veel uitvoerend werk over, maar mijn ervaring bepaalt nog steeds waar het project naartoe gaat.

Steeds verder van mijn eigen code

Daar ontstaat tegelijkertijd een nieuwe valkuil. Omdat alles zo soepel verloopt, ben ik de geschreven code steeds minder goed gaan nakijken. Ik beoordeel vooral of het eindresultaat werkt en eruitziet zoals ik bedoelde. Maar als ik later zelf iets wil aanpassen, kan blijken dat ik nauwelijks nog weet hoe het onder de motorkap in elkaar zit.

De Agent neemt mij dus niet alleen werk uit handen, maar vergroot ook de afstand tussen mij en mijn eigen project.

Dat hoeft niet meteen een probleem te zijn. Ook zonder AI werkten programmeurs al met frameworks, libraries en open-sourcecode die ze niet volledig zelf hadden geschreven. Maar bij Agent coding kan die afstand veel sneller groeien. In een middag kunnen er zoveel bestanden en functies veranderen dat het bijna onmogelijk wordt om iedere regel nog rustig te bestuderen.

Het risico verschijnt waarschijnlijk pas later: bij een storing, een beveiligingsprobleem of een aanpassing die niet netjes binnen de bestaande opzet past. Dan is het niet genoeg dat de code gisteren werkte. Ik moet ook kunnen achterhalen waarom hij vandaag niet meer werkt.

En toen keek ik naar de rekening

Terwijl ik steeds enthousiaster werd over het resultaat, had ik eigenlijk geen idee wat de Agent ondertussen verbruikte. Ik had Claude Sonnet 5 geselecteerd en liet hem langdurig zelfstandig door mijn project werken. Onderzoeken, plannen maken, bestanden openen, code schrijven, controleren en opnieuw aanpassen: het gebeurde allemaal binnen ogenschijnlijk doorlopende opdrachten.

Tot ik op GitHub naar mijn verbruik keek.

In vijf dagen tijd bleek voor 179,60 dollar (en nu zit ik op 217 dollar) aan modelgebruik te zijn geregistreerd. Daarvan werd 15 dollar gedekt door inbegrepen gebruik. Het daadwerkelijk gefactureerde bedrag stond inmiddels op 164,61 dollar. Op één dag had ik zelfs voor bijna 65 dollar aan AI gebruikt.

Dat was even iets anders dan het vaste maandbedrag dat ik in mijn hoofd had. De Agent werkte zelfstandig, maar bleek ook zelfstandig geld uit te geven.

Achteraf is het ergens logisch. Zo'n Agent beantwoordt niet één vraag en stopt daarna. Hij leest grote delen van het project, roept het model meerdere keren aan, controleert zijn eigen werk en probeert problemen opnieuw op te lossen. Terwijl ik alleen een voortgangsindicator zag, kon er achter de schermen een hele reeks kostbare modelacties plaatsvinden.

De vrijheid die ik de Agent gaf, bleek dus twee kanten te hebben. Hij nam mij veel denk- en programmeerwerk uit handen, maar ik verloor tegelijkertijd het zicht op zowel het proces als de kosten.

Genoeg tokens, maar toch niet verder kunnen

Alsof de rekening nog niet genoeg waarschuwing was, liep ik daarna ook tegen een rate-limit aan. Terwijl ik nog tokens en gebruiksbudget beschikbaar had, verscheen de melding dat ik de limiet van mijn sessie had bereikt. Ik kon mijn abonnement upgraden of 87 minuten wachten voordat ik verder mocht.

Blijkbaar is betalen of voldoende tokens hebben dus niet hetzelfde als onbeperkt toegang hebben. Naast de totale hoeveelheid gebruik kan er ook een limiet gelden voor hoe intensief ik binnen een bepaalde tijd met de Agent werk. Precies op het moment dat ik lekker bezig was en verder wilde bouwen, bepaalde het platform dat ik voorlopig klaar was.

Dat maakt deze manier van werken nog minder voorspelbaar. Bij traditioneel programmeren kan ik in principe doorgaan zolang mijn computer werkt en ik zelf nog energie heb. Met Agent coding kan mijn werkritme ook worden onderbroken door een grens die iemand anders heeft ingesteld. De Agent is dan niet inhoudelijk vastgelopen en ik ben niet door mijn tegoed heen, maar toch staat het project stil.

Het is misschien maar 87 minuten wachten. Toch voelde het ineens serieus. Ik had mijn manier van werken in korte tijd zo sterk rond de Agent georganiseerd, dat ik zonder die Agent niet vanzelfsprekend verderging. In plaats van zelf de code in te duiken, zat ik naar een klok te kijken totdat mijn digitale programmeur weer beschikbaar kwam.

Wat als de Agent verdwijnt?

Er ontstaat nog een andere kwetsbaarheid wanneer ik steeds grotere delen van mijn project door een Agent laat bouwen. Ik word niet alleen afhankelijk van de geschreven code, maar ook van de bedrijven en modellen waarmee ik die code maak.

Als OpenAI, GitHub of Anthropic mijn account blokkeert omdat een systeem — terecht of onterecht — denkt dat ik iets doe wat tegen de richtlijnen ingaat, kan een belangrijk deel van mijn gereedschap van het ene op het andere moment verdwijnen. Hetzelfde geldt wanneer Claude tijdelijk niet bereikbaar is, een model uit VS Code wordt verwijderd of een abonnement ineens andere voorwaarden krijgt.

Mijn project blijft natuurlijk op mijn eigen computer staan. Maar als ik ondertussen nauwelijks meer weet hoe grote delen van de code werken, kan ik alsnog behoorlijk vastlopen. Dan bezit ik de broncode wel, maar niet meer volledig de kennis waarmee die tot stand is gekomen.

Dat maakt deze manier van werken anders dan het gebruik van een gewone open-sourcelibrary. Als zo'n library niet langer wordt onderhouden, blijft de bestaande code meestal beschikbaar en kan ik die in theorie zelf aanpassen. Een AI-model bezit ik niet. Ik krijg tijdelijk toegang tot een dienst waarvan de mogelijkheden, prijs en regels kunnen veranderen.

Hoe beter de Agent wordt, hoe groter de verleiding om mijn eigen kennis minder te gebruiken. En hoe minder ik die kennis gebruik, hoe afhankelijker ik word van de beschikbaarheid van de Agent. Dat is een merkwaardige tegenstelling: het gereedschap maakt mij op korte termijn veel krachtiger, maar kan mij op langere termijn ook minder zelfstandig maken.

Ben ik nog aan het programmeren?

Tijdens mijn eerste experiment met vibecoden vroeg ik mij al af of ik nog wel echt aan het programmeren was. Ik schreef steeds minder code zelf, maar bleef wel voortdurend betrokken bij iedere stap. Met een Agent is die afstand nog groter geworden. Ik beschrijf wat ik wil bereiken, beoordeel het plan en controleer uiteindelijk of het resultaat werkt.

Mijn rol verandert dus. Ik ben minder bezig met het schrijven van afzonderlijke regels code en meer met het ontwerpen van het systeem als geheel. Ik stel de kaders, maak keuzes en bepaal wanneer iets werkelijk af is.

Misschien ben ik daardoor niet minder aan het programmeren, maar vindt het programmeren op een ander niveau plaats. Tegelijkertijd moet ik oppassen dat ik niet alleen nog naar het oppervlak kijk. Een werkende knop zegt weinig over de kwaliteit, veiligheid en onderhoudbaarheid van alles wat erachter zit.

Een explosie van creativiteit?

Als we deze technologie goed leren inzetten, kan er volgens mij een enorme explosie van creativiteit ontstaan. Niet alleen bij programmeren, maar ook bij beeld, tekst, geluid en animatie. Technieken waarvoor eerder verschillende specialisten, veel tijd of een groter budget nodig waren, komen binnen het bereik van één maker.

Op dit moment zien we veel AI-slop. Iemand die geen ontwerper is, voert één prompt in en laat ChatGPT een volledige poster maken. Het resultaat ziet er op het eerste gezicht soms indrukwekkend uit, maar mist vaak eigenheid, samenhang en afwerking. Omdat veel mensen ongeveer dezelfde modellen op ongeveer dezelfde manier gebruiken, beginnen de resultaten bovendien steeds meer op elkaar te lijken.

Maar dat zegt vooral iets over de manier waarop het gereedschap wordt gebruikt. Een goede ontwerper hoeft geen volledige poster door AI te laten maken. Die kan specifieke onderdelen genereren, resultaten selecteren, verschillende technieken combineren en de uiteindelijke compositie zelf afmaken.

Eigenlijk is dat niet heel anders dan het gebruik van stockfotografie. Ook daarbij maakte een ontwerper niet ieder onderdeel zelf. Een bestaande foto kon het uitgangspunt vormen voor een nieuwe compositie, zolang de ontwerper maar bepaalde hoe het beeld werd uitgesneden, bewerkt, gecombineerd en toegepast. Het creatieve werk zat niet uitsluitend in het maken van het bronmateriaal, maar ook in de selectie en alle beslissingen daarna.

Voor programmeren geldt iets vergelijkbaars. Programmeurs gebruiken al jaren frameworks, libraries en open-sourcecode. We schrijven zelden werkelijk alles vanaf nul. Met Agent coding komt daar een nieuw en bijzonder krachtig gereedschap bij. De Agent kan grotere onderdelen onderzoeken, uitwerken en implementeren, terwijl ik bepaal wat ik nodig heb en hoe het binnen het grotere project moet functioneren.

De interessante vraag is daarom niet alleen of Agent coding nog wel echt programmeren is. De interessantere vraag is wat ik ermee kan maken wat daarvoor buiten mijn bereik lag.

Een gereedschap, geen eindresultaat

Mijn experiment met Agent coding leverde in korte tijd veel op. Post 1 kreeg nieuwe functies, de Agent liep nauwelijks echt vast en het resultaat kwam verrassend dicht bij wat ik voor ogen had. Tegelijkertijd hield hij zich soms lange tijd stil, keek ik de geschreven code steeds minder goed na en bleek al die zelfstandigheid in een paar dagen meer dan 160 dollar te hebben gekost.

Het is dus geen magische knop waarmee goede software vanzelf ontstaat. Het is krachtig, verslavend en op sommige momenten zelfs een beetje ongemakkelijk. Hoe meer de Agent kan overnemen, hoe belangrijker het wordt dat ik zelf blijf begrijpen wat ik wil, welke keuzes er worden gemaakt en waar mijn verantwoordelijkheid ligt.

AI kan middelmatige software sneller produceren, net zoals het eindeloos middelmatige posters, teksten en beelden kan genereren. Maar in de handen van iemand met ervaring, ideeën en een eigen richting kan hetzelfde gereedschap juist nieuwe mogelijkheden openen.

Agent coding vervangt mijn gereedschapskist daarom niet. Het is een nieuw gereedschap dat ik eraan toevoeg. Een behoorlijk duur gereedschap, ontdekte ik inmiddels. Maar ook eentje waarmee ik misschien dingen kan bouwen die ik daarvoor nooit zelf had kunnen maken.