Mijn ervaring als een “AI-powered” engineer“.

Elke developer die met AI werkt, heeft tegenwoordig twee Copilots op zijn schouders zitten. De engel schrijft de boilerplate waar je geen zin in had en geeft je een middag terug. De duivel dupliceert stilletjes een functie drie bestanden verderop omdat hij de abstractie niet kon zien, en haalt ondertussen je portemonnee leeg.

Een groot deel van de industrie discussieert op dit moment over welke van de twee de echte is. Het eerlijke antwoord is: allebei, voortdurend. Het werk is in stilte verschoven naar het leren onderscheiden van die twee, op het moment zelf.

AI-powered engineer

Ik ben geen AI-expert. Niet in de academische zin van het woord. Ik heb nog nooit een model getraind, nooit vanaf nul een neuraal netwerk gebouwd en ik kan je niet vertellen wat er op gradient-niveau gebeurt wanneer een transformer zijn volgende token kiest.

Wat ik wél heb gedaan is oprecht goed worden in het gebruiken van de tools die uit al dat onderzoek zijn voortgekomen. En dat onderscheid is belangrijker dan mensen denken.

De term waar ik steeds op uitkom is “AI-powered engineer”. Die vat het werk samen zoals het echt is: mijn beslissingen, mijn architectuur, mijn smaak, versneld door een systeem dat ongeveer honderd keer sneller typt dan ik.

De vaardigheid is niet om een model om code te vragen. Dat kan iedereen. De vaardigheid is weten wát je moet vragen, wannéér je het moet vragen, en welk antwoord fout is voordat de testsuite het je vertelt. Prompts die met intentie zijn geschreven leveren bruikbare output op. Vage prompts leveren plausibel ogende onzin op.

Onder de motorkap

Bij Delta-N hebben we de afgelopen tijd steeds meer van onze development workflow naar GitHub verplaatst. Copilot schrijft inmiddels code op basis van onze instructies. Het beschrijft de wijzigingen die het heeft gemaakt, reviewt eigen pull requests, draait ze door CodeQL en laat Dependabot zelfstandig de dependency tree bijhouden.

Werk dat vroeger een hele dag kostte, gebeurt nu ’s nachts. De volgende ochtend ligt er een nette samenvatting klaar. Veel frictie van vroeger is verdwenen. Toch blijf ik mezelf afvragen of dat altijd een goede ontwikkeling is.

Meestal wel. Boilerplate waar ik vroeger over mopperde, komt nu al uitgewerkt binnen. Migraties die een middag kostten, staan in minuten op papier. Ik lees meer code dan ik schrijf. Dat ligt dichter bij waar senior werk altijd al over ging.

Wanneer het model afdrijft naar een fragiele abstractie of een patroon voorstelt dat niet voorbij drie gebruikers schaalt, merk ik dat snel op. Ik heb genoeg code opgeleverd om de vorm van een toekomstige bug te herkennen. Juist dat deel kun je niet uitbesteden. Het model schrijft de regel. De engineer bepaalt of die regel in de codebase thuishoort.

Wat me onrustig maakt, is hoe dit er van buitenaf uitziet.

Achter de groene vinkjes

Een paar weken geleden keurde ik een pull request af die op papier alles goed deed. De tests waren groen. De code zag er netjes uit. De diff telde dertig regels, allemaal met vinkjes ernaast. Toch bleken twaalf regels al te bestaan in een utility module die het model niet als context had meegekregen. De collega die de suggestie accepteerde wist dat niet. Ik wist het alleen omdat ik die utility drie maanden eerder zelf schreef.

Het verschil tussen een junior en een senior wordt voor een ongetraind oog steeds lastiger te zien. Een afgestudeerde produceert nu in een ochtend output waar een ervaren engineer vroeger een week voor nodig had. De PR’s ogen schoon. De tests slagen. De code compileert. Voor wie niet goed oplet, lijkt het werk hetzelfde.

Wie wel goed kijkt, ziet direct het verschil. Suggesties worden goedgekeurd zonder dat iemand ze echt begrijpt. Code wordt verderop opnieuw gebouwd omdat het model niet zag dat de abstractie al bestond. Patronen verschijnen opnieuw omdat het model een conventie miste die twee mappen hoger al stond.

Dat zie je niet terug in de diff. Het komt pas maanden later naar boven, wanneer iemand de code moet aanpassen. Dan blijkt het geen geheel, maar een lappendeken. Van buiten strak. Van binnen los aan elkaar geknoopt.

Dat is de stille keerzijde van AI assisted development. Het oogt als productiviteit en telt ook zo mee in dashboards en metrics. Tickets sluiten sneller. Pull requests worden gemerged. De velocity stijgt. De rekening volgt later, in het deel van de codebase waar niemand aan wil werken.

Doen de fundamenten er nog toe?

Hoe leiden we straks de volgende generatie developers op? Begrijpen zij nog wat de gegenereerde code onder de motorkap doet? Of is dat straks minder belangrijk? Vertrouwen we de modellen en schuift menselijk begrip simpelweg omhoog in de stack?

Ik weet het eerlijk gezegd niet. Ik zie het experiment in real time gebeuren en heb daar nog geen sluitende theorie over.

