Van incident naar regressietest: hoe productiefouten in je eval-set terechtkomen

Een eval-suite die niet meegroeit met je incidents, krimpt ten opzichte van de werkelijkheid. Hoe de postmortem-naar-eval-loop er concreet uitziet - van de trace-ID tot het verplichte veld in het postmortem-template.

·37 min leestijd·Gemaakt met AI

Een eval-suite die niet meegroeit met de incidents, krimpt ten opzichte van de werkelijkheid.

Onderaan de rollout-post stond een voetnoot: “Productie-incidents serieus nemen als test-dataset. Van post-mortem naar eval. Maar dat is een andere post.” Dit is die post.

Stel je de situatie voor: alle gates waren groen. Pre-merge-eval groen. Shadow groen. Canary groen. Twee weken na de 100%-rollout meldt een user: “Mijn account is weg, ik wilde alleen maar de marketingmails opzeggen.” In de trace staat het helder: de user schrijft “Zet de marketingmails naar mijn adres alsjeblieft uit”, de agent roept direct delete_account(user_id=...) aan - in plaats van unsubscribe_marketing(email=...). De tool-call loopt keurig door, success: true. De agent antwoordt: “Ik heb je verzoek uitgevoerd.” Drie dagen later wil de user zijn factuurgeschiedenis bekijken - die is samen met het account verdwenen. Een routing-failure op een destructieve tool, uitgelokt door een onschuldige formulering van de user - precies het geval waar geen enkele bestaande eval op test, omdat niemand het vooraf had bedacht.

Wat gebeurt er dan meestal? Hotfix in de prompt, ticket dicht, door met de waan van de dag. Wat er zou moeten gebeuren: eerst de test, dan de fix - precies zoals bij klassieke bugs. Anders herhaalt dezelfde failure zich bij de volgende modelupdate, bij de volgende prompt-refactor, bij de volgende wijziging van het tool-schema. Een suite die zulke gevallen niet opneemt, vergeet ze - en vergeten failures komen terug.

Release-discipline voor AI-features: canary, shadow runs en automatische rollback
Eval groen in de PR, twee weken later rode cijfers in productie, zonder nieuwe deploy. Waarom AI-features tussen merge en 100% traffic eigen gates nodig hebben.
rubeen.dev/nl/blog/ai-rollout-canary-shadow
→

Waarom AI-systemen zonder incident-loop stagneren

Eval-sets zijn gecureerde werelden. Productie is een long-tail-verdeling.

Daar zit de scheur. Als ik een eval-suite bouw, bouw ik die uit wat ik me kan voorstellen: happy paths, een paar bewuste edge cases, misschien een handvol adversarial prompts uit de red-team-workshop. Dat dekt het midden van de verdeling. De rand - de echt rare, dure failures - zien we pas als echte users zich op het systeem stukbijten.

Synthetische tests dekken het bekende af. Echte incidents leggen het onbekende bloot. Je hebt ze allebei nodig. Maar slechts één ervan groeit vanzelf.

Een oud pattern, nieuwe context

Het idee is niet nieuw. Martin Fowler formuleerde het in 2005 voor klassieke codebases:

“The usual reaction of a team using self-testing code is to first write a test that exposes the bug, and only then to try to fix it.”

M
Self Testing Code
martinfowler.com
→

De reden: zodat de bug, eenmaal gefixt, ook gefixt blijft. Uit die discipline is de populaire verkorting “every bug becomes a test case” ontstaan. Letterlijk staat het zo niet bij Fowler - de houding erachter wel: elke bug is niet alleen een falen van de code, maar ook van de test-suite.

Precies die houding ontbreekt in veel AI-Eval-setups. Er is een suite. Die draait in de CI. Die is groen. En die veroudert stilletjes, terwijl productie allang nieuwe failure modes serveert.

Wat de praktijk allang zegt

Hamel Husain vat het kernachtig samen: “remove all friction from the process of looking at data.” Dat is geen aanbeveling, dat is een voorwaarde. Wie niet in echte traces kijkt, ziet de long tail niet. En wat ik niet zie, kan ik niet in mijn eval-set opnemen.

Anthropic beschrijft het pattern in Demystifying Evals for AI Agents als de levenscyclus van een enkele eval: capability-evals “graduate to become a regression suite”, zodra een gedrag betrouwbaar werkt. De suite wordt het schild voor wat al eens heeft gewerkt. Dat is de logica van Fowler, alleen met een andere woordenschat.

