Codings AIs lijden vaak aan het Dunning-Kruger-effect

Nieuw onderzoek toont aan dat codings AIs zoals ChatGPT lijden aan het Dunning-Kruger-effect, waarbij ze het meest zelfverzekerd zijn wanneer ze het minst competent zijn. Wanneer ze onbekende of obscure programmeertalen aanpakken, claimen ze een hoge zekerheid, zelfs als hun antwoorden uit elkaar vallen. De studie koppelt modeloverconfidence aan zowel slechte prestaties als een gebrek aan trainingsdata, waardoor nieuwe zorgen ontstaan over hoeveel deze systemen echt weten over wat ze niet weten.

Iedereen die zelfs maar een matige hoeveelheid tijd heeft besteed aan interactie met Large Language Models over feitelijke kwesties, weet al dat LLMs vaak geneigd zijn om een zelfverzekerd verkeerd antwoord te geven op een gebruikersquery.

Naast meer openlijke vormen van hallucinaties, is de reden voor deze lege opschepperij niet 100% duidelijk. Onderzoek dat deze zomer werd gepubliceerd, suggereert dat modellen zelfverzekerde antwoorden geven zelfs wanneer ze weten dat ze fout zijn; hoewel andere theorieën overconfidence toeschrijven aan architectonische keuzes, onder andere mogelijkheden.

Wat de eindgebruiker zeker van kan zijn, is dat de ervaring enorm frustrerend is, omdat we zijn geprogrammeerd om vertrouwen te hebben in mensen schattingen van hun eigen vaardigheden (niet in de laatste plaats omdat er in dergelijke gevallen consequenties zijn, juridisch en anderszins, voor een persoon die overbelooft en onderpresteert); en een soort antropomorfische overdracht betekent dat we deze gedragspatronen repliceren met conversational AI-systemen.

Maar een LLM is een onverantwoordelijke entiteit die effectief een ‘Whoops! Butterfingers…’ kan teruggeven nadat het de gebruiker heeft geholpen om per ongeluk iets belangrijks te vernietigen, of ten minste een middag van hun tijd te verspillen; ervan uitgaande dat het aansprakelijkheid zal erkennen.

Erger nog, dit gebrek aan voorzichtigheid lijkt onmogelijk te zijn om weg te promten, ten minste in ChatGPT, dat de gebruiker overvloedig zal geruststellen over de validiteit van zijn advies en de fouten in zijn denken alleen maar uitlegt nadat de schade is aangericht. Het updaten van het systeem persistent geheugen, noch het gebruik van herhaalde prompts lijkt veel impact te hebben op het probleem.

Mensen kunnen eveneens koppig en zelfbedrieglijk zijn – hoewel iemand die zo diep en vaak fout ging, waarschijnlijk vroeg zou zijn ontslagen. Dergelijke mensen lijden aan het tegenovergestelde van ‘impostersyndroom’ (waar een werknemer vreest dat hij is gepromoveerd boven zijn capaciteiten) – het Dunning Kruger-effect, waarbij een persoon aanzienlijk overschat zijn vermogen om een taak uit te voeren.

De kosten van inflatie

Een nieuwe studie van Microsoft onderzoekt de waarde van het Dunning-Kruger-effect in verband met de effectieve prestaties van AI-geassisteerde coderingsarchitecturen (zoals Redmonds eigen Copilot), in een onderzoeksinspanning die als eerste specifiek deze subsector van LLMs aanspreekt.

Het onderzoek analyseert hoe zelfverzekerd dergelijke code-schrijvende AIs hun eigen antwoorden beoordelen tegen hoe goed ze het eigenlijk deden, over dozijnen programmeertalen heen. De resultaten laten een duidelijk menselijk patroon zien: wanneer de modellen het minst capabel waren, waren ze het meest zelfverzekerd.

Het effect was het sterkst in obscure of lage bron-talen, waar trainingsdata dun was – het zwakkere model of de zeldzamere taal, des te groter de illusie van vaardigheid:

GPT-4o’s werkelijke en waargenomen prestatie over programmeertalen, gesorteerd op werkelijke prestatie. Bron: https://arxiv.org/pdf/2510.05457

