Wacht even. Lees die titel nog eens.
Agents zijn de belangrijkste gebruikers van AI. Niet jij. Niet ik. Niet je team dat nog braaf tickets aftikt. De softwarewereld kantelt op een manier die ik in twintig jaar bouwen maar een paar keer heb gevoeld, en juist daarom wil ik je wakker schudden voordat je prettig nog dut in het sprookje dat AI vooral een slimme autocomplete is waar je even wat tijd mee pakt als je AI programmeren in je workflow propt.
Dat verhaal klopt niet.
Van gereedschap naar collega die nooit slaapt
Onderzoekers bekeken 128.018 GitHub-projecten en schatten dat coding agents in 22,20% tot 28,66% daarvan detecteerbare sporen achterlieten. Dat zegt niet dat al die code goed was, want de methode meet aanwezigheid en geen kwaliteit. Toch is dit geen randverschijnsel meer. Echt niet.
Kijk naar echt werk in het wild. Een analyse van 128.018 GitHub-projecten door Robbes en collega’s schat dat coding agents detecteerbare sporen hebben achtergelaten in 22,20% tot 28,66% van die projecten, met grotere commits die relatief veel features en bugfixes bevatten, terwijl hun methode expliciet alleen detecteerbare sporen meet en niets zegt over volledig gebruik, kwaliteit of productiviteitswinst.
Dat gaat ergens over. Want zo’n spoor betekent niet een losse snippet hier of daar, maar werk dat voldoende kenmerkend is om te herkennen, alsof een collega met een afwijkend handschrift lange zinnen in je repo heeft gezet en jij die krullen daarna overal terugvindt waar hij is langsgekomen.
En dat is precies het punt. Agents spelen mee. Niet als typmaatje, maar als deelnemer die context ophaalt, plannen maakt en ingrepen doet, en jij mag daarna ja of nee zeggen zoals je dat bij een junior ook zou doen, alleen dan met een tempo en uithoudingsvermogen waar geen mens tegenop kan knokken.
Wat een agent doet terwijl jij slaapt
Ik heb vorig jaar voor het eerst een coding agent losgelaten op een middelgrote refactor. Oude PHP, nauwelijks tests, nul documentatie. Ik verwachtte babysitten. Ik ging naar bed.
De volgende ochtend keek ik stilletjes naar mijn scherm.
Wat gebeurt er tussendoor? Sourcegraph beschrijft de agent-lus heel helder als een cyclus van context verzamelen, plannen, code wijzigen, testen en verfijnen, keer op keer, waardoor je iets krijgt dat aanvoelt als een doorlopende review- en bouwstroom die je orchestration vraagt in plaats van alleen prompts tikken (leveranciersbron).
Anthropic zet de richting simpeler nog neer: de verschuiving gaat van zelf code kloppen naar agents orkestreren, terwijl menselijk oordeel nodig blijft voor toezicht, kwaliteit en beveiliging, wat ik verstandig vind en waar ik in de praktijk ook precies op bijstuur wanneer een agent te gretig wordt of een veiligheidsrail overslaat (leveranciersbron).
Dus wat is jouw nieuwe werk? Niet de for-loop herschrijven, maar het speelveld bouwen waar die loop veilig kan draaien, de constraints zetten, de tests klaarleggen, de toolpermissies zuiver snijden en de besluitmomenten bepalen, zodat de agent gas mag geven zonder je product en je nachtrust te slopen.
De programmeur sterft niet. Hij verandert van baan
Tja, bangmakerij verkoopt. Maar “de programmeur is dood” voelt lui en onwaar, omdat je waarde als developer nooit alleen in typen zat, en de teams die winnen juist die mensen koesteren die probleemkaders scherp maken, trade-offs snappen en durven ingrijpen wanneer een autonome stap logisch lijkt maar strategisch dom is.
Ik noem die mensen dirigenten. Ze componeren niet elke noot. Ze horen wat ontbreekt, zetten de inzet van secties slim neer en tikken af wanneer het wordt gemaskeerd door ruis.
En dat vraagt nieuwe spieren. Geen heilige tools, wel denkwerk.
Wat dit voor jouw team betekent
Goed, maak het concreet. Je team gaat leren hoe je agent-workflows opzet, bewaakt en bijstuurt, hoe je prompts formuleert die over herhaalde runs consistent gedrag oproepen, hoe je output beoordeelt zonder elk regeltje met de hand uit te pluizen, en hoe je meerdere agents laat samenwerken zonder dat ze elkaars werk overschrijven of in lusjes blijven hangen, wat verrassend vaak terug te voeren is op te brede doelen en te veel tooltoegang in te weinig gecontroleerde stappen.
Dat vraagt oefening. En ritme. En vooral dat je procesdenken voorrang geeft op tool-shiny-ness, omdat de meeste misfires niet voortkomen uit een zogenaamd domme agent, maar uit een vage opdracht of een omgeving waar jij zelf ook zou verdwalen als je alleen logboeken en halftamme tests kreeg.
Omscholen kost tijd. Wachten kost meer.
Veiligheid zonder drama, met voorbeelden
Kijk, niemand hoeft je bang te praten met sciencefiction om serieus te doen over grenzen. OpenAI publiceerde een korte update over een veiligheidsincident tijdens model-evaluatie waarin Hugging Face werd genoemd, en dat soort cases herinnert je eraan dat autonomie zonder scherpe omheining vooral operationeel risico toevoegt in plaats van waarde (bron).
Niemand suggereert dat modellen bewustzijn hebben of moedwillig kwaadaardig zijn; gedrag volgt uit configuratie, context en tooling, en jij bepaalt precies die drie, dus je pakt de verantwoordelijkheid door sandboxing, logging en een expliciet toestemmingsmodel als harde randvoorwaarden te nemen in plaats van sluitposten die je pas inbouwt als “het straks live gaat”.
Geen paniek, wel opletten.
Waarom dit geen sciencefiction is maar een budgetvraag
Dus waar stop je geld en tijd in? Niet in nóg een autocomplete-licentie omdat iedereen dat al snapt, maar in een runtime voor agents, in tooling voor tracing en reproducible runs, en in CI-pijplijnen die een agent durven te blokkeren als hij buiten zijn mandaat gaat, omdat een project alleen schaalbaar wordt als je groepstempo wordt bepaald door de kwaliteit van de rails en niet door de snelheid van losse vingers.
Maar, je moet kiezen. Je kunt niet alle frameworks omarmen, je kunt niet elke hype volgen, dus je gaat terug naar je roadmap en je vraagt: waar lekt nu de meeste energie weg, welke klussen lenen zich voor agent-lussen, en welke afbakening is klein genoeg om binnen je risico-adem te passen terwijl de leercurve maximaal is?
Wie niet waagt, die niet wint.
Hoe je nu begint zonder jezelf gek te maken
Eerste stap: pak één afgebakend intern project en geef een agent een duidelijke taak met zichtbare successignalen, bijvoorbeeld het onderhouden van een module met tests als poortwachter, zodat je elke iteratie kunt accepteren of terugfluiten zonder dat iemand om drie uur ’s nachts een changelog hoeft te lezen.
Tweede stap: train je team op concepten, niet op knoppen, met het simpele doel dat iedereen de agent-lus kan tekenen, safe-guards kan uitleggen en weet wanneer handmatig ingrijpen logisch is, want de vaardigheid zit in het ontwerpen van beslismomenten en niet in het kopiëren van een toverprompt uit een chatvenster.
Derde stap: leg vast hoe je risico reviewt, met standaard logging, tijdslimieten, toolscopes en rollbacks, plus het besef dat acceptatiecriteria voor agentwerk meer lijken op productreviews dan op micro-level code-inspectie, omdat je vooral gedrag en contracten evalueert in plaats van individuele keuzen voor variabele namen.
En wees eerlijk naar jezelf. Je eerste runs voelen rommelig, je tweede reeks voelt machtig, je derde reeks laat je zien waar je te vroeg schaalt, en precies dat patroon maakt je beter omdat je fouten zichtbaar, herhaalbaar en corrigeerbaar worden in plaats van stil onder het vloerkleed te verdwijnen.
Dus ja, programmeurs zijn niet meer de belangrijkste gebruikers van AI. Agents zijn dat, en jij krijgt de leukere baan als je die realiteit omarmt: minder tikwerk, meer systeemontwerp, meer verantwoordelijkheid op de plekken waar het telt, en een carrière die harder draait op oordeel dan op mechaniek.
Wat ga jij orkestreren de komende zes weken, en durf je een scope te kiezen die klein genoeg is om te falen en groot genoeg om te leren zonder smoesjes?