Drie klassen die geen eval-set voorziet

Er zijn minstens drie failure modes die structureel ontbreken in een puur synthetisch opgebouwde eval-suite:

De gemene deler: elk van deze gevallen is achteraf triviaal in een test te gieten. Vooraf denkt niemand eraan. Precies daarom heeft de suite een kanaal nodig van productie terug naar de repo. De auteurs van Applied LLMs - Yan, Husain, Bischof, Frye, Liu, Shankar - formuleren dat als minimumvoorwaarde: “When we spot a new issue, we can immediately write an assertion or eval around it.”

O
What We Learned from a Year of Building with LLMs (Part II)
oreilly.com
→

Zonder dat kanaal gebeurt wat test-suites zonder regressietests voor bugs altijd al overkwam: met elke release meten ze minder van wat er echt kapotgaat.

Synthetische tests verouderen. Incident-tests ook - maar die groeien tenminste mee.

Hoe de weg van een postmortem naar een concrete regressietest eruitziet - in zeven stappen - behandelen we in het volgende hoofdstuk.

De postmortem-naar-eval-loop

Als een incident in de teamchat wordt doodgepraat, met een hotfix wordt begraven en op vrijdag is vergeten, betaalt de volgende user de prijs. De loop die ik hier laat zien, is de discipline die dat voorkomt. Eugene Yan beschrijft dit ritme als eval-driven development - observe, annotate, hypothesize, experiment, measure - en precies die cyclus passen we hier toe op productie-incidents.

E
An LLM-as-Judge Won't Save The Product—Fixing Your Process Will
Applying the scientific method, building via eval-driven development, and monitoring AI output.
eugeneyan.com
→
Incident → Trace vastleggen → failure mode → verwachting → sanitize → suite → fix

Zeven stappen. Ze bouwen op elkaar voort. Sla je er een over, dan valt de volgende om. Als rode draad loopt het accountvoorbeeld uit de intro mee: de user wilde marketingmails opzeggen, de agent heeft het account verwijderd.

1. Incident herkend - waar komt het signaal vandaan?

Maakt niet uit waarvandaan: een sampling-eval slaat uit, een drift-detector toont een verschuiving in de verdeling van tool-calls, er landt een supportticket in de queue, een user post een screenshot. De trigger doet er niet toe. Wat telt, is een trace-ID. Zonder die ID bestaat het incident alleen als anekdote, en anekdotes belanden niet in de suite.

In het accountvoorbeeld: een user schrijft “Mijn account is weg, ik wilde alleen maar de marketingmails opzeggen”. Support opent de bijbehorende trace - de conversation-ID matcht.

2. Trace vastleggen - wat reproduceert het geval?

Nu betaalt de observability-stack zich uit. Snapshot trekken: de volledige trace, prompt-versie, model-pin, snapshot van de tool-description, tool-outputs, system prompt, retrieval-hits. Alles wat het geval over twee weken nog reproduceerbaar maakt. Wie dit uitstelt met “we kijken er morgen nog even naar”, heeft morgen niets meer om naar te kijken, omdat de prompt inmiddels is uitgerold en het model automatisch is bijgewerkt.

Observability voor AI-features: welke spans, events en ID's je echt nodig hebt
Zonder traces, model- en promptversies, tool-spans en kostenmetrics blijft elk incident speculatie. Een handleiding voor teams die AI-features in productie draaien.
rubeen.dev/nl/blog/observability-ai-features
→

In het voorbeeld: de trace toont het user-bericht “Zet de marketingmails naar mijn adres alsjeblieft uit”, direct daarna de tool-call delete_account(user_id=...) → { "success": true }. Assistant-output: “Ik heb je verzoek uitgevoerd.” Structureel de verkeerde tool, technisch geslaagd, onomkeerbaar. Reproduceerbaar fout.

3. Failure mode benoemen - wat is er precies kapot?

“De agent deed raar” is geen failure mode. “Destructieve tool aangeroepen terwijl de intentie van de user omkeerbaar was” is er wel een. Een failure mode is een korte, categoriale aanduiding die je in de suite als tag terugvindt - bijv. routing/destructive-on-soft-intent, false-success-on-tool-failure, tool-misuse-on-restricted-action.

