Archetypes 1–3: nauwkeurigheid & grounding

Waarom “klinkt goed” bij DNB niet genoeg is

Je krijgt in Copilot een antwoord dat strak geschreven is, logisch oogt en precies jouw woorden lijkt te gebruiken. In een DNB-context is dat juist het risico: de vorm kan betrouwbaarheid simuleren. Eén onjuiste definitie, één verzwegen aanname, of één onterechte causaliteit kan gevolgen hebben voor besluiten, reputatie en uitlegbaarheid.

Archetypes 1–3 zijn daarom je “nauwkeurigheids-set”: ze helpen je delegatie te begrenzen, je eigen redenering te spiegelen en claims te valideren. Samen zorgen ze voor grounding: je output blijft verbonden met bronmateriaal, met expliciete aannames, en met controlepunten waar jij eigenaar van blijft.

In deze les leer je hoe je bewust schakelt tussen Offloader, Self-Checker en Critical Verifier—zodat Copilot je versnelt zonder dat je de kernwaarden rond zorgvuldigheid en navolgbaarheid ondermijnt.

Drie denkstanden, drie soorten zekerheid

Nauwkeurigheid betekent hier: uitspraken zijn correct binnen scope, termen zijn consistent gedefinieerd, en conclusies volgen aantoonbaar uit onderbouwing. Grounding betekent: wat je opschrijft is herleidbaar naar bronnen, data, of expliciet gemarkeerde interpretatie—niet naar “waarschijnlijk klinkende” taal.

Deze drie archetypes leveren elk een ander type zekerheid op:

• Offloader (Wat kan ik delegeren?): proceszekerheid. Je wint tijd door werk te laten doen dat jij inhoudelijk al kunt beoordelen (samenvatten, structureren, eerste versie).

• Self-Checker (Klopt mijn eigen analyse?): redeneringszekerheid. Je test jouw logica op sprongen, blinde vlekken en framing.

• Critical Verifier (Is dit wetenschappelijk correct?): feitelijke zekerheid. Je checkt beweringen op bewijs, definities, meetbaarheid en bronkwaliteit.

Belangrijk onderliggend principe: AI verhoogt waarschijnlijkheid, geen waarheid. De archetypes maken dat praktisch: je voorkomt dat je “mooie tekst” verwart met “goede onderbouwing”, en je bouwt een controlepad dat je later kunt uitleggen.

Offloader: delegeren met harde grenzen (zodat snelheid veilig blijft)

Offloader werkt het best als je het ziet als workflow-ontlasting, niet als inhoudelijke besluitvorming. Je laat Copilot het werk doen dat veel tijd kost maar weinig menselijk oordeel vereist: lange stukken reduceren, bullets ordenen, herhalingen verwijderen, koppen voorstellen. De kwaliteit zit niet in “hoe goed de AI het begrijpt”, maar in hoe strak jij de opdracht afbakent. Als je scope vaag blijft (“vat samen en geef risico’s”), dan gaat de AI bijna altijd toch interpreteren, rangschikken en soms zelfs aanvullen—precies waar de risico’s beginnen.

Een goede Offloader-prompt bevat daarom drie componenten: inputgrenzen, outputvorm, en verboden gedrag. Inputgrenzen: welk document, welke paragrafen, welke periode, welke definities. Outputvorm: lengte, structuur, gewenste rubrieken. Verboden gedrag: geen nieuwe feiten, geen aannames als feiten presenteren, geen externe bronnen verzinnen. Je stuurt dus op een output die je later kunt checken: compact, traceerbaar en zonder “creatief invullen”.

De meest voorkomende misconceptie is: “Als ik Offloader gebruik, heb ik al een eerste ‘inhoudelijk goede’ versie.” In werkelijkheid heb je een eerste tekstversie, geen eerste waarheid. Offloader is bedoeld om tijd vrij te spelen voor de archetypes die inhoudelijke risico’s reduceren. Zie het als een productie-stand: je koopt snelheid, maar je betaalt terug met controle. Als je die controle niet plant, stapelt het risico zich op in een nette opmaak.

Best practices die in DNB-achtige settingen het verschil maken:

• Vraag om letterlijke extractie (“citeer sleutelzinnen”) naast samenvatting; dat verhoogt grounding.

