Tempo medio di lettura: 13 minuti

Negli ultimi giorni il mondo digitale ha offerto uno spettacolo istruttivo, per quanto costoso. Prima, giovedì 12 novembre, il grande blackout globale di Microsoft 365: oltre sedici ore di buio operativo che hanno paralizzato Exchange Online, Outlook, Teams e persino Copilot in settantaquattro Paesi. Poi, il 16 novembre, l’effetto domino sul sistema bancario statunitense: clienti di colossi come JPMorgan Chase, Bank of America e Wells Fargo tagliati fuori dai propri conti, pagamenti su Zelle bloccati e transazioni interbancarie in tilt.

In entrambi i casi, il copione comunicativo è stato identico. Prima il silenzio, poi il sospetto — quasi una speranza collettiva — dell’attacco informatico, infine la doccia fredda dei comunicati ufficiali: nessun hacker, nessun sabotaggio esterno. Nel caso delle banche americane, Chase ha parlato apertamente di un «problema temporaneo legato a un bug software» introdotto con un rilascio su sistemi on-premise. Nel caso di Microsoft, il rapporto preliminare post-incidente ha descritto una tempesta perfetta innescata da una lock contention — una contesa sui blocchi di accesso alle risorse di un processo interno — nata proprio da una correzione (un fix) distribuita poco prima. E non sfugge a chi legge i bollettini tecnici con un minimo di memoria storica che appena due giorni prima del crash, nel Patch Tuesday di novembre, Redmond si era vantata di aver risolto la cifra record di 1.094 vulnerabilità, attribuendo esplicitamente all’intelligenza artificiale il merito di una simile produttività.

Sia chiaro fin da subito, per onestà intellettuale e rigore scientifico: non abbiamo prove dirette che le righe di codice responsabili del bug bancario o del collasso di Exchange siano state sputate da un Large Language Model. Anzi, Microsoft ha negato un coinvolgimento diretto di agenti autonomi nell’incidente (notate quella parolina: diretto). Eppure, osservando questi due giganti cadere nello stesso modo — insieme a una miriade di piccoli disservizi quotidiani che ormai accettiamo come rumore di fondo — il dubbio sorge spontaneo. E se la causa profonda non fosse un singolo algoritmo impazzito, ma un cambiamento culturale silenzioso e devastante? E se stessimo pagando il conto di una generazione di sviluppatori trasformati in semplici incollatori di codice plausibile?

La trappola della plausibilità statistica

Su queste pagine ho già avuto modo di analizzare perché delegare la scrittura del software all’intelligenza artificiale rappresenti una bomba a orologeria tecnica. Il problema non risiede nella capacità sintattica di questi strumenti, che è indiscutibilmente prodigiosa, ma nella loro natura matematica fondamentale. Un modello linguistico non ragiona, non dimostra teoremi, non costruisce un modello mentale dello stato di un sistema distribuito. Calcola probabilità condizionate. Dato un contesto, predice la sequenza di token statisticamente più verosimile.

Il risultato è codice plausibile. E nel mondo dell’ingegneria del software, il codice plausibile è infinitamente più pericoloso del codice palesemente sbagliato.

Un errore di sintassi o un’architettura grossolanamente errata vengono intercettati subito: il compilatore protesta, i test unitari falliscono, il programma va in crash sul banco di prova prima ancora di vedere la luce. Il codice plausibile, invece, si compila al primo colpo. Ha nomi di variabili eleganti, commenti formattati secondo le migliori convenzioni, gestisce il caso d’uso principale con grazia apparente e supera brillantemente una revisione superficiale.

Il veleno si nasconde nelle condizioni al contorno. Si annida nella concorrenza tra thread, nella gestione della memoria sotto carico estremo, nella latenza di rete imprevista. Un modello statistico conosce migliaia di esempi in cui un certo pattern di sincronizzazione “funziona” nella maggior parte dei repository pubblici su cui è stato addestrato. Non capisce perché quel pattern, in uno specifico contesto ad altissima concorrenza, generi un collo di bottiglia letale.

Anatomia di una lock contention: perché un modello statistico non vede il tempo

Per capire perché un incidente come quello di Microsoft sia il sintomo perfetto di questo approccio, bisogna scendere nel merito tecnico di cosa sia una lock contention e perché rappresenti il tallone d’Achille di chi scrive codice senza padroneggiare la fisica dei sistemi distribuiti.

Immaginiamo una risorsa condivisa critica all’interno di un’infrastruttura colossale come Exchange Online: una tabella di instradamento in memoria, un registro di stato delle sessioni o una coda di messaggi ad altissima priorità. Quando migliaia di processi concorrenti devono leggere e aggiornare quella risorsa, occorre un meccanismo di sincronizzazione — un lock, un lucchetto logico — per evitare che due thread scrivano contemporaneamente corrompendo i dati.

