Thought leaders
Waarom testen vanaf het begin onderdeel moet zijn van de AI-assemblagelijn

Belangrijkste puntenAI versnelt het coderen maar legt zwakke downstream-tests bloot en verlaagt de…
Meer weergeven
- AI versnelt het coderen maar legt zwakke downstream-tests bloot en verlaagt de stabiliteit van de oplevering.
- Agenten die hun eigen tests beoordelen kunnen vals spelen door falende tests te bewerken in plaats van de code te repareren.
- Testen moet een eigen station buiten CI zijn, zodat elke wijziging hetzelfde oordeel ondergaat.
Ik bouw al meer dan twintig jaar testtools en het grootste deel van die tijd leken mijn gesprekken met engineeringteams sterk op elkaar. Testers voelden zich tweederangsburgers in de softwarelevenscyclus. Testen gebeurde laat, vaak gepropt in de tijd die vóór een release nog over was, en toegevoegd aan een CI-pijplijn die voor iets heel anders was gebouwd. AI heeft de manier waarop we code schrijven inmiddels ingrijpend veranderd – en dat heeft zeker ook gevolgen voor het testen, zowel positieve als negatieve. In veel opzichten heeft AI de uitdaging zichtbaarder gemaakt.
De afgelopen maanden heb ik een handvol conferenties over testen en cloud-native technologie bezocht (LeadDev, CloudX, StarWest). Bijna elk team waarmee ik sprak, werkte aan een variant van hetzelfde project: een AI-gestuurde levenscyclus voor softwarelevering, waarin agents werk oppakken vanaf een specificatie en dat omzetten in iets dat in productie draait, met onderweg de juiste mate van menselijke betrokkenheid. Ik zie het voor me als een assemblagelijn. Agents schrijven de code, andere agents beoordelen die en pijplijnen bouwen en implementeren de software. Mensen houden een oogje in het zeil. Waar ik veel minder over hoor, is de plek die testen op die lijn inneemt.
Niemand heeft dit al helemaal uitgewerkt
Op dit moment is het een beetje het Wilde Westen. Om de paar weken verschijnen er nieuwe mogelijkheden voor agents, de grote AI-labs brengen steeds nieuwe modellen uit en zowel teams als leveranciers proberen van alles uit om te zien wat aanslaat.
Sommige gegevens wijzen erop dat de problemen nu al zichtbaar worden. Uit het meest recente DORA-rapport over AI-ondersteunde softwareontwikkeling van Google, waarvoor bijna 5.000 technologieprofessionals werden ondervraagd, blijkt dat AI-adoptie samenhangt met een hogere doorvoercapaciteit bij softwarelevering, wat goed nieuws is. Tegelijkertijd blijft AI ook samenhangen met een lagere stabiliteit van softwareleveringen. Volgens de onderzoekers versnelt AI de ontwikkeling en legt het zwakke plekken verderop in het proces bloot. Ze wijzen op grondige geautomatiseerde tests als een van de waarborgen die voorkomen dat meer veranderingen tot meer instabiliteit leiden.
Dat verbaast me niet. Als je veel meer code door een proces voert dat voor veel minder code is ontworpen, loopt het ergens vertraging op of gaat er ergens iets mis.
Ontwikkelaars werken sneller, maar de meeste releases niet
Wanneer mensen zich voorstellen wat er mis kan gaan met door AI gegenereerde code, denken ze vaak aan een agent die iets rampzaligs in productie zet. Ik weet zeker dat dat gebeurt – en als het gebeurt, zijn de gevolgen niet fraai: bugs, ontevreden klanten, misschien zelfs een beveiligingsincident. Maar eerlijk gezegd kom ik dat meestal niet tegen.
De Stack Overflow-ontwikkelaarsenquête van 2026 laat zien waarvoor AI tegenwoordig vooral wordt gebruikt. Ontwikkelaars zetten AI vooral in om code te genereren op gebieden die ze al kennen (67%) en om fouten op te sporen (61%); slechts 20% gebruikt AI om productiesystemen te implementeren, te beheren of problemen ermee op te lossen. Tot nu toe heeft AI vooral het schrijven van code versneld. Het controleren van die code en het in productie nemen ervan verlopen grotendeels nog zoals voorheen.
Dit komt ook overeen met wat ik zelf zie: teams produceren veel meer code, maar brengen niet sneller releases uit. Een individuele ontwikkelaar of team kan het gevoel hebben twee keer zoveel functies te bouwen, maar die functies lopen verderop in het proces vast: ze wachten op beoordeling, op tests of op een omgeving waarin ze getest kunnen worden. Al die extra code verstopt de pijplijn en vertraagt in veel gevallen zelfs de algehele softwarelevering door teams.
Managers stellen vragen over waarborgen
Hoewel de bezorgdheid over door AI veroorzaakte knelpunten bij de oplevering heel concreet is, is dat niet het enige waar teams ons naar vragen. Ontwikkelaars willen vooral weten hoe ze sneller betere code kunnen schrijven. De vragen over waarborgen komen van engineeringmanagers en van de mensen die deze agentgestuurde workflows opzetten. Hoe zorgen we ervoor dat de agents niet ontsporen? Hoe weten we dat ze geen regressies veroorzaken of ongemerkt werk overslaan dat ze hadden moeten doen? Hoe zorgen we ervoor dat de tests die ze schrijven daadwerkelijk (en naar waarheid!) valideren wat ze moeten valideren?
Volgens mij komt dat doordat ze naar verschillende dingen kijken. Een ontwikkelaar bekijkt één pull request tegelijk. Een engineeringmanager is verantwoordelijk voor alles wat door veel agents en mensen samen wordt uitgebracht, en moet uitleg geven als er in productie iets misgaat.
Ze hebben bovendien reden om voorzichtig te zijn. Onderzoekers ontwikkelden een benchmark met de naam ImpossibleBench, gebaseerd op programmeertaken waarbij de unittests in tegenspraak zijn met de specificatie. De enige manier om te slagen, is dus valsspelen. Toonaangevende modellen deden dat vaak ook, bijvoorbeeld door de falende tests aan te passen of te verwijderen in plaats van de code te repareren (!!). Uit een afzonderlijk onderzoek naar pull requests die door agents zijn ingediend bleek dat agents hun eigen wijzigingen niet altijd goed testen. Het onderzoek verwijst ook naar eerder werk waaruit blijkt dat bijna een derde van de samengevoegde pull requests van agents achteraf aanpassingen of refactoring nodig had.
Mijn conclusie is dat waarborgen niet alleen binnen de eigen omgeving van een agent kunnen worden ingebouwd, en evenmin pas nadat code is uitgebracht. Als de agent die de code heeft geschreven ook bepaalt of die de test heeft doorstaan, zegt de uitkomst weinig. Dat betekent niet dat agents geen tests moeten schrijven. Het betekent dat het oordeel van een plek moet komen waar de agent niets aan kan veranderen. Testen moet een eigen station op de lijn zijn, waar elke wijziging doorheen gaat, of die nu door een mens of door een agent is geschreven.
Wat dat station nodig heeft
Het antwoord is geen compleet nieuwe vorm van testen. Het meeste van wat nodig is, is precies waar goede QA-teams altijd al om hebben gevraagd. Alleen is het nu belangrijker.
Tests moeten worden gecontroleerd op juistheid en overeenstemming met de vereisten, net als de code die ze testen. Tests moeten ook draaien in de omgeving waarin de software draait. Als een test slaagt in de sandbox van een agent, zegt dat weinig over staging of productie. Bovendien kan zo verborgen blijven welke afhankelijkheden zijn nagebootst – of hoe dat is gebeurd. Uit een recent onderzoek naar bijna 180.000 door agents gegenereerde testbestanden bleek dat agents meer randgevallen afdekten dan tests die door mensen waren geschreven, maar dat hun tests vaker tekenen van instabiliteit vertoonden. Dat kwam grotendeels doordat de agents te weinig wisten over de omgeving waarin de tests zouden draaien. Door tests al vroeg op echte infrastructuur uit te voeren, komen zulke problemen aan het licht.
Tests en de resultaten ervan moeten bewaard blijven. Als een agent een test schrijft, moet die bestaande tests en de resultaten ervan als context krijgen, zodat de agent kan leren van zowel de testdekking als mogelijke instabiliteit. Tests moeten net als andere code worden gecontroleerd en van versiebeheer worden voorzien, zodat ze bij de volgende wijziging opnieuw worden uitgevoerd in plaats van te verdwijnen zodra de sessie eindigt.
Een geslaagde test moet hetzelfde betekenen, ongeacht wie erom heeft gevraagd: een pipeline, een ontwikkelaar of een agent. Dat betekent dezelfde tests, uitgevoerd op dezelfde infrastructuur, met alle resultaten op één plek.
En mensen moeten hun beoordelingsvermogen blijven gebruiken. Ik laat agents graag het standaardwerk en de koppelingen voor hun rekening nemen. Bepalen wat het testen waard is en wat een mislukte test betekent, blijft mensenwerk – voorlopig althans…
Dit betekent ook dat testen niet alleen binnen CI/CD kan plaatsvinden (onthoud dan vooral dit punt uit het artikel!). CI-pipelines zijn ontworpen om code te bouwen en uit te leveren; ze zijn nooit bedoeld om op grote schaal geautomatiseerde tests uit te voeren. Naarmate we overstappen op een agentgestuurde SDLC en de hoeveelheid code blijft groeien, wordt CI nog minder geschikt voor het uitvoeren van tests. Testen moet een volwaardig onderdeel zijn van de manier waarop software wordt geleverd, in plaats van een stap aan het einde van een pipeline. Dat betekent dat je testen als een zelfstandig systeem moet orkestreren, voor elk hulpmiddel en elke omgeving die een team gebruikt, ongeacht wie het werk aanstuurt: een agent of een mens.
Waar te beginnen
De meeste teams hebben al tests die ze vertrouwen in Playwright, Cypress, k6, Postman of de tool waarop ze zich hebben vastgelegd. Dat is een prima startpunt. Een paar suggesties:
- Breng in kaart hoe een wijziging tegenwoordig van prompt tot productie komt en markeer elke plek waar een test wordt uitgevoerd. Is dat maar op één plek, vlak voor het einde, dan zou ik daar beginnen.
- Wees voorzichtig met agents die ongemerkt bestaande tests aanpassen. De onderzoekers van ImpossibleBench ontdekten dat agents minder fraudeerden wanneer hun toegang tot tests werd beperkt. Als een agent een test toch moet aanpassen, moet die wijziging worden ingediend als pull request en door iemand worden beoordeeld, net als andere code.
- Voer je tests zo vroeg mogelijk uit in testomgevingen (bij voorkeur echte), niet in sandboxes van agents. Dat kan zelfs met niet meer dan een kleine set smoke-tests op staging voor elke door een agent gegenereerde wijziging. Als je AI gebruikt om tests te schrijven, accepteer een test dan pas nadat die daar is uitgevoerd.
- Breng je testresultaten samen in één besturingslaag, bijvoorbeeld een rapportagetool, je APM-oplossing of een speciaal testplatform. Zorg ervoor dat zowel mensen als agents toegang hebben tot deze resultaten.
- Meet de oplevering, niet de activiteit. Het aantal pull requests zegt weinig. De opleveringsstatistieken van DORA, zoals de doorlooptijd van wijzigingen en het percentage mislukte wijzigingen, vertellen je veel meer over de vraag of AI helpt.
- Laat agents dezelfde testinfrastructuur gebruiken als je medewerkers, zodat hun werk aan dezelfde norm wordt getoetst.
Optimistisch, maar onder voorwaarden
Ik ben optimistisch over AI en denk dat het softwareteams veel capabeler en uiteindelijk productiever zal maken. Maar daarvoor moeten teams genoeg vertrouwen hebben in wat hun agents produceren om het uit te leveren. Ook hebben ze een integrale aanpak nodig voor testen binnen de agentgestuurde SDLC, want daar wordt dat vertrouwen opgebouwd of juist ondermijnd.
Welke plek heeft testen op dit moment in jouw streven naar een agentgestuurde SDLC?