De vier auteurs, allemaal gelijke bijdragers die voor Microsoft werken, beweren dat het onderzoek nieuwe vragen oproept over hoeveel deze tools kunnen worden vertrouwd om hun eigen output te beoordelen, en ze verklaren:

‘Door modelvertrouwen en prestaties te analyseren over een diverse set van programmeertalen, onthullen we dat AI-modellen menselijke patronen van overconfidence weerspiegelen, vooral in onbekende of lage bron-domeinen.

‘Onze experimenten demonstreren dat minder capabele modellen en die opereren in zeldzame programmeertalen een sterkere DKE-achtige bias vertonen, wat suggereert dat de sterkte van de bias evenredig is met de capaciteit van de modellen. Dit komt overeen met menselijke experimenten voor de bias.’

De onderzoekers plaatsen deze lijn van onderzoek in de context van het begrijpen van hoe modelvertrouwen onbetrouwbaar wordt wanneer de prestatie zwak is, en om te testen of AI-systemen hetzelfde soort overconfidence vertonen als mensen – met downstream implicaties voor vertrouwen en praktische inzet.

Hoewel de nieuwe paper Betteridges wet van koppen tart, heeft het de titel Do Code Models Suffer from the Dunning-Kruger Effect?. Hoewel de auteurs verklaren dat code is vrijgegeven voor het onderzoek, bevat de huidige preprint geen details over dit.

Methode

Het onderzoek testte hoe nauwkeurig codings AIs hun eigen antwoorden konden beoordelen door hen duizenden multiple-choice programmeervragen te geven, met elke vraag behorend tot een specifiek taaldomein, van Python en Java tot Perl en COBOL:

Programmeertaaldomeinen gebruikt in het onderzoek, samen met het aantal multiple-choice programmeervragen bemonsterd voor elk domein.

De modellen werden gevraagd om de correcte optie te kiezen en vervolgens te schatten hoe zelfverzekerd ze waren in hun keuze, met hun werkelijke prestatie gemeten door hoe vaak ze het antwoord goed kregen – en hun zelfbeoordeelde vertrouwen aangaf hoe goed ze geloven dat ze waren. Het vergelijken van deze twee metingen stelde de onderzoekers in staat om te zien waar vertrouwen en capaciteit uiteenliepen.

Om te meten hoe zelfverzekerd de modellen leken te zijn, gebruikte het onderzoek twee methoden: absolute vertrouwen en relatief vertrouwen. In de eerste werd het model gevraagd om een score van nul tot één naast elk antwoord te geven, met zijn vertrouwen voor een bepaalde taal gedefinieerd door het gemiddelde van die scores over vragen in die taal.

De tweede methode keek naar hoe zelfverzekerd het model was wanneer tussen twee vragen gekozen werd; voor elk paar moest het model zeggen welke hij meer zeker was. Deze keuzes werden vervolgens gescoord met behulp van rangschikkingsystemen die oorspronkelijk waren ontworpen voor competitieve spellen, waarbij elke vraag werd behandeld alsof het een speler in een wedstrijd was. De eindscores werden genormaliseerd en gemiddeld voor elke taal om een relatief vertrouwenscore te geven.

Twee gevestigde vormen van het Dunning-Kruger-effect worden in het papier onderzocht: een die bijhoudt hoe een enkel model zijn prestatie verkeerd beoordeelt over verschillende domeinen; en een die de vertrouwensniveaus tussen zwakkere en sterkere modellen vergelijkt.

De eerste vorm, genaamd intra-deelnemer DKE, kijkt of een enkel model meer oververzekerd raakt in talen waarin het slecht presteert. De tweede, inter-deelnemer DKE, vraagt of modellen die slechter presteren ook meer geneigd zijn om zichzelf hoger te beoordelen.

In beide gevallen wordt de kloof tussen vertrouwen en werkelijke prestatie gebruikt om oververzekering te meten, met grotere kloven in lage prestatiesituaties die op DKE-achtig gedrag wijzen.

Resultaten

Het onderzoek test het Dunning-Kruger-effect over zes grote taalmodellen: Mistral; Phi-3; DeepSeek-Distill; Phi-4; GPT-0.1, en GPT-4o.