Scrivere il codice per acquisire e rilasciare un lock è banalissimo. Qualsiasi modello generativo sa scrivere un blocco lock() / unlock() o gestire un semaforo in C# o C++ in modo sintatticamente impeccabile. Il problema non è mai la sintassi del lucchetto, ma la dinamica temporale con cui quel lucchetto viene conteso sotto carico.

Quando un programmatore — o un’IA da lui guidata — introduce una correzione rapida per risolvere un bug di coerenza dei dati, la soluzione più “plausibile” e statisticamente frequente consiste nell’estendere leggermente il perimetro del blocco: si acquisisce il lock un po’ prima e lo si rilascia un po’ dopo, per assicurarsi che l’operazione sia salda. Sulla carta, e in un ambiente di test con dieci utenti simulati, la modifica è perfetta. Il bug sparisce, i test di regressione passano tutti con semaforo verde.

Ma un Large Language Model opera su un testo statico, dentro una finestra di contesto finita. Non possiede un simulatore fisico del tempo di esecuzione. Non vede che quella funzione, innocua in isolamento, viene invocata milioni di volte al minuto da un gateway di rete; non vede che, allungando di tre millisecondi la permanenza del lock per gestire una verifica aggiuntiva, la probabilità che due thread si scontrino supera la soglia critica di saturazione. Quando il traffico globale colpisce il server, i thread iniziano ad accodarsi in attesa del lucchetto. L’attesa fa crescere la latenza, la latenza fa accumulare nuove richieste, l’accumulo satura i pool di connessione e, in pochi minuti, l’intero sistema entra in uno stato di paralisi a cascata.

Ops… Assomiglia davvero in modo preoccupante alla descrizione che la stessa MS ha fatto dell’incidente, nevvero?

Un modello linguistico vede solo righe di codice; un ingegnere deve vedere i flussi di elettroni, i cicli di clock e le code di attesa nel tempo reale. Se chi preme il tasto “accetta” sul suggerimento dell’editor non ha più questa visione tridimensionale della macchina, il disastro è già scritto nel momento stesso in cui il commit viene inviato al repository.

La lezione della fisica, delle radio e degli ingranaggi

Chi ha una formazione scientifica o si è tagliuzzato le mani con l’hardware sa bene che la natura non accetta il “quasi giusto”.

Esempio: nel mondo dei radioamatori, quando si progetta un sistema d’antenna o un filtro passa-basso per un trasmettitore, non esiste la plausibilità statistica. Se l’adattamento di impedenza è sbagliato, le onde stazionarie (ROS) tornano indietro lungo il cavo coassiale e bruciano i transistor finali dello stadio di potenza. Non importa quanto sia elegante lo schema elettrico disegnato su carta o quanto sia “verosimile” il calcolo fatto a spanne: la fisica del campo elettromagnetico presenta il conto istantaneamente e senza appello.

Lo stesso vale nell’orologeria meccanica, un altro ambito in cui la tolleranza è tutto. Un ruotismo con un gioco calcolato in modo “statisticamente accettabile” sulla media dei calibri esistenti, ma privo di rigorosa verifica sull’attrito dei perni e sulla coppia della molla motrice, magari marcia per dieci minuti sul banco dell’orologiaio, per poi fermarsi non appena l’olio si addensa leggermente o la temperatura cala di due gradi.

L’informatica moderna, grazie a strati su strati di astrazione, memoria quasi illimitata e potenza di calcolo sovrabbondante, ci ha illusi di poterci emancipare da queste leggi ferree. Ci ha fatto credere che il software sia materia eterea, infinitamente malleabile, dove l’approssimazione può sempre essere corretta con una patch successiva. L’intelligenza artificiale generativa ha portato questa illusione al parossismo: ha trasformato la progettazione di sistemi complessi in un esercizio di composizione letteraria. Ma sotto gli strati di astrazione continuano a esserci silicio, clock, memoria finita e tempi di propagazione. E quando la scala raggiunge le dimensioni di Microsoft o del sistema interbancario americano, la fisica torna a bussare alla porta con la forza e la grazia di un maglio.

Dal progettista al “copiatore di codice”

Se il problema fosse confinato allo strumento, basterebbe applicare la regola aurea di ogni laboratorio di fisica o sala server: non fidarsi mai di uno strumento di misura senza averne verificato la taratura e i limiti di applicabilità. Ma è qui che entra in gioco il fattore umano, ed è qui che il quadro diventa inquietante.

Stiamo assistendo a una mutazione antropologica del mestiere del programmatore. Per decenni, scrivere software ha significato affrontare un sano, necessario attrito cognitivo. Per risolvere un problema bisognava scomporlo, disegnare diagrammi di stato, comprendere il funzionamento sottostante del sistema operativo, dello stack di rete, del database. Anche quando si cercava aiuto su un forum tecnico o su Stack Overflow, bisognava leggere, adattare, capire il perché di una soluzione prima di integrarla. Quel processo faticoso serviva a costruire una mappa mentale del sistema.

