Vibe coding is geen trucje. Het is programmeren met beter gereedschap.

Er wordt veel te makkelijk gedaan over vibe coding.

Alsof het betekent dat je zonder kennis even tegen AI zegt wat je wilt, een paar keer op enter drukt en daarna betrouwbare software hebt.

Dat is natuurlijk onzin.

Vibe coding zonder technische basis is gokken.
Vibe coding mét programmeerervaring is iets heel anders.

Dan gebruik je AI niet als vervanging van kennis, maar als versneller van kennis.

En dat is precies hoe ik ernaar kijk.

Ik programmeerde al in 1981, toen ik twaalf was. Ik begon met Z80 Assembly. Daarna kwamen BASIC, Pascal, Turbo Pascal, Clipper, COBOL, Visual Basic, PHP en JavaScript.

Dat is een behoorlijk lange lijn van programmeren. Van heel dicht op de machine tot steeds hogere abstractieniveaus. Van zelf nadenken over registers en geheugen tot werken met talen, frameworks en tools die steeds meer werk uit handen namen.

Ik weet dus hoe het is om dicht op de techniek te zitten. Om zelf te snappen wat code doet. Om fouten te zoeken. Om logica te bouwen. Om te begrijpen waarom iets wel of niet werkt.

Daarom kijk ik anders naar vibe coding dan iemand die nooit heeft geprogrammeerd.

Ik zie AI-assisted coding niet als valsspelen.
Ik zie het als de volgende logische stap in de evolutie van softwareontwikkeling.

Programmeurs gebruiken altijd al hulpmiddelen

Er wordt soms gedaan alsof vibe coding een radicale breuk is met “echt programmeren”.

Dat vind ik onzin.

Programmeren is altijd makkelijker, sneller en toegankelijker geworden door betere hulpmiddelen.

Vroeger moest je veel dichter op de machine zitten. Je moest precies begrijpen wat de computer deed, hoe geheugen werkte, hoe instructies werden uitgevoerd en hoe je fouten moest opsporen.

Daarna kwamen hogere programmeertalen. Compilers. Frameworks. Libraries. Editors. IDE’s. Debuggers. Versiebeheer. Autocomplete. Syntax highlighting. Linters. Testtools.

Allemaal hulpmiddelen die programmeurs sneller, beter en effectiever maakten.

Niemand zegt: “Je bent geen echte programmeur meer, want je gebruikt syntax highlighting.”

Niemand zegt: “Je bent geen echte programmeur meer, want je compiler vertaalt je code.”

Niemand zegt: “Je bent geen echte programmeur meer, want Visual Studio Code wijst je op fouten.”

Waarom zouden we dat bij AI dan ineens wel zeggen?

Van Z80 Assembly naar AI is geen breuk, maar een logische lijn

Als je zelf die ontwikkeling hebt meegemaakt, zie je hoe logisch deze stap eigenlijk is.

Van Assembly naar BASIC was al een vorm van abstractie.
Van BASIC naar Pascal en Turbo Pascal werd programmeren gestructureerder.
Met Clipper en COBOL bouwde je zakelijke toepassingen op een andere manier.
Met Visual Basic werd interfaceontwikkeling veel toegankelijker.
Met PHP en JavaScript verschoof veel ontwikkeling richting webapplicaties.

Elke stap maakte programmeren anders. Sneller. Toegankelijker. Krachtiger.

En bij elke stap waren er mensen die vonden dat het “niet meer echt programmeren” was.

Maar dat is achteraf altijd onzin gebleken.

Het vak verdween niet.
Het gereedschap werd beter.

En dat is precies wat nu opnieuw gebeurt.

Een compiler was ook ooit een enorme versneller

Een compiler schrijft geen magie.

Een compiler vertaalt jouw intentie naar iets wat de machine begrijpt. Jij schrijft in een programmeertaal die voor mensen leesbaarder is. De compiler zet dat om naar iets wat de computer kan uitvoeren.

Dat heeft programmeren niet minder serieus gemaakt.

Het heeft programmeren juist krachtiger gemaakt.

Je hoefde niet meer alles op het laagste niveau zelf te doen. Je kon abstracter denken. Grotere systemen bouwen. Sneller ontwikkelen. Minder tijd kwijt zijn aan mechanisch werk.

Maar je moest nog steeds weten wat je deed.

Een compiler kon je helpen, maar niet voor je denken.
Een compiler kon fouten melden, maar jij moest ze begrijpen.
Een compiler kon code vertalen, maar jij bleef verantwoordelijk voor de logica.

Dat is met AI niet anders.

AI kan code voorstellen.
AI kan structuur aanbrengen.
AI kan alternatieven geven.
AI kan bugs helpen vinden.
AI kan documentatie maken.
AI kan je enorm versnellen.

Maar jij blijft verantwoordelijk.

Visual Studio Code maakte programmeren ook makkelijker

Neem een tool als Visual Studio Code.

Daarin zit alles wat het leven van een programmeur makkelijker maakt. Syntax highlighting, autocomplete, extensies, terminal, Git-integratie, debugging, linting, formatting en refactoring.

Dat is allemaal ondersteuning.

