From Restructuring to Stabilization: A Large-Scale Experiment on Iterative Code Readability Refactoring with Large Language Models

Probleemstelling

Grote Taalmodellen (LLMs) worden steeds vaker ingezet voor geautomatiseerde code-refactoring om de leesbaarheid en onderhoudbaarheid van software te verbeteren. Hoewel deze modellen snel code kunnen herschrijven, is de kwaliteit van de output vaak inconsistent en onvoorspelbaar. Er bestaat een kritische kennislacune over wat er gebeurt wanneer LLMs herhaaldelijk worden gevraagd om hun eigen output te refactoren. De centrale vraag is of deze modellen convergeren naar een stabiele, hoge-kwaliteit oplossing (gebaseerd op een intern begrip van "optimale leesbaarheid") of dat ze blijven oscilleren en oppervlakkige, zelfs regressieve, veranderingen introduceren. Daarnaast is onduidelijk hoe specifieke prompt-strategieën (bijv. focus op namen versus commentaar) de dynamiek van deze iteratieve processen beïnvloeden.

Methodologie

De auteurs hebben een grootschalig experiment uitgevoerd met GPT-5.1 (OpenAI) om de iteratieve refactoring van code te analyseren.

• Dataset: Er zijn 230 Java-codefragmenten geselecteerd uit de open-source repository "The Algorithms – Java".
• Variatie: Voor elk origineel fragment zijn twee extra varianten gemaakt om de robuustheid te testen:
  1. Meaningless: Alle identificatoren (variabelen, methoden) en commentaar zijn bewust betekenisloos gemaakt.
  2. NoComment: Alle commentaar is verwijderd.
• Iteratief Proces: Elk van de 230 fragmenten (in 3 varianten) werd 5 iteraties lang herwerkt.
• Prompt-strategieën: Drie verschillende prompts werden gebruikt:
  1. General: "Refactor this code for improved readability." (Ongeleid).
  2. Meaning: Focus op het verbeteren van identificator-namen.
  3. Comments: Focus op het verbeteren van commentaar.
• Analyse Tooling: De auteurs ontwikkelden een aangepast DiffParser (Python) dat sequentie-, token- en AST-gebaseerde vergelijkingsmaatstaven combineert. Dit tooling classificeerde veranderingen in categorieën zoals:
  • Implementatieveranderingen (toegang, aanroepen, controleflow, etc.).
  • Syntactische aanpassingen.
  • Naamswijzigingen (Renaming).
  • Commentaarveranderingen.
• Validatie: Er werden twee vervolgonderzoeken uitgevoerd:
  1. Functionele Correctheid: Unit-tests werden uitgevoerd om te controleren of de refactoring de functionaliteit niet verbrak.
  2. Novel Code: Een experiment met code uit repositories die na de trainingsdata van GPT-5.1 (2025) zijn gegenereerd, om te controleren op "memorization" bias.

Belangrijkste Bijdragen

1. Empirisch Bewijs van Convergentie: Het artikel levert data-onderbouwd bewijs dat LLMs bij iteratieve refactoring een patroon van "herstructurering gevolgd door stabilisatie" vertonen. Ze neigen naar een interne standaard van leesbaarheid.
2. Invloed van Prompts: Er wordt aangetoond dat expliciete prompts de trajecten van verandering significant beïnvloeden. Sommige prompts leiden tot stabilisatie, terwijl andere (zoals focus op namen) kunnen leiden tot oscillerend gedrag.
3. LLM-agnostisch Framework: De auteurs presenteren een herbruikbaar framework voor het analyseren van code-evolutie onder iteratieve refactoring, toepasbaar op verschillende modellen.
4. Open Replicatiepakket: Alle data, scripts en figuren zijn openbaar beschikbaar gesteld.

Resultaten

De resultaten worden gepresenteerd aan de hand van drie onderzoeksvragen (RQ):

• RQ1: Evolutie van iteratieve refactoring (bij goed gestructureerde code):

  • LLMs behouden de basisstructuur van goed geschreven code, maar introduceren in de eerste iteraties vaak onnodige veranderingen (bijv. verwijderen van commentaar, hernoemen van variabelen, opsplitsen van methoden).
  • Na de eerste twee iteraties stabiliseert het proces snel. De hoeveelheid veranderingen neemt af en de gelijkenis tussen versies neemt toe.
  • Er is een tendens tot "over-refactoring": zelfs bij bestaande best practices blijven kleine, soms willekeurige, aanpassingen plaatsvinden.

• RQ2: Convergentie over code-varianten:

  • Ondanks dat de startvarianten sterk verschilden (bijv. betekenisloze namen of geen commentaar), convergeren alle varianten na enkele iteraties naar een zeer vergelijkbare eindstructuur.
  • De gelijkenis tussen de uiteindelijke versies van de verschillende varianten is hoog (ongeveer 0,87–0,90), wat suggereert dat LLMs diverse inputs normaliseren naar een gemeenschappelijke, intern gedefinieerde "optimale" vorm.
  • De variant zonder commentaar convergeerde iets sneller dan de variant met betekenisloze namen.

• RQ3: Impact van expliciete prompts:

  • Naam-focussende prompts: Leidden tot een oscillerend gedrag. De LLM bleef variabelen hernoemen zonder tot een stabiele oplossing te komen, wat resulteerde in minder convergentie.
  • Commentaar-focussende prompts: Leidden tot snellere stabilisatie. De LLM voegde commentaar toe in de eerste iteratie en stabiliseerde daarna.
  • Statistische tests (Kruskal-Wallis en Mann-Whitney U) bevestigden dat de keuze van de prompt een significant effect heeft op het type en de frequentie van veranderingen.

• Robuustheid:

  • Functionele Correctheid: De functionaliteit bleef grotendeels behouden. Er was slechts een minimale daling (<1%) in de pas-rate van unit-tests per iteratie, voornamelijk door oppervlakkige veranderingen (zoals tekst in uitzonderingsberichten) en niet door fundamentele logica-fouten.
  • Novel Code: De bevindingen bleven gelden voor code die waarschijnlijk niet in de trainingsdata zat, wat suggereert dat het gedrag voortkomt uit een fundamenteel begrip van code en niet uit memorisatie.

Betekenis en Conclusie

Dit onderzoek biedt een empirische basis voor het beoordelen van de betrouwbaarheid van LLM-gestuurde code-refactoring. De belangrijkste conclusies zijn:

1. Stabilisatie is mogelijk: LLMs kunnen diverse code naar een consistente stijl normaliseren, maar ze hebben een neiging tot over-refactoring in de vroege fasen.
2. Prompt Engineering is cruciaal: De keuze van de prompt bepaalt of het proces stabiliseert of oscilleert. Prompts die te specifiek zijn op dynamische aspecten (zoals namen) kunnen leiden tot eindeloze wijzigingen.
3. Beveiligingsmaatregelen: Voor praktische toepassing zijn expliciete stop-criteria nodig om over-refactoring te voorkomen, en moet men oppassen met het automatisch verwijderen van commentaar, aangezien dit waardevolle context kan verliezen.

Het werk markeert een stap in het begrijpen van de dynamiek van AI-gestuurde software-engineering en opent de weg voor verdere onderzoek naar het optimaliseren van iteratieve verbeteringscycli in softwareontwikkeling.