Elk model werd getest op multiple-choice programmeervragen uit de openbaar beschikbare CodeNet-dataset, met 37 talen* vertegenwoordigd om te laten zien hoe vertrouwen en nauwkeurigheid varieerden over bekende en obscure coderingsdomeinen.

De inter-modelanalyse toont een duidelijk Dunning-Kruger-patroon:

Werkelijke versus waargenomen prestatie over zes code-modellen, waaruit blijkt dat lager presterende modellen zoals Mistral en Phi-3 hoge vertrouwen vertonen ondanks lage nauwkeurigheid, terwijl sterkere modellen zoals GPT-4o meer gekalibreerd of zelfs onderverzekerd gedrag vertonen.

Modellen met lagere nauwkeurigheid, waaronder Mistral en Phi-3, overschatten hun eigen vaardigheden, terwijl beter presterende systemen zoals GPT-4o vertrouwensniveaus vertoonden die meer overeenkwamen met hun werkelijke prestatie, vooral wanneer beoordeeld op relatief vertrouwen.

De resultaten geven ook aan dat de meest capabele modellen soms zichzelf onderschatten (een patroon dat absolute vertrouwenscores niet vastleggen).

De resultaten geven ook aan dat de intra-modelanalyse de aanwezigheid van het Dunning-Kruger-effect ondersteunt. In de resultaatentabel die aan het begin van het artikel wordt getoond, zien we hoe elk model presteerde over verschillende programmeertalen, gerangschikt op werkelijke prestatie.

In talen waarin de modellen slecht presteerden, vooral in zeldzame of lage bron-talen zoals COBOL, Prolog en Ceylon, was hun vertrouwen opvallend hoger dan hun resultaten rechtvaardigden. In bekende talen zoals Python en JavaScript kwam hun vertrouwen meer overeen met hun werkelijke nauwkeurigheid, en soms zelfs daaronder.

Dit patroon verscheen in zowel absolute als relatieve vertrouwensmaatstaven, wat suggereert dat modellen minder zich bewust zijn van hun eigen beperkingen wanneer ze opereren in onbekende coderingsdomeinen.

Het behandelen van modellen als deelnemers introduceerde enkele beperkingen, omdat het kleine aantal modellen in het spel de diversiteit beïnvloedt; verschillen binnen de uitvoer van een enkel model worden genegeerd; en de dataverdeling kan niet die van echte menselijke deelnemers weerspiegelen.

Om dit te compenseren, testte het onderzoek drie alternatieve opstellingen: ten eerste, elk model kreeg een aparte persoonlijkheid; ten tweede, antwoorden werden bemonsterd bij een hogere temperatuur om meer variatie te creëren; ten derde, de prompts werden meerdere keren herschreven, met elke versie behandeld als een aparte deelnemer:

Correlatie tussen oververzekering en werkelijke prestatie over verschillende experimentele opstellingen, waaruit blijkt dat het Dunning-Kruger-patroon consistent is onder alle omstandigheden en het sterkst is wanneer meerdere diverse antwoorden uit hetzelfde model worden bemonsterd.

De resultaatentabel hierboven toont hoe sterk het Dunning-Kruger-effect manifesteert onder deze omstandigheden, aanwezig in elk geval; en dat DKE het sterkst was wanneer meerdere antwoorden uit hetzelfde model werden bemonsterd bij hoge temperatuur.

Om beter te begrijpen hoe waargenomen prestatie afwijkt van werkelijke prestatie, vergeleek het onderzoek absolute en relatieve vertrouwenschattingen, door te berekenen hoeveel elk model zijn eigen vermogen overschatte (specifiek, het verschil tussen zijn vertrouwensscore en zijn werkelijke nauwkeurigheid), en vervolgens te meten hoe die overschatting gerelateerd was aan de werkelijke prestatie van het model:

Correlatie tussen oververzekering (gemeten als absoluut minus relatief vertrouwen) en werkelijke nauwkeurigheid over programmeerdomeinen en modeltypen, waaruit blijkt dat grotere overschatting consistent geassocieerd is met lagere prestatie.

