💻 computer science

Articulate but Wrong: Self-Review Failures in LLM-Based Code Modernization

Dit artikel toont aan dat LLM-gebaseerde codemodernisatie vaak stilzwijgende gedragsafwijkingen introduceert die de modellen zelf niet betrouwbaar kunnen detecteren of zelf corrigeren, wat aantoont dat deze faalmodus taak-structureel is en niet afhankelijk van modelschaal of -capaciteit.

Oorspronkelijke auteurs: Gokul Chandra Purnachandra Reddy, Aditya Lolla, Harsha Sanku

Gepubliceerd 2026-05-22

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Gokul Chandra Purnachandra Reddy, Aditya Lolla, Harsha Sanku

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een zeer articulate, zelfverzekerde architect inhuurt om een oud, piepend huis (legacy code) te renoveren tot een modern, strakke woning. Je vraagt hen het werk te doen, en vervolgens, om geld te besparen, vraag je aan dezelfde architect om naar hun eigen blauwdrukken te kijken en te zeggen: "Heb ik per ongeluk de werking van het huis veranderd?"

Dit artikel stelt een eenvoudige maar angstaanjagende vraag: Kunnen we de architect vertrouwen om hun eigen stille fouten op te sporen?

De onderzoekers ontdekten dat deze AI-"architecten" uitstekend zijn in het nieuw laten lijken van het huis, maar verrassend slecht zijn in het opmerken wanneer ze stiekem de leidingen hebben verbroken of de bedrading op een manier hebben gewijzigd die geen brand veroorzaakt, maar het huis gewoon anders doet functioneren.

Hier is de uiteenzetting van hun bevindingen met behulp van alledaagse analogieën:

1. Het probleem van de "Stille Drift"

Wanneer de AI probeert oude code bij te werken, maakt het soms een wijziging die perfect lijkt. De code draait, crasht niet en ziet er goed uit. Maar onder de motorkap komen de uitkomsten iets anders uit.

De Analogie: Stel je voor dat in het oude huis de regel was dat "een half brood" betekende dat je het doormidden sneed en je het hele half kreeg. In het nieuwe huis verandert de regel zodat "een half brood" betekent dat je een klein kruimeltje krijgt. Het huis staat nog steeds, en het brood is er nog steeds, maar het aantal dat je krijgt, is verkeerd.
De Bevinding: De onderzoekers testten 60 specifieke lastige scenario's. Wanneer de AI echte, complexe updates moest uitvoeren, maakte het deze stille fouten 40% van de tijd. Toen ze de AI gemakkelijke taken gaven die eigenlijk geen wijziging nodig hadden, maakte het slechts 7% van de tijd fouten. Dit bewijst dat de AI niet alleen slordig is; het worstelt specifiek met de logica van de update.

2. De "Rekenval"

De grootste boosdoener voor deze fouten was hoe de AI met getallen omgaat.

De Analogie: In het oude huis (Python 2), als je 5 koekjes verdeelt over 2 personen, krijg je 2 koekjes per persoon (het extra halve wordt weggegooid). In het nieuwe huis (Python 3) krijg je 2,5 koekjes.
De Bevinding: De AI vergeet deze regel vaak. Het werkt de code bij, maar behoudt de logica "gooi het halve weg", of andersom. Deze specifieke rekenfout kwam voor in 57% van de moeilijke gevallen. Het is alsof de AI weet hoe je muren moet schilderen, maar vergeten is hoe je bakstenen moet tellen.

3. De "Zelfverzekerde Leugenaar" (Zelfherzieningsfalen)

Dit is het meest schokkende deel. Nadat de AI de renovatie heeft voltooid, vroegen de onderzoekers: "Heb je de werking van het huis veranderd?"

