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 vaak 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 modeloververtrouwen aan zowel slechte prestaties als een gebrek aan trainingsgegevens, 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 gebruikersvraag.

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

Wat de eindgebruiker zeker van kan zijn, is dat de ervaring extreem frustrerend is, omdat we zijn geprogrammeerd om vertrouwen te hebben in mensen hun schattingen van hun eigen capaciteiten (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 antropomorfe overdracht betekent dat we deze gedragingen repliceren met conversational AI-systemen.

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

Erger nog, lijkt dit gebrek aan prudente omzichtigheid onmogelijk weg te prompen, althans in ChatGPT, dat de gebruiker overvloedig zal verzekeren van de geldigheid van zijn advies, en de fouten in zijn denken alleen zal uitleggen nadat de schade is aangericht. Noch het updaten van het systeem persistent geheugen, noch het gebruik van herhaalde prompts lijken veel impact te hebben op het probleem.

Mensen kunnen eveneens koppig en zelfbedrieglijk zijn – hoewel iemand die zo diep en vaak fouten maakt, waarschijnlijk vroeg ontslagen zou worden. Dergelijke personen lijden aan het tegenovergestelde van ‘impostersyndroom’ (waar een werknemer vreest dat hij boven zijn capaciteiten is gepromoveerd) – 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 tegenover hoe goed ze werkelijk presteerden, over tientallen 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 laagbron-talen, waar trainingsgegevens dun waren – hoe zwakker het model of hoe zeldzamer de taal, hoe groter de illusie van vaardigheid:

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

De vier auteurs, alle 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 over een diverse set van programmeertalen te analyseren, onthullen we dat AI-modellen menselijke patronen van oververtrouwen spiegelen, vooral in onbekende of laagbron-domeinen.

‘Onze experimenten demonstreren dat minder capabele modellen en die in zeldzame programmeertalen werken, 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 contextualiseren deze lijn van onderzoek als een manier om te begrijpen hoe modelvertrouwen onbetrouwbaar wordt wanneer de prestaties zwak zijn, en om te testen of AI-systemen hetzelfde soort oververtrouwen vertonen als mensen – met downstream implicaties voor vertrouwen en praktische inzet.

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 juiste optie te kiezen en vervolgens te schatten hoe zelfverzekerd ze waren in hun keuze, met hun werkelijke prestaties 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 metrieken 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: absoluut vertrouwen en relatief vertrouwen. In de eerste methode kreeg het model de opdracht 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 het tussen twee vragen koos; voor elk paar moest het model zeggen welke het meer zeker was. Deze keuzes werden gescoord met behulp van rangschikkingsystemen die oorspronkelijk waren ontworpen voor competitieve spellen, waarbij elke vraag werd behandeld als een speler in een wedstrijd. 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 artikel onderzocht: één die volgt hoe een enkel model zijn prestaties misjudiceert over verschillende domeinen; en een andere die confidence-niveaus tussen zwakkere en sterkere modellen vergelijkt.

De eerste vorm, genaamd intra-deelnemer DKE, kijkt of een enkel model meer oververzekerd wordt in talen waarin het slecht presteert. De tweede, inter-deelnemer DKE, vraagt of modellen die slechter presteren ook meer zelfverzekerd zijn.

In beide gevallen wordt de kloof tussen vertrouwen en werkelijke prestatie gebruikt om oververzekerdheid te meten, met grotere kloven in lage-prestatiesettings 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 prestaties over zes code-modellen, waaruit blijkt dat lager presterende modellen zoals Mistral en Phi-3 een hoge zelfverzekerdheid vertonen ondanks slechte nauwkeurigheid, terwijl sterkere modellen zoals GPT-4o een meer gekalibreerde of zelfs onderverzekerd gedrag vertonen.

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

De resultaten geven ook aan dat de meest capabele modellen soms hun eigen capaciteiten kunnen 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 resultaatgrafiek die aan het begin van het artikel wordt getoond, zien we hoe elk model presteerde over verschillende programmeertalen, gerangschikt naar werkelijke prestaties.

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

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

Door modellen als deelnemers te behandelen, werden enkele beperkingen geïntroduceerd, omdat het kleine aantal modellen in het spel de diversiteit beïnvloedt; verschillen binnen een enkel models output worden genegeerd; en de gegevensverdeling kan niet die van echte menselijke deelnemers weerspiegelen.

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

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

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

Om beter te begrijpen hoe waargenomen prestaties afwijken van werkelijke prestaties, berekende het onderzoek hoeveel elk model zijn eigen capaciteiten overschatte (specifiek, het verschil tussen zijn vertrouwensscore en zijn werkelijke nauwkeurigheid), en meet hoe die overschatting gerelateerd was aan de werkelijke prestaties van het model:

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

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

Correlatie tussen overschatting en werkelijke prestaties voor basis-, enkel-domein- en multi-domein gespecialiseerde modellen, waaruit blijkt dat DKE-effecten toenemen met toenemende specialisatie.

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

Tests toonden ook aan dat modellen geneigd zijn om meer oververzekerd te zijn in zeldzame programmeertalen. Over GitHub, IEEE en TIOBE-ranglijsten, correleert zeldzaamheid sterk met hogere waargenomen prestaties, met een piek van 0,797:

Correlatie tussen modeloververzekerdheid en taalzeldzaamheid, gebruikmakend van drie populariteitsranglijsten. Minder gebruikelijke talen zijn geassocieerd met hogere waargenomen prestaties.

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 merkbaar zwakker dan in de multiple-choice-vrageninstelling, waarschijnlijk vanwege de grotere moeilijkheid om vertrouwen en correctheid te beoordelen in open-eindtaken:

Correlatie tussen overschatting en werkelijke prestaties bij open-eindcodegeneratie, gebaseerd op MultiPL-E-resultaten over acht programmeertalen.

In het overwegen van de nog steeds betwiste verklaring voor het Dunning-Kruger-effect, concluderen de auteurs:

‘Een mogelijke verklaring die zowel voor mensen als voor AI-modellen kan gelden, 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 die vaardigheid.

‘Deze verklaring kan mogelijk experimenteel getest worden in AI-modellen met een gecontroleerde studie van verschillende trainingsstrategieën en of die allemaal leiden tot gelijktijdige verbeteringen in prestaties en in de mogelijkheid om de kwaliteit van prestaties te beoordelen. Echter, deze studie gaat verder dan de reikwijdte van dit artikel, en we laten het voor toekomstig onderzoek.’

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 neigen om dubbel zo hard te gaan in hun minst gunstige omstandigheden, d.w.z. door maximaal vertrouwen te tonen wanneer ze te maken hebben met de meest zeldzame of minst bekende talen – wat een vrijwel directe 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.

First published woensdag, 8 oktober 2025