Naar de inhoud
maarten.
Close-up van een computerscherm met kleurrijke programmeercode, achtergrond wazig.
Alle stories

AI-code review voor productie

Maarten Soetens 12 min lezen

AI-gegenereerde code kan snel een werkende oplossing opleveren, maar werkende code is niet automatisch veilig, correct of onderhoudbaar. Lees hoe je de risico’s beoordeelt, welke controles je automatiseert en waar menselijke beoordeling noodzakelijk blijft.

Zo kijk je naar het gedrag van AI-code, niet alleen vorm

Als je een pull request of merge met AI-gegenereerde code beoordeelt, begin dan met: wat moet deze code precies doen? Mooie structuur, goede benamingen en een build zonder fouten zeggen weinig over functionaliteit. Leg de functie langs de eisen die gelden, kijk welke architectuurregels gelden voor dit project en vergelijk patronen met de bestaande codebase. Check direct: zijn alleen relevante bestanden aangepast, zijn er meegekomen wijzigingen die nergens over gaan, verwerkt de code alleen wat gevraagd is of haalt hij er ergens meer bij?

Loop de datastroom even na. Waar komt de input vandaan? Welke verwerking volgt er, waar komt de uitkomst terecht? Een nette functie kan lokaal prima ogen, maar op een andere plek in je applicatie foutbeheer, validatie of statusvolle logica omzeilen (meestal onbedoeld). Kijk uit voor impliciete beslissingen, bijvoorbeeld standaardwaardes, tijdzonedetails, manier van afronden of gedrag bij lege data. Dergelijke finesses maken vaak het verschil tussen een demo die werkt en een productieomgeving die 's nachts ineens uitvalt.

Zijn de veranderingen zo compact en gericht mogelijk? Reviews worden snel onoverzichtelijk door samengevoegde refactors, dependency-updates en formattering in één pull. Knip die los als dat kan. Met automatische tools filter je alleen ruis weg, ze nemen je niet de taak uit handen om te bekijken of het systeem zich met deze code aan de opdracht houdt.

Bij een WordPress-plug-in is die aansluiting op de bestaande code extra belangrijk.

Let op kwetsbaarheden in door AI gegenereerde code

Beoordeel beveiliging niet alleen per functie maar kijk naar het systeem eromheen. Begin met de grenzen: welke invoer komt van buiten, wie mag die invoer vertrouwen? Komt er iets van een gebruiker, een externe API, een bestand, of communiceer je intern? Zorg dat validatie gebeurt op de plek waar de grens zit. Validatie alleen aan de voorkant in React is niet genoeg, en met alleen een typecontrole ben je bij SQL-injectie niet veilig.

Let scherp op authenticatie (is deze gebruiker wie hij zegt te zijn), autorisatie (mag deze gebruiker dit doen) en gevoelige informatie zoals secrets. AI-code controleert soms wél of een gebruiker bestaat, maar vergeet of die dezelfde rechten heeft voor objecten die worden opgevraagd. Kijk bij gevoelige acties naar controle op recht per resource. Scan verder de code, logs en foutafhandeling op lekke geheimen: tokens, wachtwoorden, sleutels. Foutmeldingen die te veel prijsgeven zijn een bekend risico.

Tools als statische analyse, dependency-scans en secret-scans signaleren bekende vulns en gevoelige data. Ze missen vaak bedrijfseigen logica, soms slaan ze vals alarm. Probeer daarom concrete misbruikscenario’s: rare input, onlogische combinaties, ontbrekende rechten, verlopen sessies. Hoe diep je moet testen hangt af van waar de code draait. Code die gebruikers kan aanpassen heeft een ander securityniveau nodig dan een stuk dat alleen publieke info ophaalt.

Ook bij front-endontwikkeling hoort validatie op de server, niet alleen in de browser. Denk daarnaast aan prompt injection wanneer AI-code met onbetrouwbare invoer werkt.

Zo herken je aannames en gaten in AI-gegenereerde code

Een AI vult ontbrekende informatie graag aan met plausibele keuzes, zodat de code er logisch uitziet, maar pas op voor aannames die niet blijken te kloppen met jouw systeem. Check goed: bestaat elk gebruikt veld wel, geeft de API echt een waarde in het verwachte formaat, zijn foutmeldingen niet anders dan wat de code ervan maakt? Baseer je liever op daadwerkelijke documentatie of de bestaande implementatie dan op een toelichting die alleen overtuigend klinkt.

