Het einde van software zoals we dat kennen

Bart Grootveld is spreker, ondernemer en expert op het gebied van AI, productiviteit, software en de toekomst van werk. Na ruim twaalf jaar in productontwikkeling en enterprise software bij AFAS Software richtte hij Vrijdag.AI op, waarmee hij organisaties helpt om AI niet alleen te begrijpen, maar ook praktisch toe te passen. Vanuit die ervaring laat hij zien wat kunstmatige intelligentie verandert aan kenniswerk, productiviteit en de manier waarop organisaties zijn ingericht. Daarbij kijkt hij verder dan de techniek: welke keuzes moet je nu maken om AI echt waarde te laten toevoegen?

Een robot die een lekker bakkie koffie voor je zet.. Dat klinkt leuk toch? Nou, hier komt nogal wat bij kijken. Hij moet een kopje herkennen, inschatten hoe stevig hij het mag vastpakken, rekening houden met mensen die langslopen en voorkomen dat hij kokend water over tafel giet. De fysieke wereld zit bomvol met uitzonderingen. Daarom duurt het waarschijnlijk nog best wel wat jaartjes voordat we allemaal onze persoonlijke huishoudrobot hebben.

Wat er op je computer gebeurt is een ander verhaal. Een applicatie bestaat niet uit gladde vloeren en vallende kopjes, maar uit code, databases, API's en regels. Ook complex.. maar wel een wereld die voorspelbaar is en die AI veel beter kan lezen.

Precies daarom is softwareontwikkeling een van de eerste vakgebieden die door AI fundamenteel op zijn kop gaat. Niet omdat developers gaan verdwijnen.. maar omdat hun impact explodeert!

Software bouwt software

Softwareontwikkeling werkt traditioneel als volgt; mensen bedachten wat een applicatie moest kunnen, engineers vertaalden dat naar code, en tools als editors, frameworks en testplatformen hielpen daarbij. De mens bouwt software met behulp van andere software.

Nu gebeurt er iets anders. AI kan code lezen en schrijven, bugs analyseren, tests genereren, systemen refactoren en requirements vertalen naar werkende functionaliteit. Software helpt dus niet langer alleen maar de programmeur. Software begint software te bouwen.

Dat klinkt misschien als een subtiel verschil, maar economisch is het gigantisch. Zodra programmeerwerk niet meer 1 op 1 gekoppeld is aan menselijke arbeid, verandert de verhouding tussen het aantal developers en de hoeveelheid software die een organisatie kan produceren.

Iedereen kan ineens software maken

Iedereen die recent met AI ontwikkeltools heeft zitten spelen, kent het bijna magische moment. Je beschrijft wat je wilt: een app, een dashboard, een website. Een paar minuten later staat er iets. Knoppen werken, data wordt opgeslagen, de interface ziet er (soms) verrassend goed uit.

Dit heet vibe coding. En het bewijst dat natuurlijke taal een interface voor softwareontwikkeling wordt. Dat democratiseert de technologie echt enorm.

Maar er zit een gevaarlijke misvatting in: Iedereen kan opeens “toffe” software maken. Maar dat betekent niet dat iedereen opeens “goede” software kan maken. Want wat gebeurt er achter die knappe interface? Hoe is authenticatie geregeld? Wat gebeurt er als een externe API uitvalt? Kun je over 6 maanden nog begrijpen hoe het systeem werkt? En belangrijker: weet de maker überhaupt welke vragen hij zou moeten stellen?

Software die op je laptop werkt is iets anders dan software in productie, waarop duizenden klanten of bedrijfskritische processen moeten kunnen vertrouwen. Vibe coding verlaagt de drempel om software te bouwen. Niet de drempel om betrouwbare software te bouwen.

AI maakt fouten... maar jij ook!

Tuurlijk, AI hallucineert nog steeds. Het stelt onveilige code voor, begrijpt architectuur niet goed en lost problemen overtuigend op een manier op die onder de motorkap soms totaal fout blijkt. Maar goed, mensen maken ook fouten. De juiste vraag is daarom niet of AI software zonder fouten kan schrijven, maar: binnen welk systeem kun je AI laten werken?

Geef iemand zonder softwarekennis een krachtige coding-agent en je krijgt in een spectacular tempo mooie software met gigantische gaten. Geef diezelfde agent aan een ervaren engineer die architectuur, security, testen en deployment begrijpt, en er gebeurt iets totaal anders. Dan is de AI extra capaciteit.

Van programmeren naar agentic engineering

Dat is het verschil tussen ‘vibe coding’ en ‘agentic engineering’. Je geeft AI niet zomaar de opdracht "bouw een app". Je creëert een omgeving waarin AI gecontroleerd kan werken: architectuurprincipes, codingstandaarden, tests, securitychecks, reviewprocessen, CI/CD, monitoring. De agent krijgt vrijheid, maar binnen een systeem dat door mensen met vakkennis is ontworpen.

Daarmee verandert de rol van de engineer. Minder tijd gaat naar het produceren van iedere regel code, en meer naar het ontwerpen van het systeem waarin code geproduceerd wordt. De engineer wordt architect, regisseur en kwaliteitsbewaker.

Dat maakt softwarekennis niet minder belangrijk. Ik denk juist het tegenovergestelde: AI maakt softwarekennis niet overbodig, AI geeft mensen met softwarekennis superkrachten. Wie begrijpt waarom een systeem werkt en waar het fout kan gaan, krijgt een enorme hefboom. Software engineering gaat misschien eindelijk weer méér over engineering en minder over code kloppen.