• Laat Copilot onzekerheden markeren (“waar is het bronmateriaal ambigu?”) in plaats van ze glad te strijken.

• Werk met “alleen op basis van deze tekst” als standaardzin, zodat je output niet stiekem wordt aangevuld.

Self-Checker: AI als spiegel, niet als arbiter

Self-Checker draait om een ongemakkelijke waarheid: de grootste vertekening zit vaak niet in de AI, maar in jouw eigen framing. Je hebt al een verhaal in je hoofd (“dit is het grootste risico”, “dit is de logische conclusie”), en AI is goed in het ondersteunen van het verhaal dat jij impliciet aanbiedt. Self-Checker gebruikt Copilot juist om die vanzelfsprekendheid te doorbreken. Je vraagt niet: “vind je dit goed?”, maar: “waar zou dit fout kunnen gaan?”, “welke aanname maak ik zonder het te zeggen?”, “welke interpretatie is ook plausibel?”.

Praktisch werkt Self-Checker het best als je jouw redenering eerst expliciet maakt—desnoods in ruwe bullets—en daar dan op laat “schieten”. Je kunt Copilot vragen om je argumentatie te herformuleren als een reeks premissen → gevolgtrekking, en vervolgens om zwakke schakels te signaleren. Dit is vooral nuttig bij beleids- of toezichtcontexten waar je altijd te maken hebt met trade-offs: effectiviteit versus proportionaliteit, snelheid versus uitlegbaarheid, risico-reductie versus neveneffecten. Self-Checker helpt je die afruilen expliciet te maken in plaats van ze te verstoppen in taal.

Een typische valkuil is “AI als objectiviteitstempel”: je laat de AI zeggen dat je redenering logisch is, en voelt je daardoor zekerder. Maar als je de AI niet dwingt om tegen je in te denken, krijg je vooral bevestiging. Een tweede valkuil is dat je alleen om tegenargumenten vraagt zonder criteria, waardoor je een lijst krijgt die indrukwekkend klinkt maar niet relevant is. Daarom hoort bij Self-Checker altijd: welke criteria maken een tegenargument sterk? (bijvoorbeeld: empirische plausibiliteit, consistentie met definitie, impact op kernwaarden, uitvoerbaarheid).

Goede Self-Checker-uitvoer is niet “een beter verhaal”, maar een eerlijker verhaal: duidelijker waar onzekerheid zit, waar alternatieven bestaan, en waar jouw conclusie afhankelijk is van aannames.

Critical Verifier: van overtuigend naar controleerbaar

Critical Verifier is de stand waarin je expliciet strijd voert tegen hallucinatierisico, schijnprecisie en valse causaliteit. Je behandelt AI-output als een tekst die mogelijk fouten bevat, en je vraagt om een audit: welke beweringen zijn feitelijk, welke zijn interpretatief, welke zijn normatief, en welke vereisen verificatie. Dit archetype is extra belangrijk zodra er cijfers, definities, “onderzoek toont aan”-claims of impliciete causaliteit in het spel zijn. Juist omdat AI taalmodellen zinnen kan produceren die wetenschappelijk klinken, is jouw opdracht om de output om te zetten naar een checkbaar format.

De kerntechniek is: claim-ontleding. Je laat Copilot uitspraken opdelen in losse claims, en per claim aangeven: (1) wat zou als bewijs gelden, (2) waar in het bronmateriaal het staat, of (3) dat het niet traceerbaar is. Vervolgens maak jij een keuze: schrappen, herformuleren als hypothese, of zelf verifiëren in betrouwbare bronnen. Als je geen gecontroleerde broncontext in Copilot hebt, is de juiste houding: AI kan signaleren, jij verifieert. Dat is geen beperking; het is governance in actie.

Misconcepties die hier vaak voorkomen:

• “Bronvermelding = waarheid.” AI kan bronnen verzinnen of onjuist toeschrijven; een verwijzing is pas waardevol als jij hem kunt openen en de claim terugvindt.

• “Het staat logisch, dus het is waar.” Logica is geen empirisch bewijs; causaliteit vereist onderbouwing.

• “Een nuancezin dekt het af.” “Kan mogelijk” helpt, maar vervangt geen verificatie wanneer de claim besluitvorming beïnvloedt.

