Position, not importance: what a likelihood threshold actually defers on

In de wereld van softwareontwikkeling is kunstmatige intelligentie geëvolueerd van een hulpmiddel dat simpelweg vragen beantwoordt naar een partner die samen met mensen code schrijft. Deze digitale assistenten, vaak codingsagenten genoemd, observeren wat een programmeur typt en suggereren vervolgens de volgende paar regels code om het werk te versnellen. De centrale uitdaging voor deze systemen is weten wanneer ze moeten stoppen. Als de assistent te veel schrijft, kan hij een cruciale beslissing voor de programmeur nemen, zoals het kiezen van een beveiligingsinstelling of een databasecommando, waardoor hij effectief het toetsenbord overneemt voordat de mens de kans krijgt de keuze te beoordelen. Als hij te vroeg stopt, biedt hij weinig hulp. Lange tijd hoopten onderzoekers dat een computer zou kunnen leren herkennen op welk exact moment een mens moet ingrijpen door te meten hoe "verrast" de computer is door zijn eigen voorspellingen. De theorie was dat wanneer een model onzeker wordt over wat er volgt, dit waarschijnlijk komt omdat er een moeilijke of belangrijke beslissing wordt genomen, en dat dat het perfecte moment is om te pauzeren en om hulp te vragen.

Een recente studie zette zich uit om deze theorie te testen in de omgeving met hoge inzet van computerprogrammering. De onderzoekers bouwden een specifieke testomgeving die honderden korte codestukken bevatte, waarvan sommige gevaarlijke keuzes bevatten — zoals het open laten van een beveiligingsdeur of het gebruik van een zwakke wachtwoordmethode — en andere die slechts onschuldige, routineuze code waren. Ze pasten een regel toe die de computer vertelde om te blijven schrijven zolang hij zich zelfverzekerd voelde, en alleen te stoppen wanneer het cumulatieve vertrouwen onder een bepaalde lijn zakte. De hoop was dat deze regel vanzelf zou pauzeren vóór de gevaarlijke keuzes, waardoor de mens de kans kreeg om deze te beoordelen. De resultaten onthulden echter een schokkende discrepantie. De computer stopte niet omdat een keuze gevaarlijk was; de computer stopte omdat de tekst moeilijk te voorspellen werd. In de wereld van code zijn de meest gevaarlijke keuzes vaak de meest voorkomende en voorspelbare, terwijl de werkelijk verrassende tekst vaak gewoon willekeurige ruis is. Consequent schreef het systeem de gevaarlijke code vaak volledig uit, terwijl het abrupt stopte midden in onschuldige, saaie tekst.

De onderzoekers, onder leiding van Shubhanandan T Y en collega's van de Dayananda Sagar University, construeerden een gedetailleerde benchmark genaamd CEDE-Bench om precies te meten hoe vaak dit gebeurt. De test omvatte 112 specifieke scenario's waarbij een programmeur moet kiezen tussen een veilig pad en een riskant pad, zoals de beslissing of men een beveiligingscontrole uitschakelt of hoe men met een wachtwoord omgaat. Ze bevatten ook 12 onschuldige controlemiddelen die geen echte beslissingen bevatten, maar slechts standaard boilerplate-code. Toen ze de stopregel van de computer op deze items uitvoerden, waren de resultaten treffend. Bij de instelling die in een eerder gebruikersonderzoek werd gebruikt, schreef het systeem de gevaarlijke tak in 33 procent van de gevallen uit. In sommige gevallen voltooide het bijna een volledige SQL-databasequery die kwetsbaar was voor hacking, waarbij achttien van de negentien tokens werden geschreven voordat het stopte. Dit gebeurde niet omdat de computer het gevaar niet zag, maar omdat de gevaarlijke code precies was wat de computer verwachtte op basis van zijn trainingsdata.