De AI-softwarefabriek

Het woord softwarefabriek roept een beeld op van autonome AI die ergens in een datacenter applicaties uitspuugt. Daar zijn we niet. De softwarefabriek van vandaag is bemand. Slimme mensen bepalen welk probleem wordt opgelost, welke architectuur past, welke risico's acceptabel zijn en wanneer iets klaar is.

Maar rond die mensen ontstaat steeds meer digitale capaciteit. Agents die requirements uitwerken, code schrijven, tests schrijven, security controleren, documentatie bijhouden en pull requests beoordelen. De truc zit niet in hoe intelligent één agent is, maar in hoe je al die capaciteit organiseert. Welke context geef je mee? Welke fouten mogen nooit productie bereiken? Hoe zorg je dat het systeem iedere volgende keer beter werkt?

Dat is AI-native softwareontwikkeling: niet werken aan de volgende feature, maar werken aan een fabriek die features van hoge kwaliteit produceert.

Disruptie

Stel je een team voor van vijf sterke mensen met productkennis, architectuurervaring en goed begrip van AI. Geef ze moderne coding-agents, sterke automatisering en een goed ingerichte softwarefabriek. Hoeveel output kan zo'n team leveren?

Wat gebeurt er met de softwaremarkt wanneer een klein team kan produceren wat vroeger een grote organisatie vereiste?

Dan verandert bijna alles: time-to-market, kosten, marges, organisatiestructuren, prijsmodellen. Headcount wordt steeds minder een goede indicatie van wat een softwareorganisatie kan produceren. Een startup van vijf extreem sterke mensen kan opeens een markt betreden waar een paar jaar geleden tientallen miljoenen en een grote ontwikkelorganisatie nodig waren.

Dat is geen productiviteitsverbetering. Dat verandert de economie van software.

Bestaande softwarebedrijven hebben een voordeel

Je zou concluderen dat bestaande softwarebedrijven een probleem hebben. Dat lijkt me te eenvoudig. Juist zij hebben iets wat AI-native nieuwkomers jarenlang moeten opbouwen: domeinkennis, klantrelaties, data, kennis van regelgeving, distributie. En vooral: jarenlange ervaring met alles wat mis kan gaan wanneer software de echte wereld raakt.

Die ervaring wordt niet waardeloos, ze kan vermenigvuldigd worden. Een organisatie die twintig jaar kennis over logistiek, finance, zorg of HR slim vertaalt naar agents, tooling en processen heeft een enorme uitgangspositie.

De grootste bedreiging voor bestaande softwarebedrijven is daarom niet AI zelf. Het is een concurrent met dezelfde vakkennis die AI veel agressiever inzet.

De bottleneck verschuift

Als code produceren goedkoper wordt, verschuift de bottleneck. Vroeger was ontwikkelcapaciteit het probleem: te weinig developers, volle roadmaps, ideeën die maanden op een backlog lagen.

Wanneer die schaarste afneemt, worden andere zaken bepalend. Hebben we het juiste probleem gekozen? Begrijpen we de klant goed genoeg? Kunnen we agents voldoende context geven en kwaliteit betrouwbaar meten? Productvisie, domeinkennis en besluitvorming worden relatief belangrijker.

Misschien is de belangrijkste eigenschap van het softwarebedrijf van de toekomst niet hoeveel developers het heeft, maar hoeveel goede beslissingen het per week kan nemen.

Closing the loop

Maar trek de lijn één stap verder door. Wat als software zelf kan constateren dat iets niet goed werkt, kan analyseren waarom, een verbetering bedenkt, implementeert, test en beoordeelt? Dan ontstaat ‘closing the loop’. Nu zijn wij nog een essentieel onderdeel van die lus: wij geven opdrachten, beoordelen en bepalen wanneer iets goed genoeg is. Maar software die zijn eigen verbetercyclus steeds verder sluit, is een fundamenteel ander soort systeem. Geen product met een release per twee weken, maar software die continu observeert, leert en verbetert.

Daar zijn we nog niet, en er zijn enorme technische en veiligheidsvragen voordat dit verantwoord kan. Maar wil je begrijpen waar deze ontwikkeling naartoe beweegt, dan is dit het vergezicht: niet AI die sneller code voor ons schrijft, maar software die steeds meer verantwoordelijkheid krijgt voor het proces waarmee nieuwe software ontstaat.

Dit is niet het einde van developers

Uitspraken als "AI vervangt programmeurs" reduceren een systeemverandering tot een banendiscussie. Natuurlijk veranderen rollen en teams. Maar de grotere verandering zit ergens anders: individuele productiviteit kan enorm toenemen, softwarekennis vermenigvuldigt zich via agents, kleine teams betreden markten waar vroeger grote organisaties voor nodig waren.

We kijken inderdaad naar het einde van software zoals we dat kennen. Niet omdat software verdwijnt, integendeel: we gaan meer software maken dan ooit. Maar hoe die software ontstaat, wie eraan werkt en wat we eigenlijk nog onder softwareontwikkeling verstaan, staat aan het begin van een enorme verandering.

Het einde van software zoals we die kennen is niet het einde van software. Het is het einde van hoe we software tot nu toe maakten.