🤖 AI

TRIM: Reducing AI-Generated CodeSlop via Agent Trajectory Minimization

Dit artikel introduceert TRIM, een algoritme dat "CodeSlop" vermindert — de accumulatie van overbodige bewerkingen in door AI gegenereerde code veroorzaakt door talrijke agent-zoektrajecten — door deze trajecten te minimaliseren, waardoor de redundantie met 17,9%–32,9% wordt verminderd met een verwaarloosbare prestatieregressie en de helft van de validatiekosten van bestaande baselines.

Oorspronkelijke auteurs: Alex Mathai, Shobini Iyer, Aleksandr Nogikh, Petros Maniatis, Franjo Ivancic, Junfeng Yang, Baishakhi Ray

Gepubliceerd 2026-07-21

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Alex Mathai, Shobini Iyer, Aleksandr Nogikh, Petros Maniatis, Franjo Ivancic, Junfeng Yang, Baishakhi Ray

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 een wereld voor waarin robots worden ingehuurd om kapotte dingen te repareren, van lekkende leidingen tot haperende computerprogramma's. Deze robots, bekend als "AI coding agents", worden ongelooflijk goed in hun werk. Ze kunnen code lezen, ontdekken wat er mis is en nieuwe code schrijven om het op te lossen, vaak zonder dat een mens hun hand hoeft vast te houden. Maar er is een addertje onder het gras: hoewel deze robots geweldig zijn in het vinden van de oplossing, zijn ze verschrikkelijk in opruimen. Wanneer ze een probleem oplossen, laten ze vaak een rommelig spoor achter van "wat als"-experimenten, half afgemaakte ideeën en tijdelijke wijzigingen die eigenlijk niet nodig zijn. Het is alsof een chef-kok uiteindelijk de perfecte biefstuk bereidt, maar de keuken achterlaat bedekt met bloem, eierschalen en verbrand brood van alle gerechten die hij onderweg heeft geprobeerd en weggegooid. Deze rommel maakt het eindresultaat moeilijker voor mensen om te begrijpen, te beoordelen en veilig te houden. De grote vraag voor wetenschappers is: hoe krijgen we deze robots om hun eigen rommel op te ruimen voordat ze het eindproduct overhandigen?

Dit artikel introduceert een nieuw probleem genaamd CODESLOP. Denk aan CODESLOP als het digitale equivalent van die rommelige keuken. Het is de extra, onnodige code die AI-agents achterlaten nadat ze succesvol een bug hebben opgelost. De auteurs ontdekten dat deze agents niet stoppen wanneer ze een werkende oplossing hebben gevonden; ze houden alle "speculatieve bewerkingen" en verlaten hypothesen die ze gebruikten om daar te komen vast. Na verloop van tijd, als we deze rommelige patches laten opstapelen, wordt onze software opgeblazen, verwarrend en moeilijker te onderhouden, zelfs als het technisch gezien wel werkt.

Om dit op te lossen, ontwikkelden de onderzoekers een slimme tool genaamd TRIM (Trajectory-guided Redundancy Identification and Minimization). In plaats van de AI te vragen om "harder te proberen" om vanaf nul een schone patch te schrijven, kijkt TRIM naar het "dagboek" van hoe de robot het probleem heeft opgelost. Het volgt de stappen van de robot — de "trajectorie" — om te zien welke wijzigingen slechts deel uitmaakten van de exploratie en welke de daadwerkelijke fix waren. Vervolgens treedt het op als een super-efficiënte redacteur, die de onnodige delen eruit snijdt terwijl het er wel voor zorgt dat de fix nog steeds werkt.

De resultaten zijn behoorlijk indrukwekkend. Het team heeft TRIM getest op vier verschillende soorten AI-coding agents. Ze ontdekten dat TRIM tussen de 17,9% en 32,9% van de onnodige code (de CODESLOP) kon verwijderen zonder de fix te breken. Sterker nog, bij sommige bugs slaagde TRIM erin de patch van de AI zo ver terug te brengen dat deze er precies uitzag als de patch die een menselijke ontwikkelaar zou hebben geschreven.

Wat echt cool is aan de werkwijze van TRIM, is hoe het het doet. In plaats van willekeurig te gokken welke delen verwijderd moeten worden (wat traag en riskant is), gebruikt het de volgorde van de stappen van de robot om slimme gokken te maken. Het probeert eerst grote brokken van het "experimenteren" van de robot te verwijderen, en alleen als die de fix niet breken, gaat het over naar kleinere stukjes. Dit maakt TRIM ongeveer 1,9 keer sneller en goedkoper in gebruik dan oudere methoden die proberen code te minimaliseren via brute force. Het artikel suggereert dat deze aanpak veel betrouwbaarder is dan de AI simpelweg vragen om "je eigen code korter te herschrijven", wat er vaak toe leidt dat de AI fouten maakt of nóg grotere rommel creëert.