Denk verder na over randgevallen. Wat gebeurt er bij dubbele requests, als meerdere gebruikers tegelijk updaten, als een verzameling leeg is, of bij falende transacties? Eén record loopt vaak goed, maar grotere aantallen of ‘half gelukte’ updates laten snel onbedoeld gedrag zien. Pas op met datums: lokale tijd, UTC, centen en euro’s, grenzen die exclusief of inclusief zijn, één ongelijk moment en je accountants klagen direct.

Leg cruciale aannames expliciet vast in tests of door checks in de code. Bijvoorbeeld bij een API die altijd een ID nazendt: wat gebeurt er als dat veld ineens verdwijnt of niet uniek meer is? Vraag bij twijfel niet alleen: compileert het?, maar: wat laat daadwerkelijk zien dat deze aanname klopt? Een kleine test of een inspectie van de API-respons dwingt je eerder om gaten te vinden dan een trust-me uitleg van een bot.

Nieuwe dependencies? Deze punten altijd controleren

Code die door een model wordt voorgesteld, suggereert soms een extra package, soms zelfs eentje met een bijna-gelijke naam die eigenlijk nergens hoort (vooral als het model weinig context had). Check daarom vóór je iets installeert de exacte package-naam, waar het vandaan komt, het aantal recente updates en welke licentie je aantreft. Bekijk ook de keten aan indirecte dependencies; een klein pakketje kan tientallen extra packages meekrijgen. Elke dependency maakt je code groter en geeft een aanvaller (en jezelf bij onderhoud) meer te doen, vaak zelfs als je maar één functie gebruikt.

Kijk eerst of je niet al een oplossing hebt. Draagt het project al een eigen HTTP-client, parser of crypto-lib? Dan is extra binnenhalen zelden nodig, tenzij er echt een ontbrekend onderdeel is. Bouw zeker géén eigen cryptografie in op suggestie uit een voorbeeldfragment: kies altijd voor bestaande, onderhouden libs die aansluiten op je securitybeleid. Gebruik lockfiles en versiebevriezing zodat builds voorspelbaar zijn en niet stiekem stukgaan.

Automatische scanners zijn handig voor bekende kwetsbaarheden en verouderen, maar zeggen weinig over of je afhankelijkheid zinvol of te vertrouwen is. Blijf bij installeren alert op scripts die onduidelijk zijn, onduidelijk eigenaarschap, libraries waar weinig mee gebeurt. Of een package echt wordt aangeroepen in je flows bepaalt securityrisico’s, maar niet of het acceptabel is om het in huis te halen. Schrijf op waarom je een dependency kiest en wie updates opvolgt.

Hoe je tests inzet om AI-code écht te controleren

Meegesuggereerde tests bij de code hebben vaak precies dezelfde aannames als de code zelf. Daardoor geven ze weinig vertrouwen als je alleen het voorbeeld controleert. Stel je tests daarom op rond wat het systeem hoort te doen: aan de hand van vastgelegde regels, vastgestelde contracten en bekende problemen. Neem normale invoer én foute data, grenzen én uitzonderingen. Alleen bevestigen dat de happy path werkt zegt weinig over echte werking.

Unit-tests zijn handig voor logica los van alles, maar vangen geen gedrag uit je database, config of externe koppelingen. Voeg daarom waar nodig contracttests of integratietests toe die echt op de interface zitten van je systeem. Extra belangrijk bij beveiliging: negatieve tests (mag niet) op verkeerde rechten, vervallen tokens, onvolledige objecten of valse aanvragen van andere gebruikers. Na een fout mag een transactie niets half bewaren.

Pas op voor tests die alleen interne structuren checken, bijvoorbeeld of een bepaalde functie wordt aangeroepen, terwijl de uitkomst niet wordt gecontroleerd. Zo'n test hindert refactoren zonder risico's te verminderen. Mutatietests of simpelweg eens bewust een fout inbouwen laten vlug zien of je assertions echt waarde hebben. Dekking meten heeft zin maar zegt niets over kwaliteit, 100 procent coverage kan samengaan met inhoudsloze assertions. Vraag jezelf af: als deze test faalt, wat heb ik dan ontdekt? Lees ook over AI-toepassingen testen.

Voorkom onderhoudspijn voordat code blijft

AI-gegenereerde code kan de bestaande architectuur ontwijken: een controller die een losse DB-verbinding start, een nieuwe validatie-uitstulping, extra helpers die eigenlijk niet in een patroon passen. Dat lijkt misschien snel, maar straks weet niemand meer wie verantwoordelijk is. Vergelijk altijd eerst met de bestaande grenzen: waar hoort businesslogica, hoe handel je afhankelijkheden af, wie managet exceptions? Ga alleen van de standaard af als je daar bewust voor kiest, niet omdat het model het zo uitspuugt.