En niemand ziet dat als bedreiging voor het vak.

Integendeel.

Een goede editor maakt een programmeur beter, sneller en consistenter. Niet omdat de editor de programmeur vervangt, maar omdat de programmeur minder tijd kwijt is aan randzaken.

Je hoeft minder te zoeken.
Je maakt minder typefouten.
Je ziet sneller waar iets misgaat.
Je krijgt sneller feedback.
Je houdt meer ruimte over voor de echte vraag: klopt de logica?

AI doet in essentie hetzelfde, maar dan op een hoger niveau.

Niet alleen code aanvullen.
Maar ook meedenken.
Voorstellen doen.
Patronen herkennen.
Testcases suggereren.
Complexe stukken uitleggen.
Een eerste versie maken die jij daarna beoordeelt en verbetert.

Dat is geen vervanging van programmeerkennis.

Dat is beter gereedschap.

Vibe coding zonder kennis is gevaarlijk

Daar zit wel meteen de waarschuwing.

Als iemand zonder technische basis AI gebruikt om software te bouwen, kan dat snel indrukwekkend lijken.

Er verschijnt code.
Er komt een scherm.
Er werkt iets.
Er staat een demo.

Maar iets dat werkt, is nog niet automatisch goede software.

Een knop die reageert, is geen veilige workflow.
Een formulier dat data opslaat, is geen goed datamodel.
Een dashboard dat opent, is geen betrouwbare applicatie.
Een werkende demo is geen onderhoudbaar product.

Daarom is vibe coding zonder programmeerkennis riskant.

Je kunt dan niet goed beoordelen wat AI maakt. Je weet niet of de structuur klopt. Je ziet niet waar securityproblemen kunnen ontstaan. Je herkent technische schuld niet. Je weet niet of iets later nog aanpasbaar is.

Dan ben je afhankelijk van output die je niet echt begrijpt.

En dat is gevaarlijk.

Vibe coding mét kennis is versnellen met controle

Voor iemand met programmeerervaring ligt dat anders.

Dan kijk je niet alleen naar het resultaat op het scherm. Je kijkt naar wat er onder de motorkap gebeurt.

Klopt de structuur?
Is de code logisch opgebouwd?
Is dit onderhoudbaar?
Is dit veilig genoeg?
Is dit schaalbaar?
Is dit de juiste manier om het probleem op te lossen?
Kan ik dit over drie maanden nog begrijpen?
Kan iemand anders dit straks ook onderhouden?

Dat zijn vragen die AI niet definitief voor je beantwoordt.

Dat moet jij doen.

En precies daar zit het verschil.

Vibe coding zonder kennis is blind vertrouwen.
Vibe coding met kennis is kritisch versnellen.

AI levert snelheid.

De programmeur levert oordeel.

Daarom heb ik meer vertrouwen in mijn eigen AI-assisted development dan in goedkope outsourcing

Daarmee kom ik ook bij een tweede punt.

Jarenlang was de reflex: softwareontwikkeling is duur, dus we besteden het uit.

Naar een extern bureau.
Naar een team op afstand.
Naar landen met lagere uurtarieven.
Naar mensen die technisch uitvoeren wat jij in een briefing probeert te beschrijven.

Dat kan goed gaan. Er zijn overal goede programmeurs.

Maar het structurele probleem is controle.

Zodra je softwareontwikkeling op afstand zet, ontstaat er ruis.

Taalruis.
Cultuurruis.
Interpretatieruis.
Procesruis.
Eigenaarschapsruis.

Jij denkt dat je iets duidelijk hebt uitgelegd.
Zij denken dat ze het goed hebben begrepen.
Er wordt iets gebouwd.
En pas later ontdek je dat het technisch misschien werkt, maar zakelijk niet klopt.

Dat is geen verwijt aan buitenlandse ontwikkelaars. Dat is een probleem van afstand.

Als ik zelf bouw met behulp van AI, heb ik die afstand niet.

Ik zit zelf aan de knoppen.
Ik zie direct wat er gebeurt.
Ik kan direct bijsturen.
Ik kan zelf beoordelen of de structuur logisch is.
Ik kan controleren of de output klopt.

En juist dat maakt het in veel gevallen betrouwbaarder.

Goedkoop ontwikkelen kan duur uitpakken

Outsourcing lijkt vaak aantrekkelijk door het lagere uurtarief.

Maar het uurtarief is zelden het echte probleem.

De echte kosten zitten in miscommunicatie, herstelwerk, afhankelijkheid, ontbrekende documentatie, matige architectuur en gebrek aan eigenaarschap.

Als je niet goed kunt beoordelen wat er gebouwd is, koop je geen software.
Dan koop je afhankelijkheid.

Dat zie je vaak pas later.

Wanneer je iets wilt aanpassen.
Wanneer je een koppeling wilt maken.
Wanneer je wilt opschalen.
Wanneer de oorspronkelijke ontwikkelaar weg is.
Wanneer niemand precies weet waarom iets ooit zo gebouwd is.

Dan wordt goedkoop ineens duur.

AI haalt ontwikkeling dichter naar de bron

Met AI-assisted coding gebeurt iets interessants.