Oggi, l’integrazione nativa dell’IA negli ambienti di sviluppo ha azzerato quell’attrito. Si scrive un prompt, si preme il tasto Tab e venti righe di logica complessa appaiono sullo schermo. L’illusione della velocità è irresistibile, soprattutto per un management che misura la produttività in righe di codice prodotte, vulnerabilità chiuse nel bollettino mensile dei ticket evasi.

Ma c’è un effetto collaterale che chiunque si occupi di formazione tecnica osserva con crescente preoccupazione: la capacità di leggere e validare criticamente il codice è strettamente legata all’abitudine di scriverlo da zero. Il muscolo dell’analisi si atrofizza se non viene allenato nella fatica della sintesi. Quando un programmatore si riduce a fare il revisore passivo di un generatore automatico, perde gradualmente la sensibilità per le sfumature architetturali. Guarda il blocco di codice suggerito, lo trova coerente con ciò che si aspettava di vedere — perché è progettato per essere persuasivo — e lo accetta.

Diventa, di fatto, un copiatore seriale di soluzioni di cui non padroneggia più le fondamenta. E la cosa peggiore è che questa deriva colpisce anche i profili più esperti, anestetizzati dalla comodità e pressati da ritmi di rilascio sempre più frenetici, mentre impedisce del tutto ai giovani sviluppatori di farsi le ossa: come può un junior imparare a riconoscere una potenziale race condition se non ha mai dovuto fare il debug manuale di un dead-lock per tre notti consecutive?

Il paradosso del fix automatico e il debito tecnico invisibile

Torniamo ai fatti della settimana appena trascorsa. È particolarmente significativo che sia l’incidente Microsoft sia il blocco delle transazioni di JPMorgan Chase siano legati a modifiche recenti: un aggiornamento correttivo nel primo caso, un nuovo rilascio software nel secondo.

Nella gestione dei grandi sistemi informatici, il momento più critico non è mai la creazione da zero, ma la manutenzione. Mettere mano a un’infrastruttura stratificata negli anni richiede una visione d’insieme che spesso supera la capacità di qualsiasi singolo individuo. Quando si affida a un assistente IA il compito di “risolvere un bug” o “ottimizzare una routine” su una base di codice complessa, il modello opera dentro quella finestra di contesto limitata di cui parlavamo poco fa. Vede l’albero, ma ignora la foresta. Propone una toppa locale che chiude la falla immediata, ma altera un equilibrio delicato a tre livelli di astrazione di distanza.

Se dall’altra parte dello schermo c’è un ingegnere formato alla vecchia maniera — uno di quelli che si chiedono sempre perché una cosa funziona, non limitandosi al fatto che sembri funzionare — la toppa viene smontata, stressata, messa in discussione. Ma se la catena di comando è composta da sviluppatori abituati a delegare il pensiero al completamento automatico, quella modifica supera la code review perché nessuno ha più la pazienza, o la competenza profonda, per simulare mentalmente cosa accadrà quando quel codice incontrerà il mondo reale.

È la tempesta perfetta del debito tecnico: una montagna di codice nuovo, generato a velocità industriale, che nessuno ha mai davvero compreso fino in fondo. Un codice che funziona finché il vento soffia a favore, ma che non ha alcuna resilienza strutturale quando si alza la burrasca.

Una questione di metodo, non di luddismo

Chi mi legge sa bene che, anche se superficialmente potrebbe sembrare il contrario, non ho alcuna simpatia per il luddismo tecnologico. Uso gli strumenti informatici più avanzati ogni giorno, per lavoro e per passione. L’intelligenza artificiale è un moltiplicatore formidabile per attività ripetitive, per l’analisi esplorativa, persino per scovare refusi e incongruenze sintattiche in un testo come questo.

Ma qualsiasi moltiplicatore applicato a zero restituisce sempre zero. Se a una competenza ingegneristica solida affianchi un assistente generativo, ottieni un professionista più veloce, capace di delegare la manovalanza digitale mantenendo il controllo assoluto sull’architettura. Se invece consegni lo stesso strumento a chi non ha mai costruito le basi, o a chi viene spinto dalle aziende a correre senza fermarsi a pensare pur di gonfiare le statistiche dei rilasci, ottieni esattamente ciò che stiamo vedendo: sistemi sempre più fragili, opachi e interconnessi, dove basta una riga di codice “plausibile” nel posto sbagliato per spegnere la posta elettronica di mezzo pianeta o bloccare i bonifici di milioni di cittadini.

Non serve invocare complotti o scenari fantascientifici per spiegare la fragilità della nostra infrastruttura digitale. Basta guardare a come stiamo trattando il pensiero umano. Stiamo barattando la fatica della comprensione con la comodità dell’approssimazione. E i computer, esattamente come i circuiti a radiofrequenza e i bilancieri degli orologi meccanici, non hanno alcun senso dell’umorismo né indulgenza per ciò che è “quasi giusto”: continuano a ricordarcelo nel modo più brutale ed inelegante possibile.