AI maakt programmeren makkelijker — maar worden senior developers straks schaarser?

1. AI maakt programmeren toegankelijker — maar verandert ook hoe developers gevormd worden

AI-tools die code genereren worden vaak gepresenteerd als een grote democratisering van softwareontwikkeling. Met tools als Copilot, ChatGPT en andere assistenten kunnen beginners sneller iets bouwen dat werkt.

AI-tools zijn zonder twijfel een productiviteitssprong voor softwareontwikkeling. Het zou vreemd zijn om dat te ontkennen.

Op korte termijn is dat ook zichtbaar. Prototypes verschijnen sneller. Kleine projecten komen makkelijker van de grond. Veel taken die vroeger tijd kostten – boilerplate schrijven, documentatie zoeken, simpele fouten oplossen – gaan nu aanzienlijk sneller.

Maar onder die productiviteitswinst ligt een andere vraag die minder vaak wordt gesteld:

Wat gebeurt er met het leerpad dat developers traditioneel doorlopen om senior te worden?

Senior developers ontstaan namelijk zelden doordat iemand simpelweg veel code produceert. Ze ontstaan doordat iemand gedurende jaren systemen leert begrijpen: waarom iets werkt, waarom iets breekt, en welke aannames daarachter zitten.

AI verandert dat leerproces. Niet per se door het onmogelijk te maken, maar wel door het anders te laten verlopen dan voorheen.

2. Senior developers ontstaan niet door output, maar door mentale modellen

Als je kijkt naar hoe veel ervaren programmeurs hun vak hebben geleerd, zie je een vrij herkenbaar patroon.

Het begon zelden met elegante architecturen of perfect geschreven code. Veel vaker begon het met code die niet werkte:

• een query die niets teruggeeft
• een variabele die onverwacht verandert
• een API die anders reageert dan verwacht
• een foutmelding die weinig uitleg geeft

Het oplossen van dat soort problemen kost tijd. Soms veel tijd.

Maar precies in dat proces ontstaat begrip. Je leert:

• hoe data door een systeem stroomt
• waar state ontstaat en verandert
• hoe afhankelijkheden elkaar beïnvloeden
• waarom kleine wijzigingen onverwachte gevolgen kunnen hebben

Dat soort mentale modellen vormt uiteindelijk de basis van senioriteit. Niet het aantal regels code dat iemand kan schrijven, maar het vermogen om systemen te doorgronden.

3. AI laat code vaak werken voordat het begrepen wordt

AI-assistenten zijn extreem goed in het genereren van plausibele code. In veel gevallen werkt die code ook meteen.

Voor beginners is dat een enorme versnelling. Waar je vroeger eerst documentatie moest lezen, voorbeelden zoeken en experimenteren, kun je nu direct een functioneel stuk code krijgen.

Daar zit echter een subtiele verschuiving.

Wanneer code werkt voordat je begrijpt waarom, ontstaat er minder noodzaak om de onderliggende logica te onderzoeken.

Denk bijvoorbeeld aan een simpele bug waarbij een variabele onverwacht null wordt.

Vroeger betekende dat vaak: logs lezen, stap voor stap door de code lopen en begrijpen waar de state verandert.

Vandaag kan een developer de code in een AI-tool plakken en een suggestie krijgen die het probleem oplost. Het systeem werkt weer — maar het pad dat normaal naar begrip leidde is een stuk korter geworden.

4. Debuggen was historisch gezien de echte leerschool

Programmeren lijkt op het eerste gezicht vooral te draaien om schrijven. In de praktijk bestaat een groot deel van het werk uit debuggen.

Ervaren developers besteden veel tijd aan:

• code lezen die ze niet zelf geschreven hebben
• begrijpen waarom iets kapot is gegaan
• hypotheses formuleren
• aannames testen

Dit proces dwingt developers om steeds opnieuw mentale modellen bij te stellen.

AI verandert die dynamiek. Veel problemen worden nu opgelost door simpelweg te vragen:

"Why is this not working?"

Het model stelt een oplossing voor, past een stuk code aan, en vaak werkt het daarna.

Dat kan efficiënt zijn. Maar als de developer het probleem zelf niet heeft hoeven analyseren, groeit het begrip van het systeem minder snel.

5. Wanneer problemen verdwijnen, verdwijnt een deel van het leerproces

Historisch gezien was falen een belangrijk onderdeel van leren programmeren.

Niet omdat falen op zichzelf waardevol is, maar omdat het onvermijdelijk was. Als iets niet werkte, moest je het probleem ontleden.

Je moest:

• documentatie lezen
• logs analyseren
• experimenteren met alternatieve oplossingen
• stap voor stap aannames controleren

AI verandert die feedbackloop. Veel fouten worden opgelost door een nieuwe suggestie te genereren.

