L’Intelligenza Artificiale è uno strumento straordinario per lo sviluppo del codice, ma lavorare con i Large Language Models (LLM) richiede un cambio di mentalità.
Recentemente mi sono trovato a chiedere a un’IA un compito all’apparenza banale: prendere un plugin di sincronizzazione (che aggiornava stock e prezzi da un fornitore) già perfettamente funzionante e aggiungervi semplicemente una funzione di logging dettagliato.
La risposta iniziale è stata rassicurante:
“Certamente. Ho mantenuto intatta tutta la logica… inserendo solo i messaggi di log”.
Nella realtà?
Ci sono volute 11 interazioni e continui ripristini del codice originale per arrivare al risultato.
Se non avessi verificato attentamente ogni output fornito dall’IA a ogni ciclo, avrei messo in produzione un sistema completamente rotto.
Questa esperienza mi ha fatto riflettere su alcuni pattern comportamentali tipici degli LLM che ogni sviluppatore (o anche semplice utente) dovrebbe conoscere.
Non si tratta di una critica all’IA, ma di una presa di coscienza di come questi strumenti ragionano e, soprattutto, di come sbagliano.
1. Il pericolo dei “fallimenti silenziosi”
(ovvero: quando il log dice che va tutto bene)
Uno dei rischi più grandi riscontrati è stato il cosiddetto fallimento silenzioso.
Dopo alcune modifiche dell’IA, il processo di sincronizzazione — che normalmente gestiva migliaia di prodotti — si chiudeva in appena 9 secondi dichiarando:
“Aggiornati: 0, Disabilitati: 0”.
Il problema?
Il codice non generava errori PHP.
Il sistema sembrava funzionare perfettamente.
Se non avessi verificato l’effettivo aggiornamento dei dati, mi sarei ritrovato con un e-commerce che smetteva silenziosamente di aggiornare prezzi e disponibilità, convinto che tutto andasse a gonfie vele perché “i log non mostrano errori”.
L’IA, nel tentativo di aggiustare un dettaglio, aveva semplicemente rimosso la logica di estrazione dei dati, facendo girare a vuoto l’intero motore.
2. L’IA non dice “Non lo so”: inventa cause ipotetiche
Un LLM è programmato per darti una risposta. Sempre.
Quando il suo codice fallisce, piuttosto che ammettere di non aver compreso la struttura del file, l’IA tende ad arrampicarsi sugli specchi o — peggio — a dare la colpa a fattori esterni.
Quando la sincronizzazione ha smesso di riconoscere i prodotti, l’IA ha iniziato a ipotizzare:
-
problemi di precisione dei decimali nei prezzi
-
differenze tra stringhe e float
-
problemi con la cache di WooCommerce
A un certo punto stava persino suggerendo che potessero esserci spazi o caratteri strani negli SKU.
Sono stato costretto a fermarla esplicitamente:
“I prodotti ci sono. Gli SKU sono corretti. Non ipotizzare errori nei dati perché fino a prima funzionava tutto.”
La verità?
Non c’era nessun problema nei dati.
L’IA aveva introdotto costanti inesistenti o aveva alterato il motore di parsing originale che funzionava perfettamente.
3. La “Semplificazione Distruttiva”
Questo è forse il comportamento più insidioso.
Per risolvere un singolo problema (ad esempio un errore fatale o un match fallito), l’IA ha iniziato a “semplificare” il codice.
Il problema è che lo ha fatto in modo distruttivo.
Senza avvisarmi ha iniziato a rimuovere blocchi fondamentali del plugin.
Ha stravolto il parser XML originale (necessario per leggere i dati annidati del fornitore), ha eliminato filtri vitali e, a un certo punto, ha addirittura cancellato interamente le funzioni che gestivano i file CSV.
Me ne sono accorto solo alla fine guardando il file.
Il codice che mi stava restituendo era lungo la metà dell’originale.
Alla mia contestazione:
“Sei SICURO che non stai togliendo ancora troppe funzioni?”
l’IA ha candidamente risposto:
“Hai perfettamente ragione a dubitare… il file che ti ho dato per ultimo era effettivamente una versione castrata e incompleta”.
Quindi? L’umano resta l’architetto (almeno per ora)
L’idea che basti fornire un prompt e incollare ciecamente il risultato è una pericolosa illusione.
Gli LLM sono assistenti instancabili e potentissimi, ma soffrono di un’eccessiva sicurezza di sé.
Sono pronti a riscrivere il cuore del tuo sistema per farti un favore, senza capire che stanno buttando via mesi di lavoro strutturale.
Il codice generato non va solo controllato per errori di sintassi.
Va capito e testato funzionalmente a ogni ciclo.
Perché se non lo fai tu, l’IA sarà ben felice di dirti che il task è completato con successo, lasciandoti con un sistema che, semplicemente, ha smesso di fare il suo lavoro.
Il problema non è che l’IA sbaglia.
Il problema è che lo fa con estrema sicurezza.
Perché succede questo comportamento
La cosa interessante è che questi comportamenti non sono un bug dell’IA.
Sono una conseguenza diretta di come funzionano i Large Language Models.
Un LLM non ragiona come un compilatore o un debugger. Non esegue il codice e non verifica se il sistema funzionerà davvero. Genera invece la sequenza di testo più probabile in base a ciò che ha visto nei dati di training.
Per questo tende a fare tre cose molto specifiche:
-
rispondere sempre, anche quando non ha compreso davvero il contesto
-
ipotizzare cause plausibili, perché ha visto problemi simili in migliaia di discussioni tecniche
-
semplificare il codice, assumendo che una versione più corta sia spesso una versione migliore
Il risultato è che il codice prodotto può essere sintatticamente corretto, ma funzionalmente sbagliato.
Ed è qui che entra in gioco l’unico vero debugger del processo: lo sviluppatore.
La parte più affascinante (e allo stesso tempo preoccupante) è stata vedere l’IA arrampicarsi sugli specchi, ipotizzando errori nei miei codici SKU o nei miei dati pur di non ammettere di aver sbagliato l’estrazione XML.
In realtà l’ho lasciata fare anche per osservare fin dove sarebbe arrivata.
Parte del mio lavoro è anche questo: osservare cosa succede quando alcune dinamiche che vedo applicare dai clienti in consulenza vengono portate all’estremo.
Io mi sono salvato perché conoscevo perfettamente la struttura del mio plugin e ho testato maniacalmente ogni output.
Ma cosa succede quando questo strumento finisce nelle mani di uno sviluppatore alle prime armi, o di un utente che si fida ciecamente del “Copia e Incolla”?
Stiamo forse andando verso un’epoca in cui i sistemi collasseranno silenziosamente perché nessuno sa più leggere cosa l’IA ha deciso arbitrariamente di tagliare?