Zorg dat je ook in de toekomst snapt wat hier gebeurt. Liggen namen in het verlengde van het domein, kun je de flow volgen zonder over dertig neveneffecten te struikelen, zijn fouten expliciet geadresseerd? Vermijd dubbele stukken, te brede try-blokken, generieke hulpfuncties waar je drie keer moet lezen voor je doorhebt wat ze doen. Compact is niet automatisch goed onderhoudbaar; abstraheren “voor het geval dat” zorgt vaak juist voor overbodige complexiteit. Pak het pas aan als je ziet dat het patroon vaker voorkomt.

Let verder op operationele zaken als logging en storingeffect. Zorg dat errorlogs duidelijk zijn zonder gevoelige gegevens te lekken. Werken time-outs, retries, limieten goed met de gekoppelde systemen? Oneindige retries kunnen, ironisch, juist schade vergroten. Onthoud: een simpele diff kan ongemerkt veranderen hoe data wordt opgeslagen of een publieke API werkt, soms zit het pijnpunt pas buiten beeld. Bij een PHP-project helpt een review die ook de bestaande architectuur en afspraken meeneemt.

Nú alvast privacy, licentie en herkomst nagaan

Beoordelen stopt niet bij techniek. Check altijd wat je met je prompts en code deelt. AI-modellen zien soms meer dan jij wilt; een prompt kan sleutelgegevens, privacygevoelige details, een interne URL of bedrijfsregel bevatten, ook als dat niet direct als bedoelde ‘secret’ herkenbaar is. Volg het organisatiereglement voor welke modellen acceptabel zijn en hoe je omgaat met historische data. Verwijder gevoelige info voor je iets laadt in een cloudmodel, controleer of prompts opgeslagen worden.

Kijk waar de AI-fragmenten vandaan komen. Soms komt het model met code die sterk lijkt op bestaande open source, maar de oorspronkelijke herkomst is zelden duidelijk. Gaat het om overgenomen tekst uit documentatie, een voorbeeldrepo, letterlijk stuk code? Check de licentie, plak niet klakkeloos fragmenten in je project. Juridisch hangt acceptatie af van waar het vandaan komt, de gekozen licentie en distributie; een ‘AI-antwoord’ verandert daar niks aan.

Noteer voor je eigen opvolging relevante context: waarom is deze keuze gemaakt, welk ontwerp en welke test heeft dat beïnvloed, welke bron hoorde erbij? Niet elk prompt dialoog hoeft in de revisietool. Prompts zijn vaak niet geschikt als technische spec en kunnen vertrouwelijk zijn. Maar goede uitleg over het doel, ontwerpkeuzes en testgronden maakt een diff ook voor een volgende reviewer inzichtelijk. Denk ook na: wie mag deze code reviewen, wat komt er in open tools of tickets te staan? Bij een ChatGPT-integratie is het extra belangrijk om zorgvuldig te bepalen welke data je deelt.

Zorg voor passende controle met menselijke blik

Niet elke vondst uit een model vraagt evenveel reviewtijd. Was het een kleine stylefix, of raakt het je rechtenbeheer, betalingen of data-deleten? Kijk naar impact, of code direct publiek draait, en of fouten te herstellen zijn. Gebruik die risicoklasse om te beslissen welke tests, reviews én securitychecks nodig zijn. Je hebt maar één regel code nodig om machtigingen te omzeilen, aantal regels zegt soms niks over risico.

Maak zichtbaar wanneer code door een model werd voorgesteld, en verstrek reviewers alles wat ze moeten weten: welk gedrag wordt nagestreefd, welke randvoorwaarden en controles horen hier, van welke andere onderdelen is dit afhankelijk? Een reviewer moet de wijziging zelfstandig kunnen toetsen, niet (alleen) afgaan op motiveringen van een model. Hogere risico’s vragen om beoordeling door mensen met domein- of securitykennis, en dat mag niet automatisch door een testresultaat worden overruled.

Leg vast welke checks verplicht gelden en wat je doet bij een waarschuwing, scan die faalt of test die ontbreekt. Meldingen zonder gevolg devalueren snel; groepeer issues op belangrijkheid, wijs uitzonderingen expliciet toe. Blijf ook na livegang monitoren, bijvoorbeeld met logs of incidentnotificaties, om aannames te (her)toetsen waar die aan het licht komen. Zo voorkom je dat zaken onopgemerkt pijn doen op een verkeerde plek.