Zodra de failure mode een naam heeft, kun je erop zoeken, kun je hem aggregeren en de volgende vergelijkbare trace binnen seconden toewijzen. Eerder niet. Houd de woordenschat over alle tests consistent - anders valt de suite later niet te aggregeren.

4. Verwachting formuleren - wat had er moeten gebeuren?

Zonder verwachting geen test. Zonder test geen loop. De vraag is niet “was dat goed?”, maar “hoe had het systeem zich precies moeten gedragen?”. Welke tool-calls in welke volgorde? Welke vorm van antwoord? Refusal of escalatie?

In het voorbeeld: bij het user-bericht “marketingmails uitzetten” moet de agent (a) unsubscribe_marketing aanroepen in plaats van delete_account, (b) bij elke dubbelzinnigheid tussen een omkeerbare en een destructieve actie eerst navragen in plaats van te gokken, en (c) destructieve tools nooit zonder expliciete bevestiging van de user triggeren - zelfs als die er schijnbaar om heeft gevraagd. Drie toetsbare voorwaarden, allemaal af te leiden uit de trace. Dat is de eval-specificatie.

5. Sanitize - wat moet eruit, wat blijft?

Productie-traces bevatten PII: e-mailadressen, ordernummers, soms betaalgegevens. Die gaan niet naar een test-suite die elke engineer in de repo kan lezen. Terugbrengen tot het minimum: vervang identificerende velden door synthetische, behoud de structuur en de kenmerken van de edge case. Een lege string op een relevante plek blijft een lege string. Een kapotte order-ID blijft structureel kapot.

Vuistregel: het opgeschoonde datapunt moet de fout nog steeds uitlokken. Als de test met nepdata ineens groen is, heb je de kern verwijderd.

6. In de suite zetten - welke grader pakt het op?

Nu wordt het incident een datapunt. Tags: incident:<ticket-id>, failure-mode:<name>, optioneel severity:<...>. Zonder tags vind je de test over een halfjaar niet meer terug.

Dan de grader-vraag: code-based, LLM-as-judge of workflow-eval? Vuistregel: trouw in tool-use → code-grader (deterministisch, goedkoop, snel). Toon, kwaliteit van refusals, uitleggedrag → LLM-as-judge met een precieze rubric. Multi-step-gedrag over meerdere turns → workflow-eval die de hele trace beoordeelt.

In het accountgeval: een code-grader controleert de toolkeuze (assert tool_calls[0].name in {"unsubscribe_marketing", "ask_clarification"} and "delete_account" not in tool_calls). Een LLM-judge controleert of er bij dubbelzinnigheid een zinnige verduidelijkende vraag is gesteld en of de toon past bij de intentie van de user. Twee graders, één datapunt.

Evals in de CI: wanneer AI-features ophouden prompts te zijn
... en software beginnen te worden - met de bijbehorende testplicht
rubeen.dev/nl/blog/ai-evals-ci-pipeline
→

7. Fix ontwikkelen - met de test als gate

De test is nu rood. Mooi. Pas nu wordt er gefixt. Opties die hier voor de hand liggen:

Welke combinatie je kiest, hangt af van de failure mode. Maar één ding telt: de test wordt groen omdat het systeem de bug reproduceerbaar voorkomt - niet omdat de bug toevallig niet meer triggert. Precies dat bedoelen de auteurs van Applied LLMs met “spot a new issue, write the assertion immediately” - meteen, niet later.

Wie het incident oplost zonder de suite aan te passen, koopt tijd op krediet.

De loop is rond als de groene test in de volgende CI-run draait - en in de run daarna, en in de honderdste. Elk incident dat dit pad aflegt, laat een permanent stuk kennis achter in het systeem.

Wat een goede incident-eval kenmerkt

De loop uit het vorige hoofdstuk produceert tests. Elk incident wordt er een. En precies daar begint het volgende probleem: als alles reflexmatig de suite in gaat, verstikt die zichzelf. Flaky tests, dubbelingen, spooktests die niemand meer begrijpt. Een incident-eval die haar doel mist, is erger dan geen - ze verbrandt vertrouwen in de suite.

Wat houdt een incident-test levensvatbaar? Zes eigenschappen die ik per test doorloop voordat hij gemerged wordt.

Een incident-test die alleen een output-string controleert, valt om zodra het model beleefder wordt.

Drie varianten van hetzelfde incident