Het systeem gaat verder. Maar het pad dat vroeger leidde tot diep begrip wordt soms korter.

Dat betekent niet dat beginners niets leren. Maar het soort ervaring dat ze opdoen kan anders zijn dan bij eerdere generaties developers.

6. Beginners leren steeds meer assemblage-vaardigheden

In een AI-ondersteunde workflow verschuift de aard van het werk gedeeltelijk.

In plaats van alles zelf te schrijven, leren veel nieuwe developers eerder:

• prompts formuleren
• AI-output beoordelen
• gegenereerde oplossingen combineren
• systemen assembleren uit bestaande stukken

Dat zijn waardevolle vaardigheden.

Maar het risico is dat de fundamenten – hoe systemen intern werken – minder vaak expliciet worden opgebouwd.

Een developer kan daardoor prima in staat zijn om functionaliteit te bouwen, maar moeite hebben met vragen zoals:

• waarom een systeem instabiel wordt
• waar performance verdwijnt
• waarom data inconsistent raakt

En dat zijn precies de problemen waar senior developers het grootste deel van hun tijd aan besteden.

7. Waarom ervaren developers juist profiteren van AI

Opvallend genoeg hebben veel ervaren developers een heel andere ervaring met AI-tools.

Voor hen zijn deze systemen vaak een sterke productiviteitsboost.

Dat komt omdat zij de ontbrekende context al hebben. Ze beschikken over de mentale modellen die nodig zijn om gegenereerde code te beoordelen.

AI fungeert dan niet als vervanging van kennis, maar als versneller ervan.

Dit verklaart ook waarom dezelfde tool voor beginners en experts een heel ander effect kan hebben.

8. Wat dit op langere termijn kan betekenen voor de industrie

Op korte termijn lijkt AI het tekort aan ontwikkelaarscapaciteit te verlichten. Meer mensen kunnen sneller software bouwen.

Maar software leeft vaak veel langer dan de periode waarin het gebouwd wordt.

Systemen moeten onderhouden worden, uitgebreid worden en aangepast worden aan nieuwe eisen.

Dat werk vraagt developers die systemen echt begrijpen.

Als het leerpad dat vroeger senior developers vormde minder vaak wordt doorlopen, kan dat op termijn betekenen dat de groep developers met diep systeembegrip relatief kleiner wordt.

9. Wat dit betekent voor teams die junior developers aannemen

Voor engineeringteams verschuift daardoor mogelijk ook de manier waarop junior developers beoordeeld worden.

Het wordt minder belangrijk of iemand snel code kan produceren met behulp van AI.

Belangrijker wordt bijvoorbeeld:

• kan iemand uitleggen waarom code werkt?
• kan iemand een probleem analyseren zonder directe AI-oplossing?
• kan iemand een systeem logisch verklaren?

Niet omdat AI onbetrouwbaar is, maar omdat begrip niet automatisch ontstaat door generatie.

10. Hoe beginners alsnog sterke fundamenten kunnen ontwikkelen

AI maakt programmeren niet waardeloos als leerpad.

Maar beginners die sterke fundamenten willen ontwikkelen zullen waarschijnlijk bewust momenten moeten creëren waarop ze:

• code zelf schrijven zonder AI
• fouten eerst zelf analyseren voordat ze hulp vragen
• bestaande systemen proberen te begrijpen
• complexe bugs stap voor stap ontleden

AI kan werk versnellen. Maar ervaring blijft iets dat alleen ontstaat door tijd en herhaling.

11. Samenvatting: AI verandert niet alleen hoe we programmeren, maar ook hoe developers ontstaan

AI-tools veranderen softwareontwikkeling ingrijpend.

Maar misschien ligt de grootste verandering niet in hoe software wordt gebouwd, maar in hoe developers worden gevormd.

Senior developers ontstonden traditioneel uit een lange reeks experimenten, fouten en langzaam opgebouwde mentale modellen.

Als AI een deel van dat proces verkort, ontstaat een nieuwe uitdaging voor teams en organisaties:

niet hoe we sneller code schrijven, maar hoe we ervoor zorgen dat er ook in de toekomst genoeg developers zijn die werkelijk begrijpen waarom die code werkt.

3 veelvoorkomende misverstanden over AI en programmeren

1. "AI maakt programmeren eenvoudiger, dus het wordt makkelijker om een goede developer te worden."
AI maakt het makkelijker om werkende code te produceren. Maar code laten werken is niet hetzelfde als begrijpen waarom het werkt.

2. "AI vervangt programmeerkennis."
In de praktijk halen developers met sterke fundamenten juist meer uit AI-tools.

3. "Met AI kunnen beginners sneller senior worden."
AI kan het tempo verhogen waarin iemand projecten bouwt, maar senioriteit ontstaat vooral door ervaring met complexe systemen en onverwachte fouten.