Nel giro di pochi anni lo sviluppo software è cambiato radicalmente. Fino al 2022 gli assistenti di programmazione erano strumenti relativamente semplici, capaci soprattutto di suggerire poche righe di codice. Oggi piattaforme come GitHub Copilot, Cursor, Claude Code di Anthropic, Gemini Code Assist di Google e Codex di OpenAI sono in grado di progettare componenti software, correggere bug, generare test automatici, proporre refactoring e, in alcuni casi, sviluppare intere funzionalità partendo da una semplice descrizione in linguaggio naturale.
L’intelligenza artificiale sta riducendo in modo significativo il tempo necessario per scrivere software. Secondo GitHub, Copilot viene ormai utilizzato da milioni di sviluppatori, mentre Microsoft ha dichiarato che in diversi progetti una quota rilevante del codice prodotto è generata con il supporto dell’IA. Parallelamente, benchmark come SWE-bench, sviluppato da Princeton University, valutano la capacità degli agenti di risolvere problemi reali presenti nei repository open source, mostrando progressi che fino a pochi anni fa sarebbero sembrati irrealistici.
La direzione appare chiara: il costo di produzione del software sta diminuendo rapidamente. Ma questa trasformazione porta con sé una domanda molto meno discussa. Se produrre codice diventa sempre più semplice, chi si occuperà di mantenerlo?
Scrivere software è soltanto l’inizio
Nell’immaginario collettivo lo sviluppo coincide con la scrittura del codice. In realtà, quella è solo la fase iniziale della vita di un’applicazione.
Ogni sistema software continua a evolversi per anni, spesso per decenni. Durante questo periodo devono essere corretti errori, aggiornate librerie, gestite vulnerabilità di sicurezza, adattate interfacce, modificate regole di business, risolti problemi di compatibilità, migliorate prestazioni e documentate le modifiche.
Come osservava già nel 1975 Frederick Brooks nel celebre The Mythical Man-Month, la complessità dello sviluppo non dipende tanto dalla scrittura del codice quanto dalla sua evoluzione nel tempo. Un concetto che, negli anni successivi, è stato ripreso da autori come Martin Fowler, Michael Feathers e Ward Cunningham, il padre dell’espressione technical debt, il debito tecnico.
Il software, infatti, non viene scritto una volta per tutte. Vive. E proprio perché vive deve essere continuamente compreso, aggiornato e modificato. Una frase spesso ripetuta dagli sviluppatori sintetizza bene questa realtà:
Il codice si scrive una volta. Si legge centinaia di volte. È durante questa lettura continua che si concentra gran parte del lavoro di un team di sviluppo.
Il vero costo del software
Numerose ricerche condotte negli ultimi anni da Microsoft Research, Google e altri gruppi di ricerca mostrano come gli sviluppatori dedichino una parte molto consistente del proprio tempo non alla produzione di nuovo codice, ma ad attività di comprensione.
Leggere programmi scritti da altri.
Ricostruire il funzionamento di sistemi sviluppati anni prima.
Capire perché una modifica ha prodotto un errore.
Analizzare dipendenze.
Verificare compatibilità.
Aggiornare framework.
Scrivere test.
Preparare documentazione.
Eseguire code review.
Queste attività sono molto meno visibili della generazione di nuove funzionalità, ma rappresentano una quota rilevante del costo complessivo del software.
Michael Feathers, autore di Working Effectively with Legacy Code, definisce “legacy” non il software vecchio, ma quello che non si comprende più. È una definizione particolarmente efficace perché sposta l’attenzione dall’età del codice alla perdita di conoscenza che inevitabilmente accompagna il passare del tempo.
Le persone cambiano azienda.
I team si riorganizzano.
La documentazione diventa incompleta.
Le motivazioni che avevano portato a determinate scelte progettuali si perdono.
Comprendere un sistema esistente diventa progressivamente più difficile. Ed è proprio questa comprensione che oggi rappresenta uno dei principali fattori di costo.
Ogni nuova riga di codice genera altro lavoro. L’intelligenza artificiale rende più semplice produrre software.
Ma ogni nuova riga di codice introduce anche nuovo lavoro futuro.
Nuove dipendenze da aggiornare.
Nuovi test da mantenere.
Nuove vulnerabilità da verificare.
Nuova documentazione da aggiornare.
Nuove interazioni con il resto del sistema.
Ward Cunningham spiegava il concetto di debito tecnico attraverso una metafora finanziaria: è possibile procedere più velocemente oggi, ma prima o poi quel debito dovrà essere ripagato.
L’IA rischia di modificare profondamente questa dinamica. Se fino a ieri il limite era rappresentato dalla capacità degli sviluppatori di produrre nuovo software, domani il limite potrebbe diventare la capacità delle organizzazioni di mantenerlo.
In altre parole, il costo marginale della produzione diminuisce, mentre cresce il patrimonio software da gestire. È un cambiamento apparentemente sottile, ma con conseguenze enormi.
Perché il software invecchia. A differenza di un edificio o di un macchinario, il software non si deteriora perché viene utilizzato. Invecchia perché cambia continuamente l’ambiente in cui opera.
I sistemi operativi evolvono.
Le librerie vengono aggiornate.
Le API vengono modificate o dismesse.
Emergono nuove vulnerabilità.
Cambiano i requisiti normativi.
Cambiano i processi aziendali.
Cambiano le aspettative degli utenti.
Ogni modifica esterna obbliga il software ad adattarsi.
Basta osservare alcuni episodi degli ultimi anni. La vulnerabilità Log4Shell, scoperta nel 2021, ha costretto migliaia di organizzazioni a individuare rapidamente dove fosse utilizzata la libreria Log4j e ad aggiornare sistemi spesso sviluppati molti anni prima. La migrazione da Python 2 a Python 3 ha richiesto anni di lavoro in moltissime aziende.
L’evoluzione continua delle API di Kubernetes, Java, .NET o Angular obbliga periodicamente a interventi di adeguamento. Il problema non consiste nello scrivere una nuova applicazione. Il problema consiste nel mantenere funzionante tutto ciò che è già stato costruito.
L’IA può aiutare dove serve davvero
Oggi quasi tutta l’attenzione mediatica è concentrata sugli strumenti che generano codice. È comprensibile. Sono spettacolari. Ma probabilmente il loro contributo più importante arriverà quando smetteranno di limitarsi a scrivere software.
L’intelligenza artificiale può infatti assistere gli sviluppatori in attività molto diverse:
* spiegare il funzionamento di sistemi complessi;
* ricostruire la documentazione mancante;
* analizzare l’impatto di una modifica;
* individuare dipendenze nascoste;
* suggerire refactoring;
* verificare compatibilità tra versioni;
* identificare vulnerabilità;
* supportare le code review;
* sintetizzare la storia evolutiva di un componente software.
Sono attività meno appariscenti rispetto alla generazione automatica del codice, ma potenzialmente molto più rilevanti dal punto di vista economico. Perché riducono il costo di gestione del patrimonio software esistente.
Il prossimo mercato dell’IA
Negli ultimi tre anni la competizione si è concentrata sulla capacità di produrre codice sempre più velocemente. È probabile che questa corsa continui. Ma ogni rivoluzione tecnologica sposta anche il punto di maggiore valore. Quando la produzione diventa abbondante, ciò che conta è la gestione. È un fenomeno già osservato in molti altri settori industriali. Lo sviluppo software potrebbe seguire la stessa dinamica.
Il vero patrimonio delle aziende non è costituito dalle nuove righe di codice che verranno generate domani, ma dai milioni di righe già presenti nei loro sistemi informativi, che continueranno a evolvere per molti anni.
Comprenderle, aggiornarle, documentarle e mantenerle rappresenterà una sfida sempre più importante.
Dalla generazione alla manutenzione
È proprio da questa consapevolezza che nasce Smart AM, il progetto sviluppato da Energee3.
L’obiettivo non è realizzare un altro assistente capace di scrivere codice, in un mercato già ricco di soluzioni eccellenti. L’idea è diversa: utilizzare l’intelligenza artificiale per supportare gli operatori che ogni giorno si occupano della manutenzione applicativa, aiutandoli a comprendere sistemi complessi, recuperare conoscenza tecnica, analizzare l’impatto delle modifiche, individuare dipendenze e rendere più efficienti i processi di evoluzione del software.
Se la scrittura del codice continuerà a diventare sempre più economica grazie all’intelligenza artificiale, la manutenzione diventerà una delle risorse più preziose dell’intero ciclo di vita del software. La prossima grande rivoluzione dell’IA applicata allo sviluppo potrebbe quindi non riguardare chi scrive più codice.
Potrebbe riguardare chi riesce a mantenere meglio quello che esiste già.
