AI-code controleren: zo houd je grip op wat een codeer-agent maakt
In dit artikel
AI code review betekent dat elke wijziging van een codeer-agent wordt nagekeken voordat hij live gaat. Een reviewer controleert het verschil met de vorige versie, het gedrag in de browser, toegankelijkheid, beveiliging en snelheid, en laat de computer testen wat er te testen valt. Een tweede AI kan meekijken en vindt fouten die een mens mist, maar beslist niet. Iemand moet elke bevinding kunnen beoordelen, en dat vraagt ervaring. Zo werk ik zelf: de agent schrijft, ik beoordeel.
Wat is AI code review?
Code review is een vakterm voor het nakijken van een wijziging in de code, voordat die wordt geaccepteerd. Bij AI code review gaat het om twee dingen tegelijk. Er wordt code gecontroleerd die een AI heeft geschreven, en daarbij kan een AI als meekijker worden gebruikt. In de praktijk vallen die samen: een codeer-agent schrijft, eventueel kijkt een tweede AI mee, en een mens beslist.
Zo werk ik ook. Claude Code schrijft bij mij de code; ik geef de opdracht, lees het verschil, bekijk het resultaat in de browser en beslis of het live gaat. Mét AI, niet dóór AI. Hoe zo'n wijziging van verzoek tot livegang verloopt, lees je in website aanpassen met AI.
Het tegenovergestelde is vibe coding: bouwen met AI zonder de code te lezen. Voor een prototype kan dat, zoals ik uitleg in vibe coding. Voor een website waar klanten op vertrouwen niet. In dit artikel laat ik zien wat een goede review inhoudt. Grip houden betekent voor jou als opdrachtgever niet dat je elke regel zelf leest. Het betekent dat je weet wat er gecontroleerd moet worden, zodat je kunt zien of het gebeurt.
Waarom AI-code beoordelen vakwerk is
Een codeer-agent schrijft code die er overtuigend uitziet. Hij is netjes opgemaakt, heeft logische namen en werkt vaak bij de eerste keer klikken. Juist daardoor vallen fouten minder op. Een formulier verstuurt, maar controleert niet wat erin staat. Een knop werkt met de muis, maar niet met het toetsenbord. Een pagina ziet er goed uit, maar laadt een pakket van honderden kilobytes voor een uitklapmenu.
Zulke fouten zie je alleen als je weet hoe het hoort. Een reviewer heeft tegelijk kennis nodig van HTML en toegankelijkheid, van beveiliging, van wat de host wel en niet ondersteunt, en van het project zelf: welke afspraken er zijn, waar de gegevens vandaan komen en wat de klant bedoelde. Een verschil van twintig regels lezen kost een minuut. Zien dat regel veertien een controle uitschakelt, vraagt ervaring die je niet in een middag opbouwt.
Er komt nog iets bij. Een AI maakt andere fouten dan een mens. Hij verzint soms een instelling die niet bestaat, past meer aan dan gevraagd of past een test aan tot die slaagt. Wie dat patroon niet kent, keurt het goed. Een review zonder die kennis is een ritueel: er wordt gekeken, maar niet gezien.
De review begint bij een kleine opdracht
De belangrijkste stap in AI code review wordt gezet voordat er code is. Een wijziging van twintig regels kun je lezen. Een wijziging van tweeduizend regels scan je, en dan mis je dingen. Een goede reviewer begint daarom bij de opdracht: één taak per keer, en eerst laten zien wat de agent wil wijzigen.
Een voorbeeld van een te ruime opdracht: "Verbeter de homepage."
Beter: "Vervang op de homepage de knoptekst 'Meer info' door 'Bekijk de behandelingen'. Verander verder niets. Laat eerst zien welke bestanden je aanpast."
Dat 'verander verder niets' lijkt vanzelfsprekend. Wie nooit heeft gezien hoe een agent ongevraagd een functie opruimt of een opmaakregel verandert, schrijft het er niet bij. Een goede opdracht schrijven is dus al een deel van het vak.
Daarna krijgt elke goedgekeurde wijziging een eigen vastlegging in versiebeheer, met een korte uitleg die ook een niet-programmeur begrijpt. Gaat er later iets mis, dan draai ik die ene wijziging terug zonder de rest kwijt te raken. Wat Git daarbij precies bijhoudt, staat in Git en versiebeheer.
Vijf dingen die een reviewer bij elke wijziging bekijkt
Een goede review kijkt naar vijf dingen. Niet elke wijziging vraagt alle vijf even grondig, maar ze komen wel allemaal langs. Bij elk ervan zie je wat het vraagt aan kennis.
Het verschil
Het verschil, in vaktaal de diff, laat per bestand zien welke regels erbij kwamen en welke verdwenen. De eerste vraag is simpel: klopt het verschil met de opdracht, en niets meer? Let op bestanden die niet verwacht waren, regels die zijn weggehaald, gewijzigde instellingen en nieuwe pakketten. Een agent die een knoptekst moest aanpassen, heeft niets te zoeken in je formulierafhandeling. Om dat te zien, moet je wel weten welk bestand wat doet.
Het gedrag
Code die er goed uitziet, kan zich anders gedragen. Een reviewer bekijkt de wijziging daarom in de browser, lokaal of in een voorbeeldversie, op mobiel en op desktop. En hij probeert wat een gewone bezoeker zou doen: een leeg veld versturen, een lange naam invullen, terugklikken. Hoe een voorbeeldversie daarbij wordt gebruikt, lees je in staging-omgeving.
Toegankelijkheid
Gegenereerde code ziet er vaak strak uit en werkt toch slecht met een toetsenbord of schermlezer. Bekende fouten zijn knoppen die geen echte knop zijn, formuliervelden zonder label, te weinig contrast en een weggehaalde focusrand, het kadertje dat laat zien waar je bent als je met Tab door de pagina gaat. Een schermlezer leest een nepknop niet als knop voor. Dat zie je niet op het scherm; dat moet je weten. De eisen waaraan je zulke code toetst, vind je in de WCAG 2.2-eisen in gewone taal.
Beveiliging
Staan er wachtwoorden of sleutels in de code, wordt invoer van buiten gecontroleerd, en geeft de wijziging meer rechten of toegang dan nodig? Dat zijn de vragen bij elke wijziging. De tien controles voordat een AI-gebouwde app live gaat, staan in vibe coding security. Die herhaal ik hier niet.
Prestaties
Een agent lost een klein probleem soms op met een groot pakket, een extra lettertype of een script van een andere partij. Elk daarvan maakt je pagina zwaarder. Een reviewer kijkt of de pagina na de wijziging nog even snel laadt, zeker op een telefoon met een matige verbinding.
Testen en een tweede AI: hulp, geen vervanging
Automatische tests
Wat een computer kan controleren, hoeft niet met de hand. Een paar controles kunnen bij elke wijziging automatisch draaien:
- Het bouwen zelf. Bij een statische site moet de site zonder fouten gebouwd kunnen worden. Mislukt dat, dan gaat er niets live.
- Links en koppen. Een controle op kapotte links, ontbrekende titels en meer dan één hoofdkop per pagina.
- Toegankelijkheid. Een automatische scan vindt een deel van de problemen, zoals ontbrekende labels en te weinig contrast. Niet alles: met het toetsenbord door de pagina gaan blijft mensenwerk.
- Logica. Rekent een rekentool of configurator iets uit, dan horen er tests bij met invoer waarvan de uitkomst bekend is.
Een agent kan die tests ook schrijven. Ze moeten dan wel gelezen worden. Een bekend patroon is een agent die een test aanpast of overslaat tot alles groen is. Een groene test bewijst bovendien alleen dat werkt wat iemand heeft bedacht te testen. Hoe een agent zelf door formulieren kan klikken, lees je in website testen met AI.
Een tweede AI als meekijker
De AI die de code schreef, kijkt zijn eigen werk na met dezelfde aannames. Een tweede AI, in een nieuwe sessie en met alleen het verschil en de opdracht, ziet vaak meer. Deze mogelijkheden bestaan (stand november 2026):
| Tool | Wat het doet | Voor wie |
|---|---|---|
| /code-review in Claude Code | Kijkt de wijzigingen op je werkversie na op fouten en meldt wat het vindt | Iedereen met Claude Code, op elk abonnement |
| /security-review in Claude Code | Zoekt in je wijzigingen naar beveiligingsproblemen | Iedereen met Claude Code |
| Code Review van Claude | Bekijkt elke pull request op GitHub en zet opmerkingen bij de regels | Team- en Enterprise-abonnementen |
| Copilot code review | Reviewt pull requests op GitHub en stelt verbeteringen voor | Betaalde Copilot-abonnementen, niet in de gratis versie |
Twee dingen vallen op in de documentatie. De Code Review van Claude keurt een wijziging nooit goed of af; de beslissing blijft bij het team. En zowel Anthropic als GitHub schrijven dat zo'n review fouten kan missen. Volgens de documentatie van GitHub tellen de reviews van Copilot standaard niet mee als goedkeuring, en hoort er een menselijke review bij.
Zo'n reviewer levert bevindingen, geen oordeel. Hij meldt ook dingen die geen probleem zijn, en mist soms wat er wel mis is. Iemand moet elke bevinding beoordelen: klopt het, is het relevant, en wat is de juiste oplossing? De volgorde is daarbij belangrijk: eerst het rapport, dan het oordeel, dan pas herstel. Een reviewer die meteen gaat repareren, maakt een nieuwe wijziging die ook weer gecontroleerd moet worden. Een AI-reviewer is daarmee een hulpmiddel voor wie al kan reviewen, geen vervanging voor wie dat niet kan.
Wat vindt wie: test, AI-reviewer en mens
Met tests en een tweede AI in het proces is het verleidelijk om de controle aan hen over te laten. Elk vangt een ander soort fout. Het overzicht hieronder is mijn inschatting, geen meting of onderzoek: woorden als 'vaak' en 'soms' zijn globaal bedoeld. Het laat wel zien waarom ze naast elkaar nodig zijn:
| Soort fout (inschatting) | Automatische test | AI-reviewer | Mens |
|---|---|---|---|
| Kapotte link of ontbrekende titel | Vindt het | Soms | Als hij ernaar zoekt |
| Fout in een berekening | Als er een test voor is | Vaak | Met een testgeval |
| Sleutel of wachtwoord in de code | Met een scanner | Vaak | Bij het lezen van het verschil |
| Meer gewijzigd dan gevraagd | Nee | Soms | Ja, want hij kent de opdracht |
| Toegankelijkheid | Deels | Deels | Met toetsenbord en schermlezer |
| Past het bij huisstijl en toon? | Nee | Deels | Ja |
| Is dit wat de klant bedoelde? | Nee | Nee | Ja |
De onderste regel is de belangrijkste. Of een wijziging doet wat iemand bedoelde, weet alleen wie het verzoek kent. Daarom beslist een mens of een wijziging live gaat.
Rode vlaggen in AI-code
Sommige fouten komen bij codeer-agents steeds terug. Een ervaren reviewer kijkt bij deze signalen extra goed:
- Meer gewijzigd dan gevraagd. Een opgeruimde functie of een andere opmaak op een plek waar niemand om vroeg.
- Tests weggehaald of aangepast. Een test die eerst faalde en nu ineens slaagt, zonder dat de code is verbeterd.
- Fouten weggemoffeld. Een foutmelding die wordt opgevangen en genegeerd, of een controle die is uitgezet.
- Een nieuw pakket voor iets kleins. Elk pakket is code van een ander die moet worden bijgehouden. Wat dat bijhouden aan werk vraagt, staat in updates in een maatwerk website.
- Vaste waarden op de verkeerde plek. Een telefoonnummer dat direct in een pagina is getypt, terwijl het uit één databestand hoort te komen.
- Verzonnen functies of instellingen. Code die een functie aanroept die niet bestaat, of een instelling die de host niet kent. Hoe dat ontstaat, lees je in AI-hallucinaties.
- Eigen kleuren en maten. Opmaak die de huisstijl negeert en eigen waarden verzint.
Komt een rode vlag vaker terug, dan hoort de regel in het bestand met bouwafspraken dat de agent bij elke sessie leest; zo'n bestand heeft elk project van mij. Zo wordt de kans kleiner dat de agent dezelfde fout opnieuw maakt.
Wat dit betekent als je met AI laat bouwen
Je hoeft AI-code niet zelf te beoordelen. Je wilt wel weten of iemand het doet. Deze vragen kun je elke bouwer stellen die met AI werkt:
| Vraag aan je bouwer | Waarom het telt |
|---|---|
| Controleert iemand elke wijziging voordat hij live gaat? | Een agent die zonder controle publiceert, is vibe coding op je live site |
| Wordt elke wijziging apart vastgelegd, met uitleg die jij ook kunt lezen? | Dan is elke stap terug te draaien zonder de rest kwijt te raken |
| Zijn er vaste bouwafspraken voor de agent? | Zonder afspraken verzint de agent bij elke sessie opnieuw zijn eigen stijl en regels |
| Krijg je een nieuwe pagina of functie eerst te zien voordat hij live staat? | Of iets doet wat jij bedoelde, kun alleen jij beoordelen |
| Ben jij eigenaar van je domein, code en hosting, of heb je er minstens volledige toegang toe? | Dan kun je altijd overstappen naar een andere bouwer |
Voor mijn eigen werk is het antwoord op alle vijf ja. Een kleine correctie zet ik live zodra ik hem heb nagekeken, en jij hoort dat het gebeurd is. Een nieuwe pagina of functie bekijk je eerst als voorbeeldversie, en pas als jij akkoord geeft, gaat die online.
Conclusie: de AI schrijft en kijkt mee, een ervaren mens beslist
Goede AI code review begint bij kleine opdrachten en een apart vastgelegde wijziging. Daarna worden het verschil, het gedrag in de browser, toegankelijkheid, beveiliging en snelheid gecontroleerd, en test de computer wat er automatisch te testen valt. Een tweede AI is een nuttig extra paar ogen, zolang iemand zijn bevindingen kan beoordelen. Wat terugkomt, gaat in de bouwafspraken, zodat de agent het de volgende keer goed doet.
Voor jou als ondernemer is de les eenvoudig: AI maakt het bouwen sneller, niet het beoordelen. Dat blijft vakwerk, en het vraagt kennis die je niet even naast je eigen bedrijf opbouwt. Die controle doe ik bij elke wijziging die ik voor je doorvoer. Jij geeft door wat er moet veranderen en ziet het resultaat.
Hoe zo'n bestand met bouwafspraken is opgebouwd, met een uitgewerkt voorbeeld, staat in bouwafspraken voor je codeer-agent. Benieuwd hoe ik werk? Download het pitchdeck.
Veelgestelde vragen
Kan AI code reviewen?
Ja, en vaak verrassend goed. Een AI-reviewer leest een wijziging in seconden en wijst op logische fouten, invoer die niet wordt gecontroleerd of een vergeten randgeval. Maar de makers zijn er zelf duidelijk over: zo'n review kan fouten en beveiligingsproblemen missen, en een review zonder bevindingen betekent niet dat de code veilig is. Een AI-reviewer is daarom een extra paar ogen, in handen van iemand die elke bevinding kan beoordelen en beslist of de wijziging live gaat.
Welke AI code review tools zijn er?
De bekendste zitten in de codeer-agents zelf. Claude Code heeft de opdracht /code-review, die de wijzigingen op je werkversie nakijkt, en /security-review voor beveiliging. Voor teams is er een dienst die elke pull request op GitHub automatisch bekijkt. GitHub Copilot kan pull requests reviewen in de betaalde abonnementen. Functies en abonnementen veranderen vaak (stand november 2026). Al deze tools leveren bevindingen, geen oordeel. Ze zijn het nuttigst voor wie elke bevinding zelf kan beoordelen.
Moet ik AI-code regel voor regel lezen?
Als opdrachtgever niet: dat hoort bij je bouwer. Voor wie reviewt, hangt het af van de wijziging. Bij een kleine wijziging is het verschil met de vorige versie vaak maar een paar regels, en die worden volledig gelezen. Bij een grote wijziging lukt dat niet goed meer, en daarom wordt werk in kleine stappen opgeknipt. Het zorgvuldigst wordt gelezen wat met gegevens, formulieren, inloggen of betalingen te maken heeft. Bij een tekstwijziging is een blik op het verschil en een controle in de browser meestal genoeg.
Is code van een AI slechter dan code van een mens?
Niet per se, maar de fouten zijn anders. Een codeer-agent schrijft snel code die er overtuigend uitziet, ook als hij op een aanname of een verzonnen instelling berust. Hij past soms meer aan dan gevraagd, voegt een pakket toe voor iets kleins of past een test aan tot die slaagt. Een mens maakt ook fouten, maar twijfelt vaker hardop. Daarom hoort bij code van een AI dezelfde controle als bij code van een collega, met extra aandacht voor die typische valkuilen.
Kan ik AI-code controleren zonder programmeerkennis?
Een deel wel. Je kunt in de browser kijken of een wijziging doet wat je vroeg, op je telefoon en op een computer, en een formulier testen. Het verschil in de code beoordelen lukt zonder kennis niet. Daarvoor moet je weten wat een veilige formulierafhandeling is, wat toegankelijke HTML is en welke pakketten een risico vormen. Een AI-reviewer lost dat niet op, want ook zijn bevindingen moet je kunnen beoordelen. Het eerlijke antwoord: dat deel laat je over aan iemand die het dagelijks doet.
Benieuwd hoe ik dit in de praktijk aanpak?
Het pitchdeck laat de hele werkwijze zien.
Geschreven door Dennis Boekhout
Marketing freelancer uit 's-Hertogenbosch. Volg op LinkedIn (opent in een nieuw tabblad)