Ik vertel junioren dat ze iedere diff regel voor regel moeten lezen. Dat ze zichzelf moeten afvragen of ze het ook zelf hadden kunnen schrijven. De meesten doen dat. Sommigen niet. Juist dat verschil wordt een van de belangrijkste carrièrefilters van het komende decennium.

De diepere vraag is of fundamenten straks nog tellen. Moet je nog begrijpen hoe code zich vertaalt naar de machine? Heeft wiskundig inzicht nog waarde? Voor veel functies misschien niet direct.

Toch zie ik steeds hetzelfde patroon. De mensen die in twee seconden een slechte modelsuggestie herkennen, zijn bijna altijd dezelfde mensen die die code zelf hadden kunnen schrijven. Die intuïtie ontstaat niet vanzelf. Daarvoor moet je lang genoeg met moeilijke problemen worstelen om ze later direct te herkennen, ook als ze in een andere vorm terugkomen.

AI wordt duurder

Het andere waar ik scherp op let, is geld. AI is nu nog goedkoop. Verdacht goedkoop. De modellen worden gesubsidieerd en de prijzen blijven vriendelijk. Vrijwel iedere developer die ik ken, stuurt zonder nadenken zoveel mogelijk context mee om te kijken wat het model oplevert. Dit voelt als het Netflix tijdperk van AI tooling. Of het Uber tijdperk. Of Amazon Prime. Kies je favoriete VC gesubsidieerde lokkertje. Het patroon blijft hetzelfde: eerst goedkoop, daarna geprijsd als nutsvoorziening.

De eerste hobbel staat al gepland. In juni verandert GitHub Copilot van een enterprise abonnement van 39 euro per maand naar een pay as you go model. Je betaalt straks per token in plaats van per request. Ik rekende mijn huidige gebruik door en kwam uit op ongeveer 350 euro per maand. Geen typefout. Bijna tien keer zoveel voor dezelfde workflow.

Dat gaat gedrag veranderen. Teams sturen straks minder context naar het model om kosten te drukken. Precies daar ontstaan de fouten die ik eerder beschreef.

Het model ziet de bestaande abstractie niet en dupliceert een functie. Het mist een conventie en verzint een nieuwe. Het ziet de architectuur niet en stelt lokaal prima code voor die zes maanden later de hele structuur onderuit haalt. Minder context betekent niet minder AI gebruik. Het betekent minder bruikbare AI, terwijl de kosten blijven oplopen.

Pas ik me daarop aan? Waarschijnlijk wel. Ik word selectiever in wat ik meestuur. Ik gebruik lichtere modellen voor simpel werk en bewaar de dure modellen voor de momenten waarop ze echt nodig zijn. Ik schrijf scherpere prompts. Misschien maakt dat me uiteindelijk een betere operator. Beperkingen doen dat vaak. Toch denk ik dat veel teams straks ontdekken dat een deel van hun productiviteitswinst gebouwd was op een prijsmodel dat nooit zou blijven bestaan.

De lastigste vraag gaat over teams die volledig leunen op AI modellen. Als de senior in de kamer degene is die het model scherp houdt, wat gebeurt er dan in organisaties zonder die senior? Wat blijft er over wanneer vijf junioren afhankelijk zijn van een Copilot abonnement dat ineens evenveel kost als een extra collega? Dan beginnen de cijfers snel te schuiven.

Waarom senior developers nodig blijven

Niets hiervan maakt me pessimistisch over de technologie. Ik automatiseer inmiddels een groot deel van mijn dagelijks werk met deze tools. Schrijven, samenvatten, plannen en informatie ordenen die anders een hele avond kost.

Mijn voorzichtigheid zit ergens anders. Ik geef AI een grote rol in mijn leven, maar ik laat mijn leven geen grote rol spelen in het trainen van het volgende model. En ik laat AI niet ongemerkt de delen van mens zijn vervangen die menselijk moeten blijven.

Een boek lezen blijft een boek lezen. Een gesprek met een vriend blijft een gesprek met een vriend. Juist doordat ik de tools bewust níét overal inzet, blijven ze krachtig.

Symbiose. Dat vat het voor mij het beste samen.

Ik denk niet dat deze technologie het vak uitholt. Maar ik denk ook niet dat het een hype is die vanzelf verdwijnt. Het is een tool die expertise beloont en gebrek aan nieuwsgierigheid afstraft.

Engineers die leren hoe ze AI goed aansturen, gaan sneller en beter leveren dan mensen die het negeren of zich er volledig aan overgeven. Vooral die laatste groep baart me zorgen. Want als de prijs stijgt, het contextvenster kleiner wordt of het model een slechte dag heeft, moet er nog steeds iemand zijn die begrijpt wat de code hoort te doen.

Ik ben van plan het komende decennium gewoon mee te draaien. Prompts aanscherpen. Fouten opvangen. Blijven kijken wat er nog meer mogelijk wordt.

De engel en de duivel verdwijnen niet. De kunst is scherp genoeg blijven om te horen wie er op welk moment fluistert.

De AI powered senior developer blijven, ook wanneer de kamer grotendeels gevuld is met AI agents.

AI versnelt development. Maar er blijft altijd iemand nodig die begrijpt wat de code doet.

Dit artikel is gebaseerd op de Engelstalige versie op mijn persoonlijke blog.