Il debito tecnico è il lavoro arretrato che rende più lenta e rischiosa ogni modifica a un software. Si immagini una modifica che sei mesi fa richiedeva due giorni e oggi ne richiede dieci, senza che nessuno abbia scritto codice peggiore: è un sintomo tipico, e in azienda arriva come problema di tempi, non di codice.
Il debito tecnico è il costo futuro del lavoro non fatto nel software: scorciatoie scelte, errori di progettazione scoperti dopo, codice rimasto indietro rispetto alle tecnologie. Il risultato è che ogni modifica diventa più lenta e più rischiosa. Ward Cunningham coniò la metafora nel 1992. Come un debito finanziario, non è sbagliato in sé: diventa un problema quando gli interessi, cioè il tempo perso a ogni cambiamento, superano il vantaggio iniziale.
Da dove viene il termine e cosa significa per un'azienda?
Il debito tecnico è il lavoro arretrato che un sistema software accumula quando si sceglie la soluzione più rapida, quando si scopre tardi come andava progettato o quando il codice resta indietro rispetto alle tecnologie su cui poggia. Il nome viene da Ward Cunningham, che nel 1992, in un report presentato a OOPSLA, paragonò il primo rilascio di un codice a un prestito: un po' di debito accelera lo sviluppo, a patto di ripagarlo in fretta.
Il pericolo, scriveva Cunningham, nasce quando il debito non viene ripagato. Ogni riga di codice non corretta diventa un interesse che si paga a ogni modifica successiva.
Per un'azienda la traduzione è semplice. Il debito tecnico non compare a bilancio. Si vede nei tempi: funzionalità che costano sempre di più, rilasci che slittano, incidenti in produzione su parti del sistema che nessuno vuole toccare.
Quali tipi di debito tecnico esistono?
Non tutto il debito è uguale, e la distinzione più utile non riguarda il codice ma l'intenzione. Martin Fowler la sintetizza in un quadrante che incrocia due domande: il debito è stato preso consapevolmente o no, e con prudenza o con imprudenza. La tabella riprende i casi consapevoli del quadrante, riunisce quelli involontari e aggiunge un caso che il quadrante non tratta: il debito da obsolescenza.
| Tipo | Come nasce | Esempio tipico |
|---|---|---|
| Consapevole e prudente | Si sceglie di rimandare per rispettare una scadenza, sapendo cosa si lascia indietro | Lancio con un modulo semplificato da rifare nel trimestre successivo |
| Consapevole e imprudente | Si rinuncia alla qualità per abitudine o pressione | "Non abbiamo tempo per i test", ripetuto a ogni sprint |
| Involontario | Il team capisce solo dopo come andava progettato il sistema | Un'architettura che non regge la crescita del prodotto |
| Da obsolescenza | Il codice resta fermo mentre il contesto cambia | Dipendenze non aggiornate, framework fuori supporto, software legacy |
Il primo tipo è una decisione di business legittima. Gli altri tre sono più difficili da governare, perché raramente qualcuno li mette in agenda con una data di rientro.
Come si misura il debito tecnico?
Si misura con due famiglie di indicatori: quelli che leggono il codice e quelli che leggono il lavoro del team. Servono entrambi.
- Analisi statica del codice. Strumenti come SonarQube stimano il costo per correggere i problemi di manutenibilità e lo rapportano al costo per sviluppare il codice. Il risultato è il technical debt ratio, che la documentazione di SonarQube traduce in un rating di manutenibilità: A fino al 5%, E dal 50% in su.
- Tempo di cambiamento. Quanto impiega una modifica a passare dal commit alla produzione, e come cambia nel tempo sulle stesse parti del sistema.
- Incidenti e regressioni. Dove si rompe il software dopo un rilascio. Se i guasti si concentrano negli stessi moduli, è un buon indizio di dove guardare per primo, anche se le cause possono essere altre.
Nessun numero da solo basta. Il ratio stima lo sforzo di correzione rispetto allo sforzo di sviluppo, ma non dice quanto il debito pesa sul business; il tempo di cambiamento mostra dove il lavoro rallenta, ma non perché. Per stimare il costo per l'azienda bisogna tradurre quel rallentamento in ore di team e in funzionalità rimandate.
Refactoring o riscrittura: come si decide?
Il punto di partenza ragionevole è il refactoring incrementale. La riscrittura si giustifica in condizioni precise.
Il refactoring migliora il codice esistente a piccoli passi, senza cambiare il comportamento, e permette di continuare a rilasciare funzionalità nel frattempo. Funziona quando l'architettura regge ancora e il problema è la qualità del codice dentro i moduli.
La riscrittura ha senso quando il debito è nell'architettura stessa, quando la tecnologia non ha più supporto o quando nessuno nel team riesce più a modificare una parte del sistema con sicurezza, ed è comunque una scommessa costosa, perché per un periodo si mantengono due sistemi in parallelo mentre il business continua a chiedere novità a quello vecchio.
Un criterio pratico: si riscrive solo ciò che si può isolare. Sostituire un modulo alla volta, dietro un'interfaccia stabile, riduce il rischio rispetto alla riscrittura completa.
Per decidere quale debito ripagare prima, conviene incrociare tre domande:
- Impatto. Quanto spesso il business chiede modifiche in quella parte del sistema.
- Rischio. Quanto è probabile un incidente se non si interviene.
- Sforzo. Quanto costa l'intervento e chi nel team può farlo.
Il debito in moduli che nessuno tocca può aspettare. Quello nelle parti che cambiano ogni sprint va messo in roadmap con un responsabile e una data di revisione.
Il codice scritto con l'IA aumenta il debito tecnico?
Può farlo. Oltre alla qualità del codice generato, conta il volume: gli assistenti di programmazione producono codice funzionante molto in fretta, e se la revisione non tiene il passo il team accumula codice che non conosce davvero.
Il debito nasce lì. Codice che passa i test ma che nessuno nel team saprebbe spiegare. Duplicazioni che nessuno nota. Dipendenze aggiunte senza una decisione esplicita. È una forma nuova di debito involontario, e si gestisce con le pratiche di sempre: code review che entrano nel merito, test automatizzati, regole chiare su cosa si accetta in produzione.
È anche una parte dell'implementation gap dell'IA in azienda: adottare gli strumenti è facile, integrarli senza peggiorare il sistema che li riceve richiede competenze che non arrivano con la licenza.
Chi riduce il debito tecnico nel lavoro quotidiano?
Chi sviluppa, ogni giorno. Secondo l'analisi di mercato di Shakers su 42.052 offerte tech pubblicate in Italia tra l'8 luglio e il 15 novembre 2026, 237 annunci di 118 aziende indicano esplicitamente il debito tecnico (o technical debt) tra le responsabilità del ruolo, e 357 richiedono attività di refactoring.
Metodo: offerte raccolte da Shakers Market, ricerca testuale nella descrizione con verifica del termine in tutti i 237 annunci; un annuncio conta una volta anche se ripubblicato (172 combinazioni uniche di azienda e titolo). I due gruppi si sovrappongono in 36 annunci. È un campione, non un censimento.
Quasi sei su dieci dei 237 annunci che citano il debito tecnico sono posizioni di Software Engineering. Altri arrivano da ruoli di prodotto, che devono bilanciare debito tecnico e time-to-market nella roadmap.
La lettura per un CTO è che la riduzione del debito non è un progetto da affidare a qualcuno una volta l'anno: è una competenza che serve dentro il team, accanto a code review e CI/CD. Quando il team interno non ha il tempo o l'esperienza su uno stack specifico, si può collaborare con specialisti per una fase precisa, come la modernizzazione di un modulo legacy o la messa in sicurezza dei test, mantenendo la proprietà del sistema in casa.
Domande frequenti sul debito tecnico
- Che cos'è il debito tecnico?
-
È il costo futuro del lavoro non fatto nello sviluppo software: scorciatoie scelte, errori di progettazione scoperti dopo o codice rimasto indietro, che rendono più lente e rischiose le modifiche successive. La metafora è di Ward Cunningham (1992): un po' di debito accelera lo sviluppo, ma se non viene ripagato gli interessi, cioè il tempo perso a ogni cambiamento, crescono fino a frenare il prodotto.
- Il debito tecnico è sempre un problema?
-
No. Prendere debito consapevolmente per rispettare una scadenza è una decisione di business legittima, se si sa cosa si lascia indietro e si pianifica quando ripagarlo. Diventa un problema quando si accumula senza che nessuno l'abbia scelto, per abitudine, per pressione costante o perché il codice resta fermo mentre tecnologie e requisiti cambiano.
- Come si calcola il debito tecnico?
-
Gli strumenti di analisi statica come SonarQube stimano il costo per correggere i problemi di manutenibilità e lo confrontano con il costo per sviluppare il codice: il risultato è il technical debt ratio, tradotto in un rating da A a E. Va letto insieme al tempo di cambiamento e alla frequenza degli incidenti, che mostrano dove il debito rallenta il lavoro.
- Quando conviene riscrivere un software invece di fare refactoring?
-
Quando il debito è nell'architettura e non solo nel codice, quando la tecnologia non ha più supporto o quando nessuno riesce più a modificare il sistema con sicurezza. Anche in quei casi conviene riscrivere un modulo alla volta, dietro un'interfaccia stabile, invece di sostituire tutto insieme e mantenere due sistemi in parallelo a lungo.
- Chi deve occuparsi del debito tecnico in azienda?
-
La decisione su quanto debito accettare spetta a chi guida tecnologia e prodotto insieme, perché è un compromesso con il time-to-market. La riduzione, invece, avviene nel lavoro quotidiano di chi sviluppa: nelle offerte tech italiane analizzate da Shakers, quasi sei su dieci di quelle che citano il debito tecnico sono posizioni di Software Engineering.
Il debito tecnico non si elimina, si governa. Serve sapere dove si trova, quanto costa ogni mese in tempi di sviluppo e quale parte conviene ripagare per prima. Il resto è disciplina quotidiana.
Shakers è la piattaforma di talento tech certificato in competenze tecnologiche e IA: specialisti che collaborano con i team interni nelle fasi in cui il debito va affrontato, dalla modernizzazione del legacy al refactoring. Sono disponibili specialisti Backend Developer, Java Developer e Fractional CTO, con cui collabora Shakers.
. 