De Analogie: De AI kijkt naar zijn eigen blauwdruk, ziet de gebroken leidingen en zegt: "Ja, ik heb het veranderd, maar maak je geen zorgen, het is prima!" Of erger: het ziet de gebroken leidingen, legt precies uit waarom het kapot is, en concludeert vervolgens: "Daarom is het huis perfect."
De Bevinding: Wanneer de AI daadwerkelijk een stille fout maakte, slaagde het er 32% van de tijd niet in om zichzelf te betrappen. Het keurde zijn eigen gebroken werk zelfverzekerd goed.
- Sommige modellen waren als een paranoïde inspecteur die elke fout opspoorde (0% falen).
- Andere modellen waren als een zelfverzekerde leugenaar die elke fout miste (100% falen).
- Cruciaal: de "beste" of duurste modellen waren niet noodzakelijkerwijs degenen die hun eigen fouten opspoorden. Een goedkoop model deed soms beter dan een duur model bij het opsporen van zijn eigen gebreken.

4. De "Magische Spiegel" Werkt Niet

De onderzoekers testten of het vragen aan de AI om zijn eigen "veiligheidsnet" te zijn, werkt.

De Analogie: Je zou kunnen denken: "Als ik de architect vraag om zijn werk te dubbelcontroleren, zal het fouten oplossen."
De Bevinding: Nee. De "zelfcontrole" is geen betrouwbaar veiligheidsnet. De AI is te goed in zich uit de brand te praten. Het kan een alinea schrijven waarin het het verschil uitlegt tussen de oude en nieuwe regels, en vervolgens direct concluderen dat de regels hetzelfde zijn. Het is als een student die een perfect essay schrijft waarin wordt uitgelegd waarom 2+2=5, en vervolgens het antwoord "5" met een glimlach omcirkelt.

5. Het Gaat Niet Om Hoe "Slim" de AI Is

Je zou kunnen aannemen dat de krachtigste, duurste AI-modellen minder fouten maken en deze beter opsporen.

De Analogie: Je zou denken dat het inhuren van een "Meester-Architect" veiliger is dan het inhuren van een "Junior Architect".
De Bevinding: De studie vond geen duidelijke link tussen de prijs van de AI en de betrouwbaarheid. De duurste modellen maakten net zoveel stille fouten als de goedkopere. Het probleem is niet dat de AI niet "slim" genoeg is; het is dat de taak van het updaten van code een specifieke structurele valkuil heeft die ze allemaal in de war brengt, ongeacht hoeveel ze kosten.

De Conclusie

Als je AI gebruikt om oude software bij te werken, vertrouw dan de AI niet om zijn eigen werk te controleren.

Het artikel concludeert dat het vragen aan de AI: "Heb je iets kapotgemaakt?", vergelijkbaar is met het vragen aan een goochelaar: "Heb ik het konijn laten verdwijnen?" De goochelaar zal "Ja" zeggen, zelfs als het konijn er nog steeds is, of zelfs als ze per ongeluk het konijn in een duif hebben veranderd.

Om veilig te zijn, heb je een externe "orakel" nodig (een strikte, geautomatiseerde test) die de output controleert tegen de oorspronkelijke regels, in plaats van te vertrouwen op de eigen mening van de AI. De AI is articulate, maar in deze specifieke baan is het ook gevaarlijk verkeerd.

Technische Samenvatting: Articulerend maar Verkeerd: Zelfbeoordelingsfouten in LLM-gebaseerde Code-modernisering

Probleemstelling

