Sintesi Tecnica: L'influenza dei Large Language Models sul Codice

Definizione del Problema

La rapida integrazione di Large Language Models (LLM) e di strumenti basati su LLM (ad es. Copilot, Cursor) nello sviluppo software ha sollevato interrogativi riguardo al loro impatto tangibile sulle pratiche di programmazione reali. Mentre la ricerca precedente si è concentrata sulla distinzione tra codice generato da LLM e codice scritto da umani o sulla valutazione della correttezza funzionale, manca un'evidenza empirica riguardante se gli LLM abbiano fondamentalmente trasformato lo stile del codice nel mondo reale. Questo articolo indaga la domanda centrale: Gli LLM hanno trasformato lo stile del codice e come può essere caratterizzata tale trasformazione? Nello specifico, gli autori esaminano se le preferenze stilistiche degli LLM (ad es. convenzioni di denominazione, metriche di complessità) stiano permeando le basi di codice scritte da esseri umani nel tempo.

Metodologia

Lo studio impiega un approccio a due fronti che combina un'analisi empirica su larga scala di repository reali con simulazioni controllate.

1. Raccolta dei Dati

• Repository GitHub: Gli autori hanno raccolto 22.074 repository e oltre 1 milione di file di codice sorgente collegati a paper arXiv pubblicati tra il Q1 2020 e il Q3 2025. I repository sono stati categorizzati per linguaggio di programmazione (Python, C/C++) e dominio scientifico (Informatica vs. Non-Informatica).
• Baseline Scritta da Umani: Per stabilire una baseline pre-LLM, gli autori hanno utilizzato Code4Bench, un dataset di sottomissioni utente accettate da Codeforces prima del 2020.
• Sottoinsieme di Problemi: Un sottoinsieme di 200 problemi algoritmici è stato selezionato da Code4Bench, stratificato per difficoltà (rating 800–2000+) e tipo di algoritmo (ad es. DP, Greedy, Math).

2. Simulazione e Generazione

Gli autori hanno simulato la codifica assistita da LLM utilizzando 12 diversi LLM (inclusi serie Qwen3, DeepSeek-R1, GPT-4.1, Llama-4 e Gemini-2.0). Sono state testate due strategie di generazione:

• Generazione Diretta (ANS): I modelli risolvono i problemi da zero basandosi esclusivamente sulle descrizioni del problema.
• Generazione Guidata da Riferimento (REF): Ai modelli viene fornita una soluzione corretta scritta da un umano (codice AC) e viene istruito a revisionare o riscrivere tale codice.

3. Metriche di Valutazione

Lo studio ha analizzato il codice attraverso quattro dimensioni:

• Pattern di Denominazione: Categorizzati in formati (snake_case, camelCase, PascalCase, ecc.) e misurati in termini di lunghezza dei nomi.
• Complessità e Manutenibilità: Misurati tramite Complessità Ciclotomica, metriche di Halstead (Volume, Difficoltà, Sforzo, Bug) e Indice di Manutenibilità (Standard e Custom).
• Similarità del Codice: Quantificata utilizzando la Similarità del Coseno e la Similarità di Jaccard tra il codice umano, la generazione diretta e la generazione guidata da riferimento.
• Allineamento del Ragionamento: Analizzato l'accordo tra le etichette algoritmiche nella catena di ragionamento del modello e i tag del problema di riferimento.

Contributi Chiave e Risultati

1. Evidenza della Trasformazione dello Stile (Pattern di Denominazione)

Lo studio fornisce la prima evidenza empirica su larga scala che gli LLM stanno influenzando gli stili di codifica umani.

• Adozione delle Preferenze degli LLM: In Python, la proporzione di nomi di funzione in snake_case nei repository GitHub è aumentata dal 40,7% nel Q1 2023 al 49,8% nel Q3 2025. Questa tendenza si allinea alla preferenza osservata nel codice generato da LLM.
• Denominazione delle Variabili: Gli LLM preferiscono costantemente nomi di variabili più lunghi e descrittivi (ad es. max_length invece di ml) ed evitano nomi a lettera singola o con suffissi numerici. I repository GitHub mostrano una parallela diminuzione dei nomi brevi/con suffissi numerici e un aumento della lunghezza media dei nomi, particolarmente nei domini informatici.
• Differenze di Linguaggio: Mentre Python mostra chiare tendenze temporali nella denominazione, le tendenze in C/C++ sono meno pronunciate, sebbene l'uso di snake_case nelle variabili e funzioni in C/C++ mostri comunque una traiettoria ascendente.