De studie vond dat het gedrag van het systeem bijna volledig werd gedreven door waar de beslissing in de tekst verscheen, en niet door wat de beslissing was. Als een risicovolle keuze binnen de eerste paar woorden van een suggestie verscheen, schreef de computer deze bijna altijd uit. Als dezelfde risicovolle keuze later verscheen, nadat de computer al zijn "budget" aan zelfverzekerde woorden had verbruikt, stopte hij vóór het bereiken ervan. De onderzoekers ontdekten dat de regel minder werkt als een rechter die de belangrijkheid van een beslissing weegt, en meer als een eenvoudige token-teller. Het staat de computer toe een bepaald aantal woorden te schrijven op basis van hoe voorspelbaar de omliggende tekst is, en stopt dan. Omdat de gevaarlijke keuzes in code vaak zeer voorspelbaar zijn — zoals het gebruiken van een standaard maar onveilige functie — vallen zij binnen dit vroege venster en worden ze geschreven. Daarentegen is onschuldige tekst die willekeurig uitziende reekens bevat, zoals een nep API-sleutel, onvoorspelbaar en zorgt ervoor dat de computer vroeg stopt, zelfs als er geen gevaar is om door te gaan.

Deze bevinding daagt het idee uit dat een computer kan leren om af te wachten op menselijke tussenkomst door simpelweg zijn eigen onzekerheid te meten. De studie toonde aan dat het stoppunt van het systeem statistisch niet te onderscheiden was tussen gevaarlijke en onschuldige items. Het stopte net zo vaak midden in onschuldige boilerplate-code als vóór gevaarlijke code. De onderzoekers concludeerden dat de regel blind is voor belangrijkheid. Het weet niet dat een specifieke regel code een database kan verwijderen of een wachtwoord kan lekken; het weet alleen hoeveel woorden het heeft geschreven en hoe verrassend het volgende woord aanvoelt. Sterker nog, het systeem was eerder geneigd te stoppen op een onschuldig item met een willekeurig uitziende reeks, dan op een gevaarlijk item dat een veelvoorkomend, voorspelbaar patroon volgde. Dit betekent dat het afstemmen van de gevoeligheid van de regel het probleem niet kan oplossen; het laten stoppen eerder betekent dat de computer minder nuttige code schrijft, terwijl het laten stoppen later betekent dat hij meer gevaarlijke code schrijft.

De implicaties van deze ontdekking zijn aanzienlijk voor hoe we AI-assistenten bouwen en vertrouwen. De studie suggereert dat het vertrouwen op de eigen zekerheid van een model om te beslissen wanneer de controle terug aan een mens wordt gegeven, een gebrekkige strategie is in computerprogrammering. Het systeem draagt de controle niet over aan de mens omdat de input van de mens nodig is voor een kritieke beslissing; het draagt de controle over omdat de tekst wiskundig moeilijk te voorspellen is geworden. De onderzoekers merkten op dat in hun tests het systeem slechts ongeveer een derde van de onschuldige boilerplate-code voltooide voordat het stopte, wat betekent dat het de programmeur regelmatig zonder goede reden onderbrak. Tegelijkertijd faalde het te pauzeren voor de meest gevaarlijke beslissingen, die vaak de meest routinematige en verwachte waren. Dit creëert een situatie waarin de assistent ofwel te indringend, ofwel te riskant is, zonder een middenweg die zowel veiligheid als bruikbaarheid bevredigt.

Uiteindelijk betoogt het artikel dat de mechaniek achter deze AI-assistenten een fundamentele heroverweging behoeft. De huidige aanpak, die ervan uitgaat dat onzekerheid gelijkstaat aan belangrijkheid, houdt geen stand in de echte wereld van softwareontwikkeling. De onderzoekers stellen voor dat we, in plaats van te proberen het model te leren belangrijkheid te herkennen via onzekerheid, eenvoudiger en directere methoden moeten gebruiken om gevaarlijke patronen te vangen, zoals statische code-checkers die zoeken naar bekende beveiligingsfouten. Deze tools hoeven niet te raden wanneer ze moeten stoppen; ze kunnen simpelweg risicovolle patronen signaleren, ongeacht hoe zelfverzekerd de AI zich voelt. De studie dient als een duidelijke waarschuwing dat hoewel AI-assistenten behulpzaam kunnen zijn, hun vermogen om te weten wanneer ze moeten stoppen geen teken is van wijsheid of veiligheid, maar slechts een reflectie van hoe voorspelbaar de tekst toevallig is. Totdat de technologie het onderscheid kan maken tussen een saaie routine en een kritieke beslissing, blijft het vertrouwen erop om die onderscheiden zelfstandig te maken een gok.