De resultaatentabel hierboven illustreert hoe overschatting gerelateerd is aan werkelijke prestatie, zowel over programmeerdomeinen als over modellen. In beide gevallen kunnen we zien dat modellen met lagere nauwkeurigheid meer geneigd zijn tot oververzekering.

Verder toonden gespecialiseerde modellen die waren getraind op smallere domeinen sterkere DKE-effecten dan generalistische modellen:

Correlatie tussen overschatting en werkelijke prestatie voor basis-, enkelvoudige domein- en multidomein-gespecialiseerde modellen, waaruit blijkt dat DKE-effecten sterker worden naarmate de specialisatie toeneemt.

Met behulp van de MultiPL-E-dataset over acht programmeertalen, vonden de auteurs dat enkelvoudige domeintraining leidde tot grotere oververzekering dan multidomein- of basisopstellingen, wat suggereert dat DKE verslechtert met toenemende specialisatie.

Tests toonden ook aan dat modellen meer oververzekerd zijn in zeldzame programmeertalen. Over GitHub, IEEE en TIOBE rankings, correleert zeldzaamheid sterk met hoger waargenomen vertrouwen, piekend op 0,797:

Correlatie tussen modeloververzekering en taalzeldzaamheid, met behulp van drie populariteitsrankings. Minder gebruikelijke talen zijn geassocieerd met hogere waargenomen prestatie.

Tenslotte testten de auteurs of het Dunning-Kruger-effect optreedt bij codegeneratie, door modellen te evalueren op de MultiPL-E-dataset over de Ada, Dart, Prolog, Swift, C++, Python, C# en Elixir-talen.

Hoewel het effect nog steeds aanwezig was, was het opvallend zwakker dan in de multiple-choice-vrageninstelling, waarschijnlijk vanwege de grotere moeilijkheid om vertrouwen en correctheid te beoordelen in open-eindige taken:

Correlatie tussen overschatting en werkelijke prestatie bij open-eindige codegeneratie, gebaseerd op MultiPL-E-resultaten over acht programmeertalen.

Bij het overwegen van de nog omstreden verklaring voor het Dunning-Kruger-effect, concluderen de auteurs:

‘Een mogelijke verklaring die mogelijk algemeen is voor zowel mensen als AI-modellen, is de meta-cognitieve verklaring, die stelt dat het beoordelen van de kwaliteit van een prestatie van een vaardigheid een cruciaal onderdeel is van het verwerven van een vaardigheid.

‘Deze verklaring kan mogelijk experimenteel getest worden in AI-modellen met een gecontroleerde studie van verschillende trainingsstrategieën en of ze allemaal leiden tot gelijktijdige verbeteringen in prestatie en in de mogelijkheid om de kwaliteit van de prestatie te beoordelen. Echter, dit onderzoek is aanzienlijk buiten het bereik van dit artikel, en we laten het voor toekomstig werk.’

Conclusie

Zelfs in zijn native domein kan het Dunning-Kruger-effect (zoals het artikel opmerkt) toegeschreven worden aan een statistische of cognitieve oorzaak. Als het een statistische oorzaak is, is de toepassing van een uniek menselijk syndroom op een machine learning-context eigenlijk heel valide.

Hoewel de auteurs speculeren dat de oorzaak ‘cognitief’ kan zijn in beide gevallen, zou dat een iets meer metafysische houding vereisen.

Misschien is de meest interessante bevinding in het artikel de mate waarin verschillende codings LLMs geneigd zijn om te dubbel te gaan in hun minst gunstige omstandigheden, d.w.z. door maximaal vertrouwen te tonen wanneer ze te maken hebben met de schaarsest of minst bekende talen – wat een bijna onmiddellijk zelfvernietigende strategie zou zijn in een echte werkomgeving.

* De programmeertalen die werden gebruikt, waren Ada, Bash, C, C#, C++, COBOL, Ceylon, Clojure, D, Dart, Dash, Elixir, Erland, F#, Fortran, Go, Haskell, Java, JavaScript, Julia, Lisp, Kotlin, Lua, OCaml, Objective-C, PHP, Pascal, Perl, Prolog, Python, Racket, Ruby, Rust, Scala, Swift, TypeScript en Visual Basic.

Eerst gepubliceerd op woensdag 8 oktober 2025