Veelgestelde vragen

Wie is verantwoordelijk voor AI-gegenereerde code die in productie staat?

De verantwoordelijkheid ligt bij de organisatie die de code live zet, niet bij een tool of model. Het is dus zaak dat je expliciet kiest wie inhoudelijk naar de wijziging kijkt, wie aanspreekbaar blijft na livegang, wie incidenten oppakt en who mag bijsturen als er iets misgaat. De precieze wettelijke beantwoording hangt af van context, systemen en interne afspraken.

  • Koppel een menselijke eigenaar aan de wijziging.
  • Leg vast wie mag bijstellen en wie incidenten opvolgt.
  • Houd je aan interne change-processen voor goedkeuring.

Moet je in een pull request vermelden dat code door AI is gegenereerd?

Dat hangt af van het interne beleid of van de vraag of het de reviewer helpt om het te weten. Een label is geen vervanging voor uitleg over het gedrag, keuzes en tests. De melding maakt review soms scherper, zeker als de aanpassingen extra toelichting nodig hebben of gebaseerd zijn op aannames die niet goed te controleren zijn.

  • Noteer welk deel met modelhulp ontstond als dat van belang is.
  • Leg het doel van de wijziging en cruciale keuzes kort uit.
  • Geef geen gevoelige informatie of prompts weg zonder akkoord.

Hoe neem je controles voor AI-gegenereerde code op in een CI/CD-pipeline?

Gebruik dezelfde checks als bij andere code en sta deploy alleen toe als de noodzakelijke controles slagen. Stel per soort wijziging vast welke tests en approvals nodig zijn; een aparte pipeline is alleen zinnig bij zwaar afwijkende eisen. Automatische checks vangen veel, maar beoordelen niet of je oplossing klopt of matcht met de businessrules.

  • Zet linting, testen, dependency- en secret-scans aan op elke relevante wijziging.
  • Laat gevoelige stukken extra valideren door bevoegde reviewers.
  • Voorkom merge als verplichte checks falen en leg uitzonderingen vast.

Wanneer kun je AI-gegenereerde code beter herschrijven dan verder reviewen?

Herschrijven heeft zin als het veiliger en goedkoper is om een kleine, leesbare oplossing nogmaals te bouwen dan een onduidelijke, afwijkende suggestie te proberen bij te sturen. Zeker bij code die technisch lastig uit te leggen is, onnodige extra's bevat of op twijfelachtige aannames rust. Neem risico, omvang en onderhoud als uitgangspunt, niet het enkele feit dat AI is gebruikt.

  • Vraag de indiener kort-te-bonden uit te leggen hoe het werkt en waarom zo.
  • Weeg de tijd en risico van aanpassen af tegen een eigen herbouw.
  • Laat alleen delen staan waarvan gedrag en herkomst helder is.

Hoe monitor je AI-gegenereerde code nadat die in productie is gezet?

Stel meetpunten in die passen bij het gebruik en risico. Een geslaagde test of succesvolle deployment zegt weinig over het gedrag in productie, echte belasting of samenwerking met andere systemen. Vergelijk relevante metrics, foutpercentages en uitkomsten vóór en na aanpassing. Maak vooraf afspraken over wanneer je terugdraait of ingrijpt.

  • Kies als dat wenselijk is voor een gefaseerde uitrol of featureflag.
  • Zet meldingen aan voor onvoorziene errors of afwijkende bedrijfsmelders.
  • Bepaal en test vooraf een terugvalscenario; controleer of het verwachte effect erna meetbaar is.

Foto: Godfrey Atima

Portret van Maarten

Maarten

Freelance developer in Nijmegen

Even kennismaken?

Vertel kort wat er speelt. Dan hoor je wat er kan, wat ik anders zou doen en waar AI bij jou wél en niet iets toevoegt. Vrijblijvend.

Het kantoor in Nijmegen
© 2026 maarten.online Sitemap Privacy Algemene voorwaarden
Het kantoor in Nijmegen

Maarten.

Freelance developer in Nijmegen. Liever direct contact? Dat kan ook.

Kennismaken

Laat je gegevens achter, dan kijken we of het klikt. Vrijblijvend en zonder verkooppraat.

Maarten

Stuur een bericht via WhatsApp

Hoi! Waar kan ik je mee helpen?

nu