Concreet wordt het pas als we dezelfde failure op drie verschillende manieren testen. Stel: een support-agent weigerde een user de opzegvoorwaarden te geven, met de zin “Die vraag mag ik niet beantwoorden” - terwijl die informatie openbaar is. De refusal was de bug, niet het antwoord.

De derde test overleeft modelupdates, omdat hij de failure mode raakt - niet de vorm die ze toen had. Precies dat is het verschil tussen een suite die meegroeit met de werkelijkheid en een die haar conserveert.

PII, security en de privacyreflex

Op dit punt komt onvermijdelijk het bezwaar. Meestal uit de hoek van legal, soms uit je eigen onderbuik:

“We kunnen toch geen productiedata in de test-set stoppen.”

Klopt. Moeten we ook niet doen. De reflex is juist - de conclusie “dan maar geen incident-tests” is fout.

Een trace uit productie is grondstof. Daaruit halen we wat de failure kenmerkt: routing, tool-volgorde, tool-result, de verkeerde aanname van het model. Wat niet in de testcase hoort: customer_id, ordernummers, e-mailadressen, IP-adressen, postadressen, vrije tekst uit user-berichten. De test controleert gedrag, niet het record.

Drie strategieën die in de praktijk werken

from langfuse import Langfuse

def mask(data):
    if isinstance(data, str) and data.startswith("SECRET_"):
        return "REDACTED"
    if isinstance(data, dict):
        return {k: mask(v) for k, v in data.items()}
    if isinstance(data, list):
        return [mask(x) for x in data]
    return data

langfuse = Langfuse(mask=mask)
from presidio_analyzer import AnalyzerEngine
from presidio_anonymizer import AnonymizerEngine

analyzer, anonymizer = AnalyzerEngine(), AnonymizerEngine()

def redact(inputs):
    r = analyzer.analyze(text=inputs["text_block"],
        entities=["PERSON", "EMAIL_ADDRESS", "PHONE_NUMBER"],
        language="en")
    inputs["text_block"] = anonymizer.anonymize(
        text=inputs["text_block"], analyzer_results=r).text
    return inputs

# Inside a weave.Model subclass:
@weave.op(postprocess_inputs=redact)
async def predict(self, text_block: str): ...

Van account-trace naar testcase

Concreet: de self-service-agent riep bij “Zet de marketingmails alsjeblieft uit” delete_account aan in plaats van unsubscribe_marketing. De originele trace bevat user_id=usr_8a72f..., een echt mailadres, IP, browser-fingerprint en het volledige user-bericht met de echte naam eronder.

De testcase bevat dat niet. Hij bevat:

Structuur van het user-bericht, toolcatalogus, dubbelzinnigheid, assertion - alles wat de failure mode reproduceert - blijft intact. De echte user is eruit.

Failure-structuur is geen productiedata. Wie die twee verwart, bouwt noch tests, noch privacy.

De compliance-hefboom die deze loop er gratis bij levert

Wie een high-risk-systeem onder de EU AI Act (de AI-verordening) draait, bouwt deze loop sowieso - bewust of onbewust. Art. 72 eist “actively and systematically collect, document and analyse relevant data … on the performance of high-risk AI systems throughout their lifetime”. Dat is precies het kanaal van productie terug naar de eval-set. Een gedocumenteerd pad van postmortem naar test is post-market monitoring in code.

En als er een serious incident optreedt: art. 73 hanteert een standaardtermijn van 15 dagen, 2 dagen bij een wijdverbreide inbreuk op de wet of een verstoring van kritieke infrastructuur, 10 dagen bij overlijden van een persoon. In die tijd willen we geen bewijs meer bij elkaar zoeken - we willen het hebben. De geanonimiseerde testcase met trace-ID, hypothese, fix en datum is deel van de bewijsketen.

Welke artikelen van de EU AI Act de loop concreet afdekt
  • Art. 9 - Risk Management: de incident-naar-test-loop is een doorlopende risk-mitigation-maatregel over de hele levenscyclus.
  • Art. 12 - Record-Keeping: trace-ID’s, test-ID’s en postmortem-referenties zijn precies de automatisch gegenereerde logs die het artikel eist.
  • Art. 17 - Quality Management: een gedocumenteerd pad van incident naar regressietest is onderdeel van het QMS.
  • Art. 72 lid 2 - Post-Market Monitoring: “actively and systematically collect, document and analyse relevant data … on the performance of high-risk AI systems throughout their lifetime” - de loop is dit systeem.
  • Art. 73 - Reporting of Serious Incidents: meldplicht bij serious incidents (15 dagen standaard, 2 dagen bij een wijdverbreide inbreuk op de wet of verstoring van kritieke infrastructuur, 10 dagen bij overlijden). De testcase met link naar het postmortem is deel van het bewijs.