2. Complessità e Manutenibilità

• LLM vs. Umano: In Python, il codice generato da LLM ha esibito una maggiore complessità ciclotomica rispetto al codice scritto da umani. Al contrario, in C/C++, gli LLM hanno prodotto codice con una minore complessità ciclotomica.
• Manutenibilità: Il codice generato da LLM ha generalmente dimostrato indici di manutenibilità più elevati e un minor numero stimato di bug rispetto alle soluzioni scritte da umani nella simulazione.
• Guida di Riferimento vs. Diretta: In Python, la generazione guidata da riferimento (riscrittura di codice esistente) ha prodotto un codice più conciso (minore volume/sforzo di Halstead) rispetto alla generazione diretta. In C/C++, si è osservato l'opposto.

3. Similarità del Codice

• Capacità di Imitazione: Quando forniti con codice di riferimento, gli LLM hanno prodotto soluzioni con una similarità significativamente maggiore (sia Coseno che Jaccard) rispetto al codice umano originale rispetto alla generazione diretta.
• Divergenza: Senza guida di riferimento, il codice generato da LLM nei compiti di algoritmi IO diverge significamente in termini di stile dal codice scritto da umani, suggerendo che gli LLM possiedano stili "nativi" distinti che differiscono dalle norme umane a meno che non siano esplicitamente condizionati.

4. Ragionamento e Comprensione Algoritmica

• Corrispondenza delle Etichette: L'analisi delle catene di ragionamento ha rivelato che gli LLM spesso non menzionano esplicitamente le etichette algoritmiche corrette (ad es. "DP", "Greedy") associate al problema.
• Tassi di Errore: Il tasso di errore (identificazione di algoritmi errati) ha generalmente superato il tasso di corrispondenza (identificazione di algoritmi corretti).
• Bias di Linguaggio: I modelli tendono a fare maggiore affidamento sul ragionamento algoritmico per i compiti in C/C++, rispetto a Python, dove si concentrano maggiormente sui dettagli di implementazione pratica.
• Correlazione con la Difficoltà: Sia i tassi di corrispondenza che quelli di errore aumentano con la difficoltà del problema, suggerendo che i problemi più difficili attivano meglio le capacità di ragionamento algoritmico dei modelli, sebbene con un rumore maggiore.

Significato e Rivendicazioni

L'articolo sostiene di fornire la prima evidenza empirica su larga scala che gli LLM non sono solo strumenti per generare codice, ma stanno attivamente rimodellando il paesaggio stilistico della programmazione reale.

• Spostamento delle Norme: Gli autori sostengono che gli stili di codifica umana si stiano spostando verso le convenzioni preferite dagli LLM (ad es. snake_case, nomi più lunghi), creando un ciclo di feedback in cui gli sviluppatori umani possono allinearsi sottilmente alle norme generate dalle macchine.
• Oltre la Rilevazione: A differenza dei lavori precedenti focalizzati sul rilevamento di codice generato da IA, questo studio si concentra sull'influenza degli LLM sull'evoluzione dello stile del codice, evidenziando che l'impatto degli LLM va oltre la correttezza funzionale per estendersi alle norme estetiche e strutturali.
• Implicazioni: Le scoperte suggeriscono che con la crescita dell'adozione degli LLM, la distinzione tra stile "umano" e "macchina" potrebbe sfumare, rendendo necessaria una rivalutazione di come la qualità e lo stile del codice debbano essere valutati in futuro.

Gli autori rimangono modesti riguardo alle loro rivendicazioni, riconoscendo limitazioni come l'impossibilità di quantificare l'esatta percentuale di codice generato da LLM nel mondo reale e la potenziale incompletezza della baseline pre-LLM (Code4Bench) nel rappresentare l'intero spettro degli stili di codifica umani. Essi sottolineano che il loro lavoro identifica tracce di influenza piuttosto che una causalità definitiva per tutti i cambiamenti osservati.