Kortom, dit artikel laat zien dat we AI-agents niet zomaar op hun gemak kunnen vertrouwen om netjes te zijn. Maar door een tool als TRIM te gebruiken om naar hun werkproces te kijken en het overtollige weg te snijden, krijgen we het beste van twee werelden: de snelheid van AI en de schone, onderhoudbare code die mensen nodig hebben. De auteurs hebben deze resultaten gemeten over duizenden echte reparatiepogingen in de praktijk, wat suggereert dat dit een praktische manier is om te voorkomen dat onze software in de toekomst een opgeblazen, verwarrende bende wordt.

Technische Samenvatting: TRIM - Vermindering van AI-gegenereerde CODESLOP via Agent Traject-minimalisatie

1. Probleemdefinitie: CODESLOP

Het artikel identificeert een groeiend probleem in AI-ondersteunde software engineering: hoewel programmeeragents erin slagen patches te genereren die tests doorstaan, bevat de resulterende code vaak aanzienlijke hoeveelheden onnodige wijzigingen. De auteurs noemen dit fenomeen CODESLOP.

Definitie: CODESLOP wordt gedefinieerd als verwijderbare functionele redundantie. In tegen tegenstelling tot traditionele statische definities van code slop (bijv. verbositeit, duplicatie of structurele complexiteit), is CODESLOP een gedragsmatige definitie. Het bestaat uit wijzigingen die tijdens het zoekproces van een agent zijn geïntroduceerd en die strikt genomen niet noodzakelijk zijn voor de patch om aan de correctievoorwaarden van de taak te voldoen.
Oorzaak: De auteurs stellen dat CODESLOP voortkomt uit het iteratieve herstelpad (repair trajectory) van de agent. Terwijl agents hypothesen verkennen, accumuleren ze speculatieve edities, verworpen ideeën en tijdelijke wijzigingen. Zodra een werkende oplossing is gevonden, behoudt de agent deze artefacten meestal omdat het een gebrek heeft aan een prikkel of mechanisme om ze te verwijderen.
Impact: Deze accumulatie vergroot de patchgrootte, begraaft essentiële fixes onder exploratieve ruis en verhoogt aanzienlijk de cognitieve belasting voor menselijke reviewers. Na verloop van tijd leidt dit tot codebases die redundantie sneller accumuleren dan ze kunnen worden opgeschoond, wat leidt tot een staat die moeilijker te onderhouden is.

2. Methodologie: Het TRIM-algoritme

Om CODESLOP aan te pakken, stellen de auteurs TRIM voor (Trajectory-guided Redundancy Identification and Minimization). In plaats van de uiteindelijke patch te behandelen als een ongestructureerde verzameling wijzigingen, maakt TRIM gebruik van het herstelpad van de agent om een hiërarchische contrafactische zoektocht te sturen.

Kerninzicht

Het herstelpad biedt een natuurlijke hiërarchie van afhankelijkheden. Edities die worden gemaakt tussen feedbackverzoeken (edit sequences) vertegenwoordigen vaak een enkele hypothese. Door de temporele ordening van deze edities uit te buiten, kan TRIM grote groepen gerelateerde wijzigingen elimineren voordat het wordt verfijnd naar individuele edities, wat de zoekruimte drastisch verkleint in vergelijking met traditionele minimalisatietechnieken.

Algoritmische Workflow

TRIM werkt in drie hoofdfasen:

Constructie van de traject-gestuurde zoekruimte:
- De ruwe executie-traject wordt geprojecteerd in een gereduceerde representatie ( $Traj_R$ ), waarbij alleen Edit Sequences ( $E$ ) (groepen edities tussen feedbackverzoeken) en Feedback Requests ($FR$) (testuitvoeringen) worden behouden.
- Irrelevante acties (bestandinspectie, navigatie) worden weggegooid.
- Het systeem reconstrueert de uiteindelijke patch door het traject te herafspelen, waarbij edities en undo-operaties worden toegepast om de specifieke wijzigingen te isoleren die in de uiteindelijke patch zijn overgebleven.
Hiërarchische Contrafactische Zoektocht:
TRIM voert een zoektocht van grof naar fijn uit om onnodige edities te identificeren en te verwijderen, terwijl het vermogen van de patch om de testsuite ( $T_F$ ) te passeren behouden blijft. De zoektocht verloopt via drie niveaus van granulariteit:
- Edit Sequence Level: Test of een volledige sequentie van edities (tussen twee feedbacks) kan worden verwijderd.
- File Level: Groepeert resterende edities per bestand en test of alle edities aan een specifiek bestand kunnen worden verwijderd.
- Edit Action Level: Test individuele atomaire edit-acties.
- Proces: Op elk niveau doorloopt het algoritme kandidaat-eenheden in omgekeerde volgorde, verwijdert ze tijdelijk om een "contrafactische patch" te construeren. Als de resulterende patch nog steeds de testsuite doorstaat en kleiner is dan de huidige versie, wordt de verwijdering geaccepteerd.
Validatie en Terminatie:
- Een verwijdering wordt alleen geaccepteerd als de kandidaat-patch de taakspecifieke testsuite doorstaat en de patchlengte strikt vermindert.
- Het algoritme kan in twee modi werken:
  - TRIM-NG (No Guarantee): Voert één pass uit op elk granulariteitsniveau voor efficiëntie.
  - TRIM-G (Guaranteed): Herhaalt de passes totdat een lokaal fixpunt wordt bereikt, wat een one-minimal oplossing garandeert (geen enkele edit kan worden verwijderd zonder de test te breken).