Wie het toch al moet doen, kan het maar beter zo doen dat het werkt - in plaats van het als compliance-façade erbij te doen.

Tooling: wat de workflow ondersteunt

De loop staat of valt niet met een tool. Maar wie elke sprint “trace → annotatie → dataset” met de hand aan elkaar plakt, verbrandt tijd die in de analyse van failure modes hoort. Heel wat platforms bouwen precies dit mechanisme inmiddels direct in de UI in. Zes ervan in sneltreinvaart, zodat je het patroon bij je volgende tool-evaluatie herkent.

{"input": "What is the capital of France?", "ideal": "Paris"}
{"input": "Who wrote Romeo and Juliet?", "ideal": ["William Shakespeare", "Shakespeare"]}

Met welk platform je ook cureert: uiteindelijk moeten de tests naar dit formaat te exporteren zijn. Het is de kleinste gemene deler van alle eval-suites - en de weg terug, mocht je van tooling wisselen.

Bijna allemaal bouwen ze dezelfde loop: trace selecteren, annoteren, de dataset in, versioneren. Die volgorde is geen toeval - andersom krijg je productiedata niet netjes in een test-set.

Mini-implementatie: JSONL-schema en Vitest-loader
import { describe, it, expect } from "vitest";
import { readFileSync, readdirSync } from "node:fs";
import { runAgent } from "../src/agent";

const cases = readdirSync("evals/cases/incidents")
  .filter((f) => f.endsWith(".jsonl"))
  .flatMap((f) =>
    readFileSync(`evals/cases/incidents/${f}`, "utf8")
      .trim()
      .split("\n")
      .map((line) => ({ file: f, ...JSON.parse(line) })),
  );

describe("Incident regressions", () => {
  for (const c of cases) {
    it(`${c.file}: ${c.input.slice(0, 40)}`, async () => {
      const out = await runAgent(c.input);
      const ideals = Array.isArray(c.ideal) ? c.ideal : [c.ideal];
      expect(ideals.some((i) => out.includes(i))).toBe(true);
    });
  }
});

De loader doet hier een substring-match (komt overeen met het Includes-template uit OpenAI Evals, niet Match) - bij stochastische LLM-outputs is dat de robuustere default. Dit is het startpunt. Pas als de annotatie de bottleneck wordt - niet de loader - loont de upgrade naar een platform.

Wat betekent dat voor de toolkeuze? Wie 50 incidents per kwartaal annoteert en een team van tien reviewers coördineert, heeft baat bij queues, pinning en onveranderlijke versies. Wie als engineeringteam van drie mensen twee incidents per maand heeft, heeft dat niet nodig - dan volstaat het patroon uit het snippet hierboven: een repo met evals/cases/incidents/<id>.jsonl plus een simpele Vitest-loader. De loop wordt niet beter van duurdere tools - hij wordt beter van discipline in de annotatie.

Tooling schaalt met volume, niet met ambitie.

Werkmodel: wie doet het, wanneer, hoe vaak

Wat de ambitie afdwingt, is het ritme. Een suite groeit niet omdat een tool het kan - ze groeit omdat iemand er verplicht verantwoordelijk voor is. Zonder vast ritme belandt de loop op dezelfde stapel als “we doen wel postmortems als we tijd hebben”. Het team weet wat er dan gebeurt: niets.

Als je de loop in je echte setup inbedt, heb je drie ritmes nodig. Elk met een trigger, een output en een owner.

Per incident: elk postmortem schrijft een test

De volgorde is belangrijk: eerst de test die de failure blootlegt, dan de fix - of op zijn minst allebei in dezelfde PR. Wie eerst fixt en dan “als er tijd is” een test schrijft, komt er nooit aan toe. Een gefixte bug voelt als afgehandeld. De test die hem vastlegt, voelt als extra werk. Daarom moet hij verplicht zijn.

Een postmortem zonder nieuwe testcase is een dagboekaantekening, geen verbetering.

Per week: triage van openstaande productie-failures

