Van programmeur naar builder
Waarom AI code sneller maakt, maar goede software nog steeds begint bij begrijpen wat er echt gebeurt
“Kunnen we dat straks niet gewoon door AI laten maken?”
Die vraag hoor je de laatste tijd steeds vaker. En eerlijk: ik snap hem wel. Als je ziet wat tools als Claude Code, Copilot of ChatGPT inmiddels kunnen, dan is het indrukwekkend. Je beschrijft wat je wilt, en even later staat er code. Soms zelfs verrassend goede code.
Een scherm erbij. Een API-endpoint. Een testje. Een stukje documentatie. Een refactor waar je zelf eigenlijk geen zin in had.
Als je al wat langer software maakt, voelt dat bijna oneerlijk. Werk waar je vroeger een halve dag aan zat te sleutelen, komt er nu soms in een paar minuten uit.
Maar toch denk ik niet dat daarmee het vak kleiner wordt.
Het wordt anders.
Code typen was nooit het moeilijkste deel
Natuurlijk moet code goed zijn. Daar hoeven we niet moeilijk over te doen. Rommelige code wordt vanzelf een probleem. Zeker als een systeem jaren mee moet, gekoppeld is aan andere systemen, of gebruikt wordt in een proces waar fouten geld, tijd of gedoe opleveren.
Maar code typen was zelden het moeilijkste deel.
Het lastige zit vaak ergens anders.
Wat bedoelt de gebruiker precies?
Welke uitzondering komt in de praktijk tóch voor?
Waarom wordt dat Excel-bestand nog steeds naast het systeem gebruikt?
Welke controle doet iemand handmatig, omdat het systeem die niet vertrouwt?
Wat gebeurt er als een koppeling halverwege faalt?
Welke status mag je nooit automatisch overslaan?
Dat zijn de vragen waar software interessant wordt.
Niet in de perfecte demo-flow, maar in de rommelige werkelijkheid eromheen.
De werkelijkheid past niet netjes in een prompt
Een AI-tool kan heel veel. Maar hij kent jouw proces niet vanzelf.
Hij weet niet dat veld X alleen gevuld wordt als afdeling Y eerst iets heeft goedgekeurd. Hij weet niet dat een bepaalde klant altijd net afwijkt. Hij weet niet dat een foutmelding duidelijk moet zijn voor iemand die om 16:55 nog snel iets wil afronden. Hij weet niet dat die ene controle ooit is toegevoegd omdat het jaren geleden een keer goed misging.
Dat soort kennis zit niet netjes in een ticket. En vaak ook niet in documentatie.
Die zit in gesprekken. In meekijken. In vragen stellen. In net iets langer blijven hangen bij een opmerking als: “Ja, meestal wel, behalve als…”
Voor mij zit daar een groot deel van het vak.
Software bouwen is niet alleen vertalen wat iemand vraagt. Het is ontdekken wat iemand eigenlijk nodig heeft.
De eerste 80% is leuk. De rest bepaalt of het blijft staan.
AI is heel goed in een eerste versie. Soms zelfs irritant goed.
Je hebt snel iets dat draait. Een scherm. Een database. Een flow. Een nette structuur. Misschien zelfs tests erbij. Dat is heerlijk, want het haalt veel traagheid uit het begin.
Maar daarna begint het echte werk.
Wat als iemand dubbel klikt?
Wat als een bestand net anders is dan verwacht?
Wat als twee gebruikers tegelijk hetzelfde aanpassen?
Wat als een externe API een halve reactie teruggeeft?
Wat als data technisch geldig is, maar functioneel nergens op slaat?
Wat als iets niet fout gaat, maar nét verkeerd?
Daar zit het verschil tussen “het werkt op mijn machine” en software waar je op kunt vertrouwen.
De laatste 20% is vaak niet spectaculair. Geen mooie demo. Geen applaus. Geen screenshot voor op LinkedIn.
Maar daar zit wel de kwaliteit.
Logging. Validatie. Autorisatie. Herstelbaarheid. Duidelijke foutmeldingen. Fatsoenlijke defaults. Geen stille datacorruptie. Geen magische aannames. Geen proces dat alleen werkt zolang iedereen precies doet wat de ontwikkelaar in gedachten had.
Dat is niet glamour. Dat is gewoon goed vakwerk.
AI maakt mij niet minder ontwikkelaar
Wat ik fijn vind aan AI, is dat het veel werk versnelt waar ik niet per se romantisch over hoef te doen.
Boilerplate schrijven. Een DTO maken. Een mapping opzetten. Een stuk code laten uitleggen. Een test laten voorstellen. Even drie varianten bekijken. Een lelijke functie opentrekken en opnieuw structureren.
Prima. Graag zelfs.
Maar daardoor blijft er meer ruimte over voor het deel dat ik eigenlijk het belangrijkst vind: snappen wat er gebeurt.
Hoe loopt het proces echt?
Waar raakt iemand de draad kwijt?
Welke stap voelt logisch voor ICT, maar niet voor de gebruiker?
Waar zit een risico dat niemand ziet omdat het al jaren “gewoon zo gaat”?
Welke simpele controle voorkomt later een hoop ellende?
AI helpt bij het bouwen. Maar je moet nog steeds weten wat je aan het bouwen bent.
En vooral: wanneer het goed genoeg is om op te vertrouwen.
Van programmeur naar builder
Daarom vind ik “builder” eigenlijk wel een mooi woord.
Niet omdat “programmeur” ouderwets is. Ik ben programmeur, en met plezier. Maar builder zegt net iets meer.
Een builder kijkt niet alleen naar code. Die kijkt naar het geheel.
De flow. De data. De gebruiker. De uitzonderingen. De koppelingen. De afhankelijkheden. De dingen die fout kunnen gaan. En ook de kleine details waardoor software prettig voelt in plaats van irritant.
Een goede builder houdt van techniek, maar wordt niet blind voor de praktijk.
Die vindt het net zo belangrijk dat een foutmelding begrijpelijk is, dat een knop op de juiste plek staat, dat een proces niet onnodig dubbel werk veroorzaakt, en dat je later nog kunt achterhalen waarom iets is gebeurd.
Dat klinkt misschien minder stoer dan “AI vervangt alles”.
Maar volgens mij is het wel dichter bij de waarheid.
AI gaat softwareontwikkeling enorm veranderen. Het maakt bouwen sneller, toegankelijker en soms ook leuker. Maar goede software blijft afhankelijk van mensen die precies genoeg nerd zijn om details serieus te nemen, en precies genoeg mens om te begrijpen voor wie ze het doen.
De code was nooit het hele punt.
Het systeem moet kloppen.
Voor de machine, maar vooral voor de mensen die ermee moeten werken.
Bart van den Ancker, maart 2026