Mijn eerste volledig ge-vibe-codede project
Ik bouw een eigen webmailclient door alleen nog te prompten
De proef op de som
Ik begeef me in een bubbel waarin ik om de haverklap artikelen en filmpjes voorbij zie komen over vibe-coden. Over projecten die in een paar dagen worden gebouwd, nieuwe AI-modellen en programma’s die vrijwel zelfstandig apps, websites en webshops uit de grond stampen. Sommige beloven zelfs complete marketingkanalen te kunnen beheren.
Ik had wat tijd en besloot de proef op de som te nemen: ik ging een eigen project volledig vibe-coden. Maar hoe goed werkt dat nu echt? En wat gebeurt er wanneer je als ervaren programmeur besluit om niet meer zelf te programmeren, maar alleen nog te prompten?
Programmeren is magie
Programmeren voor het web voelt voor mij nog steeds een beetje als magie. Bij het bouwen van een website typ ik als programmeur tekst, die de browser vervolgens omzet in iets visueels. Ik schrijf bijvoorbeeld font-size: 20px en de tekst op de website wordt twintig pixels groot. Of ik schrijf width: 10px; height: 10px; border-radius: 20px en er verschijnt een klein vierkantje met afgeronde hoeken. Gaaf. Dat kan ik dus.
Ik begon in de jaren negentig met het bouwen van websites. Sindsdien heb ik allerlei programma’s en werkwijzen zien langskomen: van WYSIWYG-programma’s — what you see is what you get — waarin je direct zag wat je maakte, tot omgevingen waarin je uitsluitend code schrijft.
Toen het internet net opkwam, waren de mogelijkheden om websites vorm te geven nog minimaal. We moesten met omwegen en hacks proberen iets op het scherm te krijgen zoals we het in ons hoofd hadden. Browsers kregen steeds meer mogelijkheden, programmeurs ontdekten nieuwe toepassingen en er kwamen nieuwe soorten schermen bij, zoals mobiele telefoons. Websites werden steeds soepeler, interactiever en geschikt voor ieder scherm.
De basis is alleen nooit echt veranderd: we moeten nog steeds in code beschrijven wat een website aan de voorkant moet laten zien en hoe die zich moet gedragen.
Mijn eigen fundament
Juist omdat veel programmeerwerk bestaat uit terugkerende patronen, kunnen taalmodellen er zo goed mee overweg. De ene keer is een border-radius tien pixels, de andere keer twintig. Ook de logica achter een website is vaak terug te brengen tot opdrachten als: als dit gebeurt, doe dan dat.
Code kun je op verschillende manieren opbouwen. Zo heb je onder andere procedureel en objectgeoriënteerd programmeren. Ik heb beide geleerd en werk inmiddels ongeveer tien jaar voornamelijk objectgeoriënteerd.
In de afgelopen twintig jaar heb ik bovendien mijn eigen stack opgebouwd: een verzameling vaste code, onderdelen, conventies en oplossingen waarop ik honderden websites heb gebouwd. Die stack is mijn fundament. Alle regels code zijn door mijzelf geschreven. Ik weet waar alles staat, waarom het daar staat en wat het doet. Ik ken die omgeving van de hoed en de rand.
Een digitale collega
In mijn codeprogramma Visual Studio Code verscheen op een gegeven moment een digitale collega: GitHub Copilot. Terwijl ik typ, vult Copilot regels code voor me aan. Een soort autocomplete, maar dan een die ook probeert te begrijpen wat ik wil maken. Schrijf ik het begin van een functie, dan stelt Copilot de rest voor. Vind ik het voorstel goed, dan voeg ik het met één druk op de knop toe.
Dat levert een flinke snelheidswinst op. Bovendien kan AI rekening houden met mijn manier van programmeren. Ik kan zelfs een instructiebestand maken waarin precies staat hoe code geschreven moet worden, welke conventies ik gebruik en hoe mijn stack in elkaar zit. Eigenlijk geef ik de AI-agent een handleiding voor hoe hij binnen mijn werkplaats moet werken.
Dat zie ik als versterking van mijn vak. Ik bepaal wat er gebeurt, begrijp de code en blijf verantwoordelijk voor de keuzes. AI helpt me vooral sneller te typen en oplossingen uit te werken. Maar volledig vibe-coden is iets anders.
Een eigen webmailclient
Ik geloof dat vibe-coden krachtig kan zijn, maar ik geloof ook sterk in mijn eigen ambacht: weten welke code waar staat, begrijpen wat die doet en zelf een oplossing kunnen repareren wanneer het misgaat. Daarom wilde ik onderzoeken of ik een relatief complex project volledig door AI kon laten bouwen en toch op een bruikbaar niveau kon krijgen.
Het project heet Post 1: mijn eigen webmailclient.
Gmail probeert op allerlei manieren meer geld te verdienen aan zijn gebruikers. Tegelijkertijd wil ik minder afhankelijk worden van Big Tech. De belofte van vibe-coden, gecombineerd met mijn wens om bij Gmail weg te gaan, vormde een mooie aanleiding om zelf een mailclient te ontwerpen — helemaal op basis van mijn eigen wensen.
De eerste ideeën en visuele opzet maakte ik samen met ChatGPT. Ik had zelf een lijst met functies opgesteld en besprak vervolgens met AI wat erin moest komen, hoe alles moest werken en wat voor mij belangrijk was. Dat voelde als een goede brainstorm. Uit die gesprekken kwamen ook de eerste visuele ontwerpen.
Vanaf nu programmeer ik niet meer zelf
Daarna ging ik verder in Visual Studio Code. Ik gaf de AI mijn wensenlijst en de screenshots en we begonnen met bouwen. Via de chatfunctie laat ik de webmailclient opbouwen binnen mijn eigen stack. Het fundament heb ik dus nog steeds zelf gemaakt. Daardoor weet ik in ieder geval waar het project begint en kan ik de AI richting geven wanneer die iets niet begrijpt. Bovendien is die basis gewoon goed. Het zou zonde zijn om voor dit experiment helemaal opnieuw te beginnen.
Vanaf dat punt programmeer ik alleen niet meer zelf. Ik prompt.
Het zal wel goed zijn
Het bouwen bestaat uit veel heen-en-weer chatten, maar het gaat verrassend goed. Ik geef mijn wensen één voor één door en de AI bouwt wat ik vraag. Soms probeer ik nog wat code te lezen, maar ik merk dat ik al snel verval in: het zal wel goed zijn.
Ik test de nieuwe functie aan de voorkant. Als die werkt, ga ik door naar de volgende. De laksheid van mij als programmeur ontstaat verbazingwekkend snel. Normaal wil ik begrijpen waarom iets werkt. Nu is een zichtbaar werkend resultaat al snel voldoende. De code verdwijnt naar de achtergrond en de applicatie wordt voor mij steeds meer een zwarte doos.
Ik merk bovendien hoe snel de tokens binnen mijn abonnement opraken. Soms ben ik er binnen een halve dag doorheen en moet ik extra budget aanspreken om verder te kunnen. Dat doe ik vervolgens ook, want inmiddels ben ik verdwaald in honderden regels code die ik niet zelf heb geschreven.
Ik kan natuurlijk programmeren, maar dit project is juist bedoeld om te onderzoeken of vibe-coden voor mij werkt. Zelf ingrijpen zou het experiment vertroebelen. Daardoor ben ik voor de voortgang opeens afhankelijk geworden van de AI die de code heeft geproduceerd.
Ben ik nog wel de programmeur?
Het is te eenvoudig om te zeggen dat AI Post 1 bouwt en ik alleen opdrachten geef. Ik ben de stuwende kracht: ik bepaal wat de webmailclient moet kunnen, deel wensen op in technische functies en beoordeel het resultaat. Daarbij helpt mijn ervaring. Ik weet hoe databases, functies en onderlinge processen werken en kan daardoor gerichte vragen stellen.
AI schrijft de code, maar mijn kennis bepaalt voor een belangrijk deel wat er ontstaat. Tegelijkertijd is dat ook een valkuil. Omdat ik erop vertrouw dat ik problemen later wel kan oplossen, accepteer ik gemakkelijker code die ik niet volledig begrijp.
Ik programmeer dus op een andere laag. De grote keuzes zijn van mij, terwijl AI onderweg talloze kleine beslissingen neemt. Daardoor weet ik precies wat Post 1 moet kunnen, maar steeds minder goed hoe Post 1 dat doet.
Indrukwekkend snel
De chat blijft ondertussen onvermoeibaar vriendelijk. De AI stelt sympathieke maar ook behoorlijk assertieve vragen en het gesprek voelt soms echt alsof een andere programmeur voor mij aan het werk is.
Mijn ervaring als programmeur helpt wel degelijk. Omdat ik weet hoe websites en software werken, kan ik meestal snel de juiste vragen stellen. Ik kan een probleem opdelen in functies, herken wanneer iets niet logisch werkt en weet welke informatie de AI nodig heeft om verder te komen. Misschien schrijf ik de code niet, maar mijn vakkennis bepaalt nog steeds in belangrijke mate de kwaliteit van mijn prompts.
Post 1 begint inmiddels serieus vorm te krijgen. De webmailclient heeft profielen, verschillende mailadressen, verzenden en ontvangen, prioriteitssterren en labels. Bijna alles wat ik tot nu toe wilde, is gelukt.
Dat is indrukwekkend. Het kost flink wat tokens, maar de uitwerking gaat vermoedelijk sneller dan wanneer ik alles zelf had moeten typen. En ik heb voor dit project bewust geen regels code zelf geschreven.
Snel gebouwd, maar niet van mij
Toch merk ik dat ik onderweg de weg kwijtraak. Ik heb geen gevoel meer voor de code en nauwelijks zicht op de structuur die is ontstaan. Ik weet niet welke keuzes de AI precies heeft gemaakt, tenzij ik de code alsnog helemaal ga controleren. En juist dat doe ik steeds minder, omdat de functies aan de voorkant gewoon lijken te werken.
Voor een experimentele demo vind ik dat nog acceptabel. Voor projecten van klanten voelt het heel anders. Dan wil ik weten wat er onder de motorkap gebeurt, of gegevens veilig worden verwerkt, of de code onderhoudbaar is en of een volgende programmeur ermee verder kan.
Ik vermoed ook dat latere aanpassingen steeds lastiger worden wanneer ik zelf niet weet waar ik moet zoeken. Op dit moment kan ik dezelfde AI vragen om iets te wijzigen. Maar wat als het model verdwijnt, het AI-bedrijf failliet gaat, de prijzen fors stijgen of de chat de context van het project niet meer aankan? Dan blijf ik achter met duizenden regels code waarin ik me met terugwerkende kracht moet verdiepen.
Ik heb dus wel iets gebouwd, maar ik heb het me nog niet volledig eigen gemaakt.
Vibe-coden maakt me een ander soort programmeur
Dit experiment laat me zien dat er voor mij een waardevolle middenweg bestaat. Ik kan zelf de architectuur en de belangrijkste regels code bepalen, terwijl AI me helpt die sneller uit te werken. Dan functioneert AI als versterking van mijn vakmanschap.
Mijn programmeervaardigheden volledig uit handen geven voelt daarentegen te gevaarlijk. Bovendien maakt het mijn werk daadwerkelijk minder leuk.
Het zoeken naar oplossingen, het puzzelen tot iets werkt en begrijpen waarom het werkt, vormen een wezenlijk onderdeel van mijn plezier in programmeren. Wanneer AI dat hele proces overneemt, lever ik niet alleen controle in. Ik verlies ook een deel van wat het vak voor mij interessant maakt.
Zodra ik niet meer weet wat zich onder de motorkap afspeelt, wordt mijn houding vanzelf lakser. Een functie werkt, dus door naar de volgende. Tot het moment waarop iets niet meer werkt en niemand precies weet waarom.
Vibe-coden blijkt dus uitstekend te werken om snel iets te maken. De lastigere vraag is of je daarna ook werkelijk eigenaar bent van wat je hebt gebouwd.
Artikel geschreven door:
Aleks en ChatGPT