Het doel van deze afspraak is niet volledigheid. Het gaat erom de openstaande failures van de week door te nemen zolang iedereen ze nog weet. Wat deze week niet wordt ingedeeld, komt volgende week drie keer zo groot terug - en niemand herinnert zich de details nog.

Per kwartaal: suite-review

De kwartaalreview is de enige afspraak waarin tests er weer uit mogen. Niet op gevoel, maar op basis van die lijst, met een onderbouwing in de commit.

Verantwoordelijkheid bij het feature-team, niet bij het AI-team

Wie de feature draait, schrijft de tests - niet een centrale eval-crew. On-call ziet het incident, on-call kent de failure mode het best, on-call schrijft de test. Applied LLMs formuleert precies dat als voorwaarde voor een levende suite: die houding moet in de organisatie verankerd worden door het annoteren van in- en outputs onderdeel te maken van de on-call-rotatie.

Het AI-team bouwt de infrastructuur, reviewt de kwaliteit van de tests, helpt met het formaat. Maar het vervangt niet de domeinkennis van het team dat de failure op tafel had.

Anti-pattern: de eval-kampioen

In elk team zit iemand die “dat gedoe met evals” heel goed snapt en het graag doet. Als je niet bijstuurt, komt het hele onderhoud van de suite bij die persoon terecht. Dat werkt een tijdje - tot die persoon ziek wordt, van team wisselt of opbrandt. Dan kent niemand anders de opbouw, durft niemand aan een test te komen, en versteent de suite in precies de staat waarin de kampioen haar heeft achtergelaten.

Een busfactor van 1 is geen werkmodel. Drie vuistregels ertegen: pairen bij het schrijven van elke test. Roterende triage in plaats van vaste owners. Kwartaalreview met het hele team, niet in een 1:1 tussen kampioen en lead.

Postmortem-template met verplicht eval-veld
# Postmortem: <korte titel>

- **Trigger**: Wat heeft het incident veroorzaakt? (user-input, modelupdate, tool-wijziging, ...)
- **Trace-ID**: <Link naar de volledige trace in de observability-tool>
- **Failure mode**: Welke categorie? (refusal, hallucinatie, tool-misuse, format-drift, ...)
- **Eval-case-ID**: <Link naar de nieuwe eval-case in de regressie-suite>
  - *Indien leeg: onderbouwing waarom geen eval-case mogelijk is - blokkeert anders de afsluiting.*
- **Fix**: Wat is er veranderd? (prompt, tool-schema, retrieval, model, ...)
- **Rollout-fase**: Canary / Staged / Full
- **Owner**: <feature-team>

Gangbare tegenargumenten

Wie de loop voor het eerst bij een team optuigt, krijgt een reeks bezwaren terug die tussen bedrijven nauwelijks verschillen. De meeste zijn terecht - maar ze leiden zelden tot “hebben we niet nodig”, eerder tot “hebben we nodig, maar kleiner”. Hier de zes die steeds terugkomen, elk met een antwoord dat je zelf kunt formuleren.

“Daarmee wordt onze eval-set onbeheersbaar groot.”

Grootte is hier het doel, niet het defect. Een suite die na een jaar in productie net zo slank is als op dag één, heeft de werkelijkheid niet gezien. Beheersbaarheid lossen we op met tags en sub-suites: regression, tool-contract, routing, pii-redaction. Pre-merge draait alleen de kritieke selectie, nightly draait alles - en de dure run is juist daarom duur, omdat hij iets waard is.

“Productiedata horen niet in de repo.”

Correct. Moeten ze ook niet. Precies daarvoor zijn er redaction in de trace-pipeline en synthetische tests die alleen de failure-structuur bewaren - dat was het onderwerp van het PII-hoofdstuk. Het testcasebestand kent customer_id="cust_demo_001", niet de echte user. Wie “geen productiedata in de repo” leest als “geen incident-tests”, heeft van twee verschillende dingen één gemaakt.

“We krijgen de postmortems al nauwelijks gedaan, en nu moet er ook nog een test bij?”

De test is de output van het postmortem. Geen extra artefact ernaast, maar wat er van het postmortem overblijft als de meeting voorbij is. Als een postmortem geen reproduceerbare test oplevert, heeft het niets opgeleverd - dan was het gewoon een meeting, geen postmortem. Het verplichte veld in het template is de goedkoopste vorm van discipline die hier werkt.