De afstand tussen idee en uitvoering wordt kleiner.

Je hoeft niet alles eerst volledig uit te schrijven voor een extern team. Je kunt zelf, of met een kleine technische kern, veel sneller van idee naar prototype, van prototype naar werkende versie en van werkende versie naar verbetering.

Dat geeft grip.

Niet omdat AI foutloos is.
Maar omdat jij dichter op het proces zit.

Je ziet sneller wat er gebeurt.
Je test sneller.
Je stuurt sneller bij.
Je begrijpt beter waarom iets wel of niet werkt.
Je houdt eigenaarschap over de keuzes.

Dat is strategisch veel waard.

Kleine teams met AI winnen vaak van grote teams zonder context

De oude gedachte was: meer werk vraagt om meer mensen.

De nieuwe realiteit is genuanceerder.

Meer mensen betekent niet automatisch meer kwaliteit. Soms betekent het vooral meer overleg, meer overdracht, meer ruis en meer coördinatie.

Een klein team met veel context, technische bagage en goede AI-tools kan vaak effectiever zijn dan een groot team zonder directe betrokkenheid.

Waarom?

Omdat de feedbackloop korter is.
Omdat de inhoud beter begrepen wordt.
Omdat beslissingen sneller genomen worden.
Omdat fouten eerder zichtbaar zijn.
Omdat eigenaarschap duidelijker ligt.

Softwareontwikkeling draait niet om zoveel mogelijk handjes.

Het draait om de juiste mensen, met de juiste tools, op de juiste plek in het proces.

AI maakt slechte processen sneller slecht

Dit is misschien wel de belangrijkste waarschuwing.

AI maakt niet alles beter.

AI maakt vooral alles sneller.

Een goede aanpak wordt sneller goed.
Een slechte aanpak wordt sneller slecht.

Als je geen duidelijke structuur hebt, produceer je sneller rommel.
Als je geen technische controle hebt, bouw je sneller risico’s in.
Als je geen visie hebt, krijg je sneller losse features zonder samenhang.
Als je geen eigenaarschap hebt, ontstaat er sneller chaos.

AI is dus geen excuus om minder professioneel te werken.

Het is juist een reden om professioneler te werken.

Want de snelheid gaat omhoog. Dus je kwaliteitscontrole moet ook omhoog.

De programmeur verdwijnt niet. De programmeur verandert.

Ik geloof niet dat AI de goede programmeur overbodig maakt.

Ik geloof dat AI de goede programmeur belangrijker maakt.

Want als AI steeds sneller code kan produceren, wordt het steeds belangrijker dat iemand kan beoordelen of die code goed is.

Niet alleen: doet het iets?
Maar: klopt het?
Is het veilig?
Is het onderhoudbaar?
Past het bij het grotere geheel?
Is dit een slimme oplossing of een snelle lapmiddelenoplossing?

Dat oordeel komt niet uit de tool.

Dat komt uit ervaring.

Conclusie: vibe coding is geen shortcut, maar volwassen programmeren met modern gereedschap

Vibe coding is geen wondermiddel.

Het is ook geen bewijs dat iedereen nu zomaar goede software kan bouwen.

Vibe coding zonder programmeerkennis is riskant. Dan vertrouw je op code die je niet echt begrijpt.

Maar vibe coding mét programmeerervaring is een enorme versneller. Dan gebruik je AI zoals programmeurs altijd betere tools hebben gebruikt: om sneller, slimmer en effectiever te werken.

Voor mij is AI-assisted coding dus geen breuk met programmeren.

Het is de volgende laag bovenop alles wat er al was.

Na Z80 Assembly.
Na BASIC.
Na Pascal en Turbo Pascal.
Na Clipper en COBOL.
Na Visual Basic.
Na PHP en JavaScript.
Na compilers, IDE’s, Visual Studio Code en autocomplete.

Nu komt AI.

Niet als vervanging van vakmanschap.
Maar als versterking ervan.

De echte vraag is niet of AI code kan schrijven

De echte vraag is wie de regie houdt.

Wie begrijpt de logica?
Wie bewaakt de kwaliteit?
Wie controleert de output?
Wie ziet de risico’s?
Wie zorgt dat het onderhoudbaar blijft?
Wie neemt verantwoordelijkheid voor het eindresultaat?

Als het antwoord is: “de AI”, dan heb je een probleem.

Als het antwoord is: “iemand met decennia programmeerervaring die AI slim inzet”, dan heb je juist een voorsprong.

Want AI maakt softwareontwikkeling sneller.

Maar vakmanschap maakt het betrouwbaar.

Werk je aan software, interne tools, automatisering of een nieuw digitaal product? Stel jezelf dan niet alleen de vraag wat het kost om iets te laten bouwen.

Stel vooral deze vragen:

• Wie heeft de regie?
• Wie begrijpt de context?
• Wie kan de code inhoudelijk beoordelen?
• Wie bewaakt kwaliteit, veiligheid en onderhoudbaarheid?
• Wie is eigenaar van het eindresultaat?

Daar zit het verschil tussen snel iets bouwen en duurzaam iets goeds neerzetten.