Algoritmeaversie: waarom een AI-fout meer schade doet dan tien menselijke fouten

In 2015 publiceerden Berkeley Dietvorst, Joseph Simmons en Cade Massey van Wharton een experiment dat een ongemakkelijke waarheid blootlegde. Ze lieten proefpersonen kiezen tussen een menselijke voorspeller en een algoritme. Zodra het algoritme een zichtbare fout maakte, schakelden de meeste deelnemers terug naar de mens. Ook als de mens aantoonbaar vaker fout zat.

Ze noemden het algorithm aversion. Het mechanisme is simpel en genadeloos: mensen verwachten van algoritmes dat ze perfect zijn. Van mensen verwachten ze dat niet. Eén fout van een AI weegt zwaarder dan tien fouten van een collega.

Het asymmetrische vertrouwensmodel

Glikson en Woolley bevestigden dit in 2020 in hun meta-analyse in Academy of Management Annals. Vertrouwen in AI bouwt langzaam op en stort snel in. Bij mensen is het omgekeerd: initieel vertrouwen is hoog en daalt geleidelijk bij herhaalde fouten.

Dit creëert een asymmetrie die elk AI-product moet overleven.

Vertrouwen
  |
  |  Mens: ~~~~~~~~\___         
  |                    \____     
  |                         \__ 
  |  AI:   .....----*            
  |              1 fout \        
  |                      \_____ 
  +-------------------------------- Tijd
         opbouw    fout   herstel

Wat Dietvorst in 2018 ontdekte

Drie jaar na hun eerste paper publiceerden Dietvorst en collega's een vervolgstudie in Management Science. De vraag: hoe voorkom je algoritmeaversie? Hun antwoord was verrassend pragmatisch.

Laat gebruikers de output aanpassen. Niet het algoritme vervangen, niet de fout verbergen, maar de gebruiker de mogelijkheid geven om het resultaat te wijzigen. In hun experimenten bleef het vertrouwen in het algoritme significant hoger wanneer deelnemers een kleine aanpassing mochten maken, zelfs als ze die aanpassing zelden gebruikten.

Het gaat niet om controle. Het gaat om het gevoel van controle. De wetenschap dat je kunt ingrijpen als het nodig is, is genoeg om algoritmeaversie te voorkomen.

Wat dit betekent voor AI in werkplatforms

Een AI-assistent die taken aanmaakt, prioriteiten voorstelt of deadlines inschat, opereert in het domein van algoritmeaversie. Elke verkeerd ingeschatte prioriteit, elke taak die aan de verkeerde persoon wordt toegewezen, elke deadline die niet klopt, is een potentieel kantelpunt.

De oplossing is niet om de AI beter te maken. De oplossing is om de interactie zo te ontwerpen dat fouten corrigeerbaar zijn. Concreet betekent dit drie dingen.

Ten eerste: AI-acties zijn altijd zichtbaar. Niet verborgen in logs, maar prominent in een activiteitenfeed waar iedereen kan zien wat de AI heeft gedaan. Transparantie is de basis van vertrouwen.

Ten tweede: AI-acties zijn altijd bewerkbaar. Een taak die de AI aanmaakt, kan met een klik worden aangepast. Een prioriteit die niet klopt, kan direct worden gewijzigd. De drempel om te corrigeren moet lager zijn dan de drempel om te klagen.

Ten derde: AI-acties worden geattribueerd. Het verschil tussen een taak aangemaakt door Claude via MCP en een taak aangemaakt door een teamlid is zichtbaar. Niet als waarschuwing, maar als context. Zodat de gebruiker weet wat er is gebeurd en kan beslissen of het klopt.

De paradox van perfectie

De ironie van algoritmeaversie is dat het juist de beste AI-systemen het hardst treft. Hoe beter een AI presteert, hoe hoger de verwachtingen, hoe groter de teleurstelling bij een fout.

De uitweg is niet perfectie nastreven. De uitweg is de relatie tussen mens en AI zo ontwerpen dat fouten een normaal onderdeel zijn van de samenwerking. Zoals fouten van collega's normaal zijn. Niet door fouten te verbergen, maar door ze corrigeerbaar, zichtbaar en begrijpelijk te maken.

Dat is geen UI-beslissing. Dat is een architectuurbeslissing die je aan het begin maakt, niet achteraf.