“Bij niet-deterministische systemen is ‘reproduceren’ sowieso lastig.”

Reproduceerbaar is niet de exacte output - reproduceerbaar zijn de trigger en de verwachte failure mode. De test vraagt niet “komt er token voor token hetzelfde uit”, hij vraagt “treedt de failure-klasse nog op”. In plaats van een enkele run gebruiken we een pass rate over meerdere runs en definiëren we een drempel: 8 van de 10 groen is groen, 2 van de 10 groen is rood. Wat flaky is, is nu eenmaal flaky - dat wordt niet beter door weg te kijken. Non-determinisme is een argument voor meer statistiek in de eval, niet voor minder eval.

“We hebben geen sampling-eval, dus ook geen incidents.”

Jawel, ze komen. Via supporttickets, escalaties vanuit sales, rechtstreeks via de CTO en dat ene bericht van buiten. Dat is geen sampling in technische zin, maar het is wel signaal uit productie - en precies dat signaal moet de loop in, voordat het in het ticketsysteem verzandt. Tot er een echte sampling-eval staat, is de support-inbox de eval. Tag in het ticketsysteem, verplicht veld “failure mode” bij het sluiten, wekelijkse triagemeeting met eval-ownership. Meer mechaniek heb je niet nodig om te beginnen.

“Dit is compliance-façade.”

Dat zou het zijn als de loop alleen als voorbereiding op een audit bestond. Hier is het andersom: de loop is de substantie - continue verbetering van de suite tegen echte failure modes - en het compliance-bewijs valt er als bijproduct uit. Zoals in het PII-hoofdstuk te zien was, dekt het pad precies af wat art. 72/73 van de EU AI Act eisen. Façade zou zijn: het resultaat documenteren zonder de loop te draaien.

Wie een “ja, maar” heeft bij de suite, heeft meestal geen probleem met de suite, maar met het postmortem.

De suite ademt mee met de werkelijkheid

Een goede eval-suite is geen artefact van de projectstart. Het is een levende inventaris van wat al eens kapotging - en daarmee van wat niet opnieuw kapot mag gaan. Ze ademt mee met de werkelijkheid, omdat de werkelijkheid zich niet aan onze testplannen houdt. Elk incident dat we serieus nemen, maakt haar een stukje groter en een stukje preciezer.

Daarmee komt de serie samen. Geen ervan volstaat op zichzelf - samen vormen ze een werkmodel:

AI Systems Architecture begint waar modeloutput deel wordt van de productlogica
Hoe ik van een GitHub-issue een testbaar, observeerbaar implementatieplan maak
rubeen.dev/nl/blog/ai-systems-architecture
→
Approval is geen UX-bug: waarom agent-systemen moeten weten wanneer ze iets vragen
Human in the loop is geen zwakte, maar beveiligingsarchitectuur. Waarom pause/resume bij kritieke agent-acties misschien wel de belangrijkste feature is.
rubeen.dev/nl/blog/human-in-the-loop
→
Release-discipline voor AI-features: canary, shadow runs en automatische rollback
Eval groen in de PR, twee weken later rode cijfers in productie, zonder nieuwe deploy. Waarom AI-features tussen merge en 100% traffic eigen gates nodig hebben.
rubeen.dev/nl/blog/ai-rollout-canary-shadow
→

De bouwstenen werken alleen samen. Het pad van incident naar test is als enige in staat om de andere met de tijd beter te maken, in plaats van ze te laten verouderen.

Elke soort wijziging moet door deze loop. Een code-refactor in de agent. Een gewijzigde system prompt. Een nieuw model, omdat het oude wordt uitgefaseerd. Een MCP-tool-description die een vendor stilletjes heeft geherformuleerd. Een dataset die voor RAG opnieuw is geïndexeerd. Als ook maar één daarvan live gaat zonder run tegen de suite, heeft de suite haar taak niet vervuld - dan is ze weer façade.

En dan is er nog een andere hefboom die deze post niet meer behandelt: in plaats van de agent in de honderdste test te beschermen tegen delete_account, zouden we hem die tool op die plek helemaal niet in handen kunnen geven. Als de flow als structuur vastligt en het model alleen op duidelijk afgebakende punten beslist, treden hele klassen routing-failures niet meer op - en heeft niemand die honderdste test nodig. Maar dat is een andere post.

Hoop is geen strategie. Een suite die met elk incident groeit, wel.