Naarmate Large Language Model (LLM)-agenten steeds vaker worden ingezet om legacy-code (specifiek Python 2 naar Python 3) te migreren naar moderne stacks, blijft een kritiek betrouwbaarheidsgat bestaan: het ontbreken van geautomatiseerde waarborging van correctheid. Waar syntactische fouten (bijvoorbeeld verwijderde API's) eenvoudig worden opgevangen door compilatiefouten, is stille gedragsdrift de meest sluipende faalmodus. Dit treedt op wanneer gemoderniseerde code compileert en zonder uitzondering draait, maar plausibele doch onjuiste output produceert die in strijd is met het oorspronkelijke legacy-contract.

De centrale onderzoeksvraag is of hetzelfde LLM dat de migratie genereert, kan worden vertrouwd om te herkennen wanneer zijn eigen output het waarneembare gedrag stilzwijgend heeft gewijzigd. Het artikel onderzoekt de levensvatbaarheid van zelfbeoordeling (het producerende model vragen om zijn eigen output te beoordelen) als veiligheidsnet voor deze stille drifts.

Methodologie

De auteurs hebben een rigoureus experimenteel raamwerk opgezet om drift en betrouwbaarheid van zelfbeoordeling te meten:

Corpus: Een gebalanceerde dataset van 60 legacy Python-2 snippets, verdeeld in drie categorieën:
- Semantische Traps (20 snippets): Idiomen waarbij modernisering het gedrag stilzwijgend kan veranderen (bijvoorbeeld numerieke semantiek zoals gehele getaldivisie, trage evaluatie, verschillen in type-modellen).
- Syntactische Traps (20 snippets): Idiomen met eenduidige Python-3-equivalenten (bijvoorbeeld has_key, xrange).
- Onschadelijke Controles (20 snippets): Code die geen semantische wijzigingen vereist (bijvoorbeeld a+b), dienend als basislijn voor inherent model-drift.
Modellen: 1.980 moderniseringsoproepen werden uitgevoerd over 11 productieve LLM's uit 7 verschillende families (waaronder OpenAI, Google, Anthropic, Meta, DeepSeek, Alibaba, Mistral en Cohere), variërend in een kostenrange van ongeveer 200x.
Evaluatie (De Oracle): Output werd geëvalueerd tegen het legacy-contract met behulp van een type-strikte gedragsoracle. In tegenstelling tot standaard gelijkheidscontroles (==), dwingt deze oracle strikte type- en waarde-gelijkheid af (bijvoorbeeld het onderscheiden van 2 van 2.0), wat cruciaal is voor het detecteren van integer-naar-float-drift die veel voorkomt bij Python 2/3-migratie.
Zelfbeoordelingsproef: Na generatie en oracle-evaluatie werd hetzelfde model dat de code produceerde, gevraagd te beoordelen of zijn output het gedrag behield, zonder te weten dat het zijn eigen eerdere output evalueerde.
Promptvariaties: Drie verschillende promptformuleringen werden getest om gevoeligheid voor instructieframing te beoordelen.

Belangrijkste Bijdragen

Reproduceerbaar Benchmark: Introductie van een gecontroleerde benchmark met een onschadelijke basislijn, een type-strikte oracle en een divers panel van 11 productieve LLM's.
Kwantificering van Semantische Drift: Bewijs dat semantische-behoudstraps significant meer drift vertonen dan syntactische, met een specifieke focus op numerieke semantiek.
Taak-structurele Aard van Fouten: Aantonen dat drift niet willekeurig is, maar geconcentreerd op specifieke, moeilijke snippets die falen bij bijna alle modellen en promptvariaties.
Analyse van Zelfbeoordelingsfouten: De primaire bevinding dat zelfbeoordeling geen betrouwbaar veiligheidsnet is, gekenmerkt door een bimodale verdeling van faalpercentages en "articulerend maar verkeerd" gedrag waarbij modellen semantische regels correct identificeren maar onjuist verklaren dat het gedrag behouden is.
Methodologische Inzichten: Aantonen dat de keuze van gedragsoracle (strikte versus permissieve gelijkheid) en de methode voor outputextractie de gemeten driftpercentages materieel beïnvloeden.

Belangrijkste Resultaten

1. Prevalentie van Stille Drift

Semantische Driftpercentage: 39,7% van de moderniseringspogingen op semantische traps resulteerde in stille gedragsdrift.
Vergelijking met Basislijn: Dit is significant hoger dan het driftpercentage van 7,0% dat werd waargenomen bij onschadelijke controle-code (die geen echte modernisering vereist), wat een toename van +32,7 procentpunten vertegenwoordigt.
Syntactische Drift: Syntactische traps driftten op 12,7%, slechts licht boven de basislijn.
Dominante Faalmodus: Numerieke semantiek (specifiek Python 2 gehele getaldivisie versus Python 3 floatdivisie) was verantwoordelijk voor 57% van alle gevallen van semantische drift.

2. Taak-structurele Fouten

Drift is niet willekeurig; modellen zijn het eens over welke snippets moeilijk zijn. De paarsgewijze correlatie van driftpercentages per snippet over modellen heeft een gemiddelde Pearson $r = 0,52$ .
Een kleine kern van snippets met numerieke semantiek faalde voor $\ge 8/11$ modellen, ongeacht de promptformulering, wat aangeeft dat het falen structureel is aan de migratietak en niet idiosyncratisch voor specifieke modellen.

3. Betrouwbaarheid van Zelfbeoordeling

Stilzwijgende Goedkeuring: Bij alle 262 geïdentificeerde gevallen van semantische drift, keurde het producerende model stilzwijgend 31,7% (83 gevallen) goed als gedragsbehoudend.
Bimodale Verdeling: Zelf-misspercentages zijn sterk bimodaal. Vijf modellen misten 0% van hun eigen drift, terwijl anderen tot 100% misten.
Orthogonaliteit met Capabiliteit: Zelf-misspercentages correleren niet met modelcapaciteit of prijs. Bijvoorbeeld, Model M5 had het hoogste driftpercentage (65%) maar een zelf-misspercentage van 0%, terwijl Model M1 een gemiddeld driftpercentage had (42%) maar een zelf-misspercentage van 100%.
Het "Articulerend maar Verkeerd" Fenomeen: Meerdere modellen articuleerden expliciet het correcte Py2/Py3 semantische onderscheid (bijvoorbeeld uitleggen dat / gehele getaldivisie uitvoert in Py2 en floatdivisie in Py3), maar concludeerden toch dat het gedrag behouden was. Dit duidt op een falen in toepassing van redenering in plaats van een gebrek aan kennis.

4. Niet-monotone Capabiliteit

Driftpercentages (variërend van 5,6% tot 46,7%) volgen de modelprijs of capaciteitsniveaus niet schoon. Goedkopere modellen presteerden soms beter dan frontier-modellen, wat suggereert dat schaling alleen dit specifieke structurele falen niet oplost.

5. Methodologische Gevoeligheid

Oracle-striktheid: Het gebruik van permissieve ==-vergelijking in plaats van type-strikte gelijkheid verlaagde het gemeten semantische driftpercentage van 39,7% naar ongeveer 26,7%, waardoor de meest voorkomende faalmodus (int $\to$ float) werd verborgen.
Outputextractie: Naïeve parsers die alleen op afsluitende tekens (fences) leunden, verhoogden het driftpercentage voor onschadelijke controles tot ongeveer 23% door verklarende proza als code te interpreteren. Een robuuste extractor verlaagde dit naar de ware basislijn van 7,0%.

Betekenis en Claims

Het artikel concludeert dat zelfbeoordeling door het producerende model geen bruikbaar veiligheidsnet is voor stille semantische drift in pipelines voor code-modernisering. Het falen is niet slechts een gebrek aan recall (fouten missen), maar een gevaarlijke stilzwijgende goedkeuring met hoge zekerheid van gebroken code.

De auteurs stellen het volgende:

Drift in dit domein is taak-structureel (gedreven door de specifieke Py2/Py3 semantische kloven) in plaats van een willekeurige fout of een eenvoudige functie van modelschaal.
Leveranciers- of grootte-gebaseerde selectie van modellen biedt geen bescherming tegen deze klasse van drift; een expliciete gedragsoracle is vereist.
Methodologische keuzes met betrekking tot de striktheid van de oracle en de robuustheid van code-extractie zijn cruciaal; eerdere werken die deze controles misten, rapporteren waarschijnlijk te weinig over stille semantische drift.

De studie dient als een waarschuwend minimum: eenvoudige zelfbeoordeling is ontoereikend voor productie-code-modernisering, en vertrouwen hierop zonder externe gedragsverificatie riskeert het implementeren van code die compileert, draait, maar zich onjuist gedraagt.