Measuring LLM Trust Allocation Across Conflicting Software Artifacts

Probleemstelling

Large Language Models (LLMs) worden steeds vaker ingezet voor software-engineering taken zoals het genereren van tests, het aanbrengen van patches en code-review. Een kritiek probleem is echter dat deze modellen niet alleen falen door het produceren van incorrecte output, maar vooral door het verkeerd toewijzen van vertrouwen aan verschillende software-artifacten wanneer deze met elkaar in conflict zijn.

In de praktijk moeten modellen redeneren over bundels van heterogene bronnen: broncode (implementatie), methodesignaturen, documentatie (Javadoc) en testvoorvoegsels. Deze bronnen kunnen incompleet, verouderd of onderling inconsistent zijn. Bestaande evaluaties focussen voornamelijk op de downstream uitkomst (bijv. is de gegenereerde test correct?), waardoor ze niet kunnen vaststellen of het model:

1. De kwaliteit van de inputbronnen heeft herkend.
2. De onbetrouwbare bron heeft geïdentificeerd.
3. Het vertrouwen over de verschillende bronnen correct heeft gekalibreerd.

Het paper stelt dat huidige workflows een expliciet mechanisme missen voor trust reasoning op artifact-niveau voordat beslissingen worden genomen.

Methodologie: Het TRACE Framework

De auteurs introduceren TRACE (Trust Reasoning over Artifacts for Calibrated Evaluation), een framework dat trust reasoning als een eerste-class output behandelt in plaats van het indirect af te leiden uit de uiteindelijke taakuitkomst.

1. Opzet en Data:

• Dataset: Gebaseerd op 456 zorgvuldig gecureerde Java-method bundles uit 25 real-world systemen.
• Perturbaties: Voor elke basis-sample zijn zes varianten gegenereerd met gecontroleerde degradaties:
  • Verwijdering van Javadoc-onderdelen (beschrijving, @return, of beide).
  • Injectie van bugs in de Javadoc (verkeerde gedrag/params).
  • Injectie van bugs in de MUT (Method Under Test) logica.
  • Creatie van contradicties tussen Javadoc en MUT.
  • Deze perturbaties variëren in ernst: Heavy (expliciet), Normal (plausibel defect), en Subtle (moeilijk te detecteren afwijking).
• Modellen: Zeven LLMs werden getest (o.a. Claude 4.6, GPT-4o/5.2, DeepSeek-V3.2, Grok-4) onder een "blind" protocol waarbij het model niet wist welke samples gemanipuleerd waren.

2. Trace Structuur:
TRACE vraagt het model om gestructureerde JSON-traces te genereren die drie componenten bevatten:

• Kwaliteitsbeoordeling: Een score (0-1) voor elk artifact (Javadoc, Signature, MUT, Test Prefix) en een totale bundel-score.
• Inconsistentie-analyse: Detectie van conflicten, toewijzing van de fout aan een specifiek artifact, en een natuurlijke taalbeschrijving van de mismatch.
• Prioritering: Een rangschikking van de bronnen gebaseerd op betrouwbaarheid.

Kernresultaten

De studie analyseerde 22.339 geldige traces en beantwoordde drie onderzoeksvragen (RQs):

RQ1: Gevoeligheid voor inputkwaliteit

• Modellen reageren proportioneel op degradatie: scores dalen naarmate de ernst van de fout toeneemt.
• Asymmetrie: Puntenverlies is sterk gelokaliseerd bij het gemanipuleerde artifact.
• Documentatie vs. Code: Modellen reageren veel scherper op fouten in de documentatie dan op fouten in de code. De kloof tussen "heavy" en "subtle" fouten is aanzienlijk groter voor Javadoc (0.152–0.253) dan voor MUT-bugs (0.049–0.123).

RQ2: Detectie van Javadoc-MUT inconsistenties

• Documentatie-fouten: Modellen detecteren expliciete fouten in de documentatie zeer goed (67–94%).
• Blind Vlek (Blind Spot): Er is een systematisch falen wanneer alleen de implementatie (MUT) afwijkt terwijl de documentatie plausibel blijft. In dit scenario daalt de detectie met 21–43 procentpunten ten opzichte van wanneer beide bronnen fouten bevatten.
• Kalibratie: Het vertrouwen (confidence score) is slecht gekalibreerd voor 6 van de 7 modellen; een hoge confidence betekent niet noodzakelijk een correcte detectie.

RQ3: Semantisch codebegrip als drijvende kracht

• De variatie in prestaties tussen modellen wordt grotendeels verklaard door hun vermogen tot semantisch codebegrip.
• Modellen zoals Sonnet, DS-V3.2 en Haiku blijven robuust bij subtiele fouten en tonen dieper cross-artifact redeneren.
• Modellen zoals GPT-4o vallen sterk terug bij subtiele fouten (daling van 44 pp), wat wijst op een afhankelijkheid van oppervlakkige, lexische cues in plaats van diepgaande semantische analyse.
• Opus is goed in het beschrijven van gevonden fouten, maar faalt vaak bij het lokaliseren van welke artifact precies de fout bevat.

Belangrijkste Bijdragen

1. Formalisatie van Trust Reasoning: TRACE formaliseert het toewijzen van vertrouwen aan software-artifacten als een expliciete, meetbare taak.
2. Gecreëerde Benchmark: Een uniek, geannoteerd benchmark van 456 Java-methoden met gecontroleerde, zware, normale en subtiele degradaties en contradicties.
3. Grootschalige Analyse: Een cross-model studie die aantoont dat huidige LLMs beter zijn in het auditen van natuurlijke taal-specificaties dan in het detecteren van subtiele code-drift.
4. Interpretabele Limitaties: Het paper koppelt prestatieverschillen direct aan het vermogen tot semantisch codebegrip, wat inzicht geeft in waarom bepaalde modellen falen.

Betekenis en Praktische Implicaties

De bevindingen hebben directe gevolgen voor het gebruik van LLMs in software-engineering workflows:

• Rol als Documentatie-Auditor: LLMs zijn betrouwbaar om verouderde of incorrecte Javadoc te detecteren ten opzichte van een vertrouwde implementatie. Ze kunnen dienen als eerste filter in CI/CD-pipelines.
• Beperking bij Code-Drift: LLMs zijn niet betrouwbaar als autonome detectoren voor code-wijzigingen die niet worden bijgewerkt in de documentatie. De "MUT_Only blind spot" betekent dat stilzwijgende fouten vaak onopgemerkt blijven.
• Geen Vertrouwen op Confidence Scores: Omdat confidence scores slecht gekalibreerd zijn, mogen ze niet worden gebruikt als automatische gatekeeper zonder per-model herkalibratie.
• Modelkeuze:
  • Voor het detecteren van subtiele contradicties: Sonnet, DS-V3.2 of Haiku.
  • Voor het uitleggen van gevonden fouten: Opus.
  • Voor vertrouwen in confidence scores: DeepSeek-V3.2-Speciale (de enige met significante kalibratie).

Concluderend stelt het paper dat LLMs momenteel beter geschikt zijn als auditors van specificaties dan als autonome detectoren van code-fouten. Voor kritieke downstream-taken is een expliciete, artifact-bewuste trust-reasoning stap noodzakelijk voordat beslissingen worden genomen.