Technische Samenvatting: De Invloed van Large Language Models op Code

Probleemstelling

De snelle integratie van Large Language Models (LLM's) en door LLM's aangedreven tools (bijv. Copilot, Cursor) in de softwareontwikkeling heeft vragen opgeroepen over hun tastbare impact op de praktijk van programmeren in de echte wereld. Terwijl eerder onderzoek zich richtte op het onderscheiden van door LLM gegenereerde code van door mensen geschreven code of het evalueren van functionele correctheid, ontbreekt empirisch bewijs over de vraag of LLM's de codestijl fundamenteel hebben getransformeerd in de praktijk. Dit paper onderzoekt de centrale vraag: Hebben LLM's de codestijl getransformeerd, en hoe kan een dergelijke transformatie worden gekarakteriseerd? Specifiek onderzoeken de auteurs of de stilistische voorkeuren van LLM's (bijv. naamgevingsconventies, complexiteitsmetrieken) de door mensen geschreven codebases in de loop van de tijd binnendringen.

Methodologie

De studie maakt gebruik van een tweeledige aanpak die grootschalige empirische analyse van echte repositories combineert met gecontroleerde simulaties.

1. Datacollectie

• GitHub Repositories: De auteurs verzamelden 22.074 repositories en meer dan 1 miljoen broncodebestanden gekoppeld aan arXiv-papers gepubliceerd tussen Q1 2020 en Q3 2025. De repositories werden gecategoriseerd naar programmeertaal (Python, C/C++) en wetenschappelijk domein (Informatica versus niet-Informatica).
• Menselijke Baseline: Om een pre-LLM baseline vast te stellen, gebruikten de auteurs Code4Bench, een dataset van geaccepteerde gebruikersinzendingen van Codeforces van vóór 2020.
• Probleemsubset: Een subset van 200 algoritmische problemen werd geselecteerd uit Code4Bench, gestratificeerd naar moeilijkheidsgraad (rating 800–2000+) en algoritmisch type (bijv. DP, Greedy, Math).

2. Simulatie en Generatie

De auteurs simuleerden LLM-ondersteunde codering met behulp van 12 diverse LLM's (waaronder de Qwen3-serie, DeepSeek-R1, GPT-4.1, Llama-4 en Gemini-2.0). Twee generatiestrategieën werden getest:

• Directe Generatie (ANS): Modellen losten problemen vanaf nul op op basis van enkel de probleembeschrijvingen.
• Referentie-gestuurde Generatie (REF): Modellen kregen een correcte door mensen geschreven oplossing (AC-code) voorgelegd en kregen de instructie om deze te herzien of te herschrijven.

3. Evaluatiemetrieken

De studie analyseerde code over vier dimensies:

• Naamgevingspatronen: Gecategoriseerd in formaten (snake_case, camelCase, PascalCase, etc.) en gemeten via naamlengtes.
• Complexiteit & Onderhoudbaarheid: Gemeten met behulp van Cyclomatische Complexiteit, Halstead-metrieken (Volume, Difficulty, Effort, Bugs) en de Maintainability Index (Standaard en Custom).
• Codesimilariteit: Gekwantificeerd met behulp van Cosine Similarity en Jaccard Similarity tussen menselijke code, directe generatie en referentie-gestuurde generatie.
• Redeneer-alignement: Analyseerde de overeenkomst tussen algoritmische labels in de redeneerketen van het model en de grondwaarheid van de probleemtags.

Belangrijkste Bijdragen en Resultaten

1. Bewijs van Stijltransformatie (Naamgevingspatronen)

De studie levert het eerste grootschalige empirische bewijs dat LLM's de menselijke codestijlen beïnvloeden.

• Adoptie van LLM-voorkeuren: In Python nam het aandeel snake_case functienamen in GitHub-repositories toe van 40,7% in Q1 2023 naar 49,8% in Q3 2025. Deze trend komt overeen met de voorkeur die wordt waargenomen in door LLM gegenereerde code.
• Variabele Naamgeving: LLM's geven consequent de voorkeur aan langere, meer beschrijvende variabelenamen (bijv. max_length boven ml) en vermijden namen met enkelvoudige letters of cijfers als suffix. GitHub-repositories tonen een parallelle afname van korte/cijfer-gesuffixeerde namen en een toename in gemiddelde naamlengte, met name in CS-domeinen.
• Taalverschillen: Hoewel Python duidelijke temporele trends in naamgeving vertoont, zijn de trends in C/C++ minder uitgesproken, hoewel het gebruik van snake_case in C/C++ variabelen en functies nog steeds een opwaartse beweging laat zien.

2. Complexiteit en Onderhoudbaarheid

• LLM versus Mens: In Python vertoonde door LLM gegenereerde code een hogere cyclomatische complexiteit dan door mensen geschreven code. Daarentegen produceerden LLM's in C/C++ code met een lagere cyclomatische complexiteit.
• Onderhoudbaarheid: Door LLM gegenereerde code vertoonde over het algemeen hogere onderhoudbaarheidsindices en een lager geschat aantal bugs vergeleken met door mensen geschreven oplossingen in de simulatie.
• Referentie-gestuurd versus Direct: In Python resulteerde referentie-gestuurde generatie (het herschrijven van bestaande code) in meer beknopte code (lagere Halstead volume/effort) dan directe generatie. In C/C++ werd het tegenovergestelde waargenomen.

3. Codesimilariteit

• Imitatievermogen: Wanneer ze werden voorzien van referentiecode, produceerden LLM's oplossingen met een aanzienlijk hogere similariteit (zowel Cosine als Jaccard) aan de oorspronkelijke menselijke code vergeleken met directe generatie.
• Divergentie: Zonder referentie-instructies week door LLM gegenereerde code bij IO-algoritme-taken significant af in stijl van door mensen geschreven code, wat suggereert dat LLM's een eigen "natuurlijke" stijl hebben die verschilt van menselijke normen, tenzij ze expliciet worden geconditioneerd.

4. Redenering en Algoritmisch Begrip

• Label Matching: De analyse van redeneerketens toonde aan dat LLM's vaak nalaat om de correcte algoritmische labels (bijv. "DP", "Greedy") die bij het probleem horen, expliciet te noemen.
• Foutpercentages: Het foutpercentage (het identificeren van incorrecte algoritmen) was over het algemeen hoger dan het matchpercentage (het identificeren van correcte algoritmen).
• Taalbias: Modellen neigden er meer naar om algoritmische redenering te gebruiken voor C/C++ taken, terwijl ze bij Python meer leunden op praktische implementatiedetails.
• Correlatie met Moeilijkheidsgraad: Zowel de match- als de foutpercentages namen toe met de moeilijkheidsgraad van het probleem, wat suggereert dat moeilijkere problemen de algoritmische redeneercapaciteiten van de modellen beter activeren, zij het met meer ruis.

Betekenis en Claims

Het paper claimt het eerste grootschalige empirische bewijs te leveren dat LLM's niet alleen hulpmiddelen zijn voor het genereren van code, maar ook actief het stilistische landschap van de echte wereld vormgeven.

• Verschuiving in Normen: De auteurs betogen dat menselijke codestijlen verschuiven naar door LLM's geprefereerde conventies (bijv. snake_case, langere namen), wat een feedbackloop creëert waarbij menselijke ontwikkelaars zich subtiel afstemmen op machinegegenereerde normen.
• Voorbij Detectie: In tegen tegenstelling tot eerder werk dat gericht was op het detecteren van door AI gegenereerde code, richt deze studie zich op de invloed van LLM's op de evolutie van codestijl, waarbij wordt benadrukt dat de impact van LLM's verder gaat dan functionele correctheid tot aan esthetische en structurele normen.
• Implicaties: De bevindingen suggereren dat naarmate de adoptie van LLM's groeit, het onderscheid tussen "menselijke" en "machine" stijl kan vervagen, wat een herwaardering noodzakelijk maakt van hoe codekwaliteit en -stijl in de toekomst worden beoordeeld.

De auteurs blijven bescheiden over hun claims en erkennen beperkingen zoals het onvermogen om het exacte percentage door LLM gegenereerde code in de praktijk te kwantificeren en de potentiële onvolledigheid van de pre-LLM baseline (Code4Bench) in het vertegenwoordigen van het volledige spectrum van menselijke codestijlen. Ze benadrukken dat hun werk sporen van invloed identificeert in plaats van definitieve causaliteit voor alle geobserveerde veranderingen.