Ciao, e benvenuto nell'ottava puntata della sessantacinquesima stagione. Finora abbiamo parlato soprattutto del momento in cui scrivi il codice. Ma il codice non vive solo in quell'istante: vive per anni, dopo che tu l'hai scritto. E questa vita lunga cambia completamente il conto dei costi. Oggi guardiamo cosa succede dopo, quando l'euforia della velocità è passata. Oggi parliamo del codice che non capisci, tra manutenzione e futuro.
Partiamo da una verità che sfugge ai principianti, perché ribalta l'intuizione. Il codice si scrive una volta, ma si legge cento volte. La maggior parte della vita di un programma non è la scrittura, ma la manutenzione: correggere errori, aggiungere funzioni, adattarlo a nuove esigenze, capirlo di nuovo dopo mesi. E per fare tutto questo bisogna, prima di ogni altra cosa, leggerlo e comprenderlo. Un codice si giudica non da quanto è stato veloce scriverlo, ma da quanto sarà facile conviverci negli anni. E qui l'IA introduce un rischio nuovo e insidioso.
Vediamo qual è questo rischio, perché è la trappola centrale di oggi. L'IA rende facilissimo produrre grandi quantità di codice in fretta. Sembra un vantaggio puro, ma nasconde un tranello. Se generi montagne di codice che accetti senza padroneggiarlo davvero, stai riempiendo il tuo progetto di parti che nessuno comprende fino in fondo. Nel momento stesso in cui le scrivi va tutto bene, funziona. Ma tra sei mesi, quando qualcosa si romperà lì dentro, ti troverai a fissare un codice tuo di nome, ma estraneo di fatto, incapace di dire perché fa quello che fa. Hai accelerato la scrittura, ma hai appesantito, e di molto, tutta la vita che viene dopo.
Voglio darti l'immagine che rende chiara questa idea, perché la fissa. Immagina di costruire una casa in tempo record, facendo posare le fondamenta a una squadra velocissima, senza mai ispezionare tu cosa hanno fatto sotto terra. La casa si tira su in fretta, sembra perfetta, ci vai ad abitare felice. Ma il giorno che compare una crepa, e comparirà, ti accorgi di non sapere niente di come sono fatte le fondamenta su cui poggia tutto. Non sai dove intervenire, non sai nemmeno se sono sicure. Un codice generato in fretta e mai compreso è una casa costruita su fondamenta che non hai mai ispezionato: comoda oggi, angosciante domani.
Voglio allargare lo sguardo alle persone, perché il codice non è mai solo tuo. Nel lavoro vero, il codice che scrivi lo leggeranno altri: i colleghi di oggi, e chi arriverà dopo di te. Se riempi un progetto di codice che nemmeno tu capisci, stai lasciando un'eredità pesante a chi verrà. E c'è un'altra faccia: quando l'IA scrive tutto in modo mediamente corretto ma senza una vera anima, i progetti tendono a somigliarsi, a perdere quella coerenza e quella cura che nascono da una mente che ha davvero pensato l'insieme. La leggibilità per gli altri, la coerenza del progetto, non sono lussi: sono ciò che tiene in piedi un lavoro di squadra nel tempo.
Voglio dirti come si evita tutto questo, perché la soluzione è alla tua portata. La regola è quella di sempre, applicata al lungo periodo: fai entrare nel progetto solo codice che capisci e di cui rispondi. Meglio poche righe che padroneggi che mille che ti sono estranee. Prenditi il tempo di comprendere, ristrutturare, dare coerenza a ciò che l'IA ti propone, invece di ammucchiarlo così com'è. Vai un po' più piano nella scrittura, per andare molto più veloce in tutti gli anni che seguono. La velocità che conta non è quella di oggi, ma quella dell'intera vita del progetto. Questo vale ancora di più se lavori da solo, senza un collega che riveda ciò che scrivi: sei tu l'unico argine, e la disciplina di capire ciò che accetti è tutto ciò che ti separa da un progetto che sfugge di mano.
Voglio darti la lezione generale, perché vale in ogni costruzione umana. La lezione è che è facile ottimizzare per l'oggi e pagarne il prezzo per sempre. La fretta che sembra un guadagno spesso è solo un debito spostato in avanti, che qualcuno pagherà con gli interessi, e quel qualcuno, spesso, sei tu tra sei mesi. Costruire pensando al futuro, a chi manterrà e a chi erediterà, non è pignoleria: è la differenza tra chi lascia macerie ordinate e chi lascia case in cui si può ancora abitare.
Per oggi ci fermiamo qui. Abbiamo guardato oltre l'istante della scrittura. Il codice si scrive una volta e si legge cento volte: la sua vera vita è la manutenzione. L'IA rende facile produrre montagne di codice, ma se lo accetti senza padroneggiarlo riempi il progetto di parti che nessuno capisce, e il conto arriva quando qualcosa si rompe. Come una casa su fondamenta mai ispezionate. E il codice non è solo tuo: lo erediteranno altri, e la sua leggibilità e coerenza tengono in piedi il lavoro nel tempo. La soluzione: far entrare solo codice che capisci, andare più piano oggi per volare domani. La lezione: ottimizzare per l'oggi si paga per sempre. Nella prossima puntata: abbracciarla o diffidarne? Nelle note trovi qualche spunto. Se ti è utile, condividila. Grazie per l'ascolto, e ci sentiamo alla prossima.