Efficiëntie

De dominante kosten van minimalisatie zijn de uitvoering van de testsuite. TRIM is ontworpen om deze executies te minimaliseren. Door grote groepen edities vroegtijdig te elimineren (op sequentie- of fileniveau), vermijdt TRIM de uitputtende combinatorische zoektocht die vereist is door traditionele algoritmen zoals Delta Debugging.

3. Belangrijkste Bijdragen

Formalisering van CODESLOP: Het artikel introduceert de eerste functionele definitie van code slop in door agenten gegenereerde patches, waarbij onderscheid wordt gemaakt van statische kwaliteitsmetrieken.
TRIM-algoritme: De ontwikkeling van een traject-bewust minimalisatie-algoritme dat de hiërarchische structuur van agent-herstelprocessen exploiteert om functionele redundantie te identificeren en te verwijderen.
Empirische Validatie: Uitgebreide evaluatie over meerdere benchmarks en agent-scaffolds die aantoont dat aanzienlijke CODESLOP kan worden verwijderd zonder de correctheid in gevaar te brengen.

4. Experimentele Resultaten

De auteurs evalueerden TRIM op Live-kBench (Linux kernel kwetsbaarheden) en SWE-Bench-Verified (GitHub issues) met vier agent-scaffolds: CRASHFIXER, SWE AGENT, MINISWE AGENT, en OPENHANDS.

CODESLOP Reductie: TRIM verminderde CODESLOP met 17,9% tot 32,9% over verschillende agents en benchmarks.
- Op Live-kBench bereikte de volledige edit-level TRIM-G een reductie van tot wel 32,9%.
- In sommige gevallen reduceerde TRIM agent-patches exact tot de door de ontwikkelaar geschreven (menselijke) fix.
Vergelijking met Agentic Minimization:
- Het instrueren van agents om hun eigen patches te minimaliseren (Agentic Minimization) was aanzienlijk minder effectief, met slechts 2,1%–13,4% reductie.
- Agentic minimizatie faalde in 3,8% tot 44,9% van de gevallen (bijv. patch-inflatie, bestandsmismatches of het herintroduceren van bugs), terwijl TRIM deterministisch geldige, kleinere patches produceert.
- TRIM presteerde 1,6× tot 3,1× beter dan agentic baselines in termen van reductiekwaliteit.
Vergelijking met Deterministische Baselines (Delta Debugging):
- TRIM bereikte een statistisch equivalente CODESLOP-reductie als Delta Debugging (DD-Hunk) (32,9% vs. 31,5%).
- Echter, TRIM vereiste ongeveer de helft van de validatiekosten (1,9× minder testexecuties) en had een veel lagere worst-case executietijd door zijn hiërarchische pruning.
Correctheid: TRIM behield de oracle-correctheid in 99,1% van de SWE-Bench gevallen en vertoonde een verwaarloosbare regressie (maximaal ~1% daling) op Live-kBench. In sommige gevallen verbeterde minimalisatie zelfs de "overeenkomst met menselijke fix" metriek.

5. Betekenis en Claims

Het artikel claimt dat Patch Minimization fundamenteel een zoekprobleem is in plaats van een generatieprobleem.

Zoektocht vs. Generatie: De resultaten suggereren dat gestructureerde, traject-gestuurde contrafactische zoektocht effectiever en betrouwbaarder is dan het instrueren van Large Language Models (LLMs) om hun eigen code te herschrijven of te minimaliseren.
Efficiëntie: Door gebruik te maken van de inherente structuur van de exploratiegeschiedenis van de agent, kan TRIM de minimalisatiekwaliteit van uitputtend zoeken (zoals Delta Debugging) evenaren tegen een fractie van de computationele kosten.
Praktische Bruikbaarheid: De hiërarchische aanpak biedt een afstelbare kosten-kwaliteit afweging, waardoor gebruikers op grovere granulariteit kunnen stoppen (bijv. sequentieniveau) als de validatiebudgetten beperkt zijn, of kunnen doorgaan naar fijnmazige minimalisatie voor maximale reductie.
Generaliseerbaarheid: De aanpak generaliseert over verschillende domeinen (security-kritische kernel reparatie versus algemene repository reparatie) en verschillende agent-architecturen zonder de kernlogica van de minimalisatie te vereisen.

De auteurs concluderen dat TRIM een praktische, efficiënte methode biedt om de accumulatie van redundantie in door AI gegenereerde code te verlichten, waarmee een kritieke bottleneck in het onderhoud van agent-ondersteunde softwareontwikkeling wordt aangepakt.