Een goede Critical Verifier-output is soms “saai”: veel labels, veel onzekerheid, duidelijke grenzen. Dat is precies de bedoeling—want zo maak je een tekst die je later kunt uitleggen en verdedigen.

[[flowchart-placeholder]]

Twee realistische workflows met Copilot (en wat ze opleveren)

Voorbeeld 1: Offloader → Self-Checker bij een interne memo onder tijdsdruk

Je moet een interne memo maken over risico’s in een adviesstuk. Je start als Offloader: je vraagt Copilot om een samenvatting met koppen “Kernpunten”, “Implicaties”, “Open vragen”, met expliciet verbod op nieuwe claims. Hierdoor krijg je snel een hanteerbare basis en zie je meteen waar het document zelf al onzeker of dubbelzinnig is. De winst is vooral dat je tijd vrijmaakt om niet in productie-modus te blijven hangen.

Daarna schakel je naar Self-Checker met jouw eigen voorlopige conclusie (bijvoorbeeld: “risico X is dominant, daarom maatregel Y”). Je vraagt Copilot om jouw redenering te herschrijven als premissen en gevolgtrekking, en vervolgens om drie plausibele tegenlezingen: een die jouw causaliteit bevraagt, een die jouw scope te breed vindt, en een die een alternatieve risicoprioriteit verdedigt. Je gebruikt dit niet als “wie wint”, maar als spiegel: waar moet jij explicieter zijn, waar moet je onzekerheid benoemen, en waar zijn je criteria impliciet?

Impact en beperking:

• Impact: je memo wordt robuuster en eerlijker; je voorkomt dat één frame de rest van de tekst stilletjes stuurt.

• Beperking: Self-Checker kan eindeloos opties blijven genereren; jij moet beslissen welke kritiek relevant is voor DNB-doelen en kernwaarden.

Voorbeeld 2: Self-Checker → Critical Verifier bij “wetenschappelijk klinkende” claims

Je krijgt AI-output waarin staat: “Onderzoek toont aan dat interventie A leidt tot significante reductie van risico B” en “internationale best practices adviseren C”. Je start als Self-Checker door te vragen: “Welke aannames moet ik geloven om deze conclusie te accepteren?” Copilot kan dan vaak expliciteren: aannames over populatie, meetmethoden, tijdshorizon, en definities van “significant” en “best practice”. Alleen al dit stapje haalt je uit de hypnose van autoritaire taal.

Vervolgens ga je naar Critical Verifier en je vraagt om een claim-audit in tabelvorm: per claim labelen of het feit/interpretatie/norm is, en welke verificatie nodig is. Cruciaal is dat je Copilot ook laat aangeven welke delen niet herleidbaar zijn naar jouw input. Alles wat niet traceerbaar is, behandel je als: schrappen, herformuleren als hypothese, of buiten de memo houden tot je het zelf hebt gecheckt. Daarmee maak je het verschil tussen “AI-tekst” en “verantwoord document”.

Impact en beperking:

• Impact: je voorkomt schijnzekerheid en maakt je stuk uitlegbaar; je kunt expliciet zeggen wat je weet, wat je aanneemt, en wat je nog moet toetsen.

• Beperking: zonder toegang tot betrouwbare bronsets kan Copilot geen echte validatie leveren; het helpt vooral om jouw verificatiewerk slim te organiseren.

Wat je vanaf nu bewust anders doet

Archetypes 1–3 geven je een eenvoudige maar krachtige routine: snelheid eerst begrenzen (Offloader), dan je eigen denken aanscherpen (Self-Checker), en pas daarna claims hard maken (Critical Verifier). Je hoeft niet altijd alle drie te gebruiken, maar je wil wél weten welke je overslaat—en welk risico je daarmee accepteert.

Belangrijkste punten om mee te nemen:

• Offloader is productie onder voorwaarden: snel, afgebakend, zonder nieuwe claims.

• Self-Checker is anti-bevestiging: AI als tegenspreker die jouw aannames zichtbaar maakt.

• Critical Verifier is claim-werk: labelen, herleiden, en verificatie plannen; overtuigend taalgebruik telt niet als bewijs.

Next, we'll build on this by exploring Archetypes 4–6: verkennen naar verfijnen [30 minutes].