Articoli approfonditi sulla tecnologia che plasma il futuro.

Assistenti di Codifica IA: 5 Miti, Testati

Gli assistenti di codifica IA accelerano la digitazione, non la qualità del software. Cinque miti messi alla prova su design e verifica.

Un braccio robotico riversa sul pavimento di una fabbrica mattoni luminosi che si accumulano davanti a un unico stretto varco di ispezione.
La generazione è diventata veloce. L'ispezione no, e la produttività è decisa dalla fase più lenta.

Jonathan Blow, il designer dietro Braid e The Witness, e un uomo abbastanza testardo da passare dieci anni a costruire il proprio linguaggio di programmazione, ha recentemente posto una domanda che dovrebbe far male a ogni fornitore di assistenti di codifica IA: se l'IA ha risolto la programmazione, perché il mio software è ancora lo stesso? Stessi crash. Stessi aggiornamenti gonfi. Stesse lamentele di dieci anni fa su app che divorano RAM facendo meno degli strumenti che hanno sostituito. La replica abituale, aspetta sei mesi, non basta, e non credo che Blow abbia torto a toccare il punto dolente.

Ecco la mia posizione, dopo anni di sistemi ML e dopo aver visto questi strumenti arrivare nei team reali: gli assistenti di codifica IA oggi sono davvero validi, e non hanno davvero spostato l'ago sul software che tu e io usiamo ogni giorno. Entrambe le cose sono vere allo stesso tempo, e lo sono perché questi strumenti non hanno mai puntato al vero vincolo. Il modo più chiaro per vederlo è prendere le cinque convinzioni che sento più spesso e metterle alla prova una per una.

Mito 1: Digitare è il collo di bottiglia dello sviluppo software

La premessa si scrive da sola: programmare significa produrre codice, quindi una macchina che produce codice dieci volte più velocemente rende il software dieci volte più veloce. È un sillogismo ordinato con un difetto: il lavoro di nessuno è davvero così. C'è una vecchia regola empirica, resa popolare da Clean Code, secondo cui gli sviluppatori passano molto più di dieci volte il tempo a leggere codice che a scriverlo. Quel rapporto precede gli LLM di quindici anni, ma ogni analisi seria di come si spendono le ore di ingegneria arriva allo stesso punto: capire il sistema esistente, coordinarsi con altre persone, aspettare decisioni. La digitazione è un errore di arrotondamento.

Lo senti nella tua settimana. L'autocompletamento fa risparmiare minuti reali, non vorrei rinunciarci, ma le mie giornate difficili non erano difficili perché non riuscivo a digitare abbastanza in fretta. Erano difficili perché il servizio dei pagamenti aveva un invariante che nessuno aveva scritto, o perché tre team non erano d'accordo su cosa dovesse garantire l'API. Accelerare la fase che non era lenta non cambia quasi nulla sulla produttività complessiva. Una fabbrica che stampa pezzi più in fretta di quanto la linea di ispezione riesca a smaltirli non spedisce più prodotto. Produce una pila più grande di pezzi.

C'è un solo ambito in cui la digitazione è davvero il collo di bottiglia: il greenfield, senza un sistema esistente da rispettare. Boilerplate, prototipi, script usa e getta, la prima versione di qualsiasi cosa. Ed è proprio per questo che le demo sembrano magia: le demo sono sempre greenfield. L'ingegneria di produzione è quasi interamente brownfield, e il lavoro brownfield è lavoro di lettura.

Mito 2: Il codice generato dall'IA arriva già verificato

La versione ottimistica del flusso di lavoro dice: descrivi il compito, il modello scrive il codice, i test passano, si fa il merge. Il difetto sta nel passaggio centrale. I test passano ti dice solo che i test che hai pensato di scrivere concordano con il codice che il modello ha pensato di scrivere. Entrambi possono sbagliare nella stessa direzione, e con l'output degli LLM spesso succede: il modello produce codice fluido, idiomatico, sicuro di sé, e proprio la fluidità disarma la revisione.

Ecco un piccolo esempio che ho visto in giro, nella sostanza se non nella forma esatta. Chiedi uno scheduler di job mensili e otterrai qualcosa del genere:

from datetime import datetime
def next_monthly_run(day: int, hour: int = 9) -> datetime:
"""Next run time for a job that fires monthly on `day`."""
now = datetime.now()
candidate = now.replace(day=day, hour=hour, minute=0, second=0, microsecond=0)
if candidate <= now:
# Roll forward one month
month = now.month % 12 + 1
year = now.year + (1 if now.month == 12 else 0)
candidate = candidate.replace(year=year, month=month)
return candidate

Leggilo come faresti con la pull request di un collega. È idiomatico. Gestisce il cambio d'anno. Anche la docstring è corretta. Ora eseguilo il 15 aprile con day=31: now.replace(day=31) solleva ValueError, perché aprile non ha un 31. La funzione va in crash proprio per la richiesta di pianificazione più comune, la fine del mese, e solo nei mesi più corti, quindi può restare in produzione apparentemente sana per settimane prima che qualcuno se ne accorga. Un test che itera su un anno intero di valori di now lo individua in pochi secondi. Un revisore umano attento lo individua forse metà delle volte. Quel divario è il problema della verifica in miniatura.

Per questo continuo a sostenere che in un flusso di lavoro dominato dall'IA la scelta tra controlli di comprensione e test non è una questione accademica: è tutta la partita. Leggere codice che non hai scritto è già più difficile che scriverlo. Leggere codice che nessun essere umano ha scritto, al volume che questi strumenti producono, ribalta completamente l'economia della revisione. I team con cui parlo non sono più a corto di codice. Sono a corto di persone che capiscano cosa fa il codice e siano disposte a firmarlo.

Una lente d'ingrandimento rivela una crepa capillare su una lastra di marmo lucidata.
Il codice plausibile si rompe come il marmo: lungo una crepa che vedi solo se guardi davvero.

Mito 3: Codice più economico significa design del software economico

Una convinzione più sottile: se il codice è quasi gratuito, l'architettura conta meno, perché possiamo sempre riscrivere. Astrazione sbagliata? Rigenerala. Modello dei dati sbagliato? Rigenera anche quello. Ho sentito ingegneri senior dirlo con la faccia seria, e confonde il costo di cambiare il testo con il costo di cambiare le decisioni.

La parte difficile del software non è mai stato il codice. È decidere cosa valga la pena costruire, modellare un dominio umano disordinato in qualcosa che una macchina possa eseguire, e fare scommesse architetturali che non crollino quando i requisiti cambiano, e cambiano sempre. Sono problemi di intenzione e di valori, non di completamento di pattern. Un modello addestrato sul corpus del software esistente può dirti come di solito sono fatti sistemi come il tuo. Non può dirti come dovrebbe essere il tuo, perché quella risposta sta nei tuoi utenti, nei tuoi vincoli e nella propensione al rischio della tua organizzazione. Su questo fronte non abbiamo fatto sostanzialmente progressi, e sostengo che non sia un divario di capacità che si possa colmare scalando. È un errore di categoria.

Anche le riscritture non sono gratuite. La maggior parte del budget d'ingegneria si spende nel modificare sistemi che esistono già, e modificare un sistema significa prima ricostruire l'intenzione incorporata in esso: gli invarianti mai documentati, il caso limite che si rivela portante per un cliente importante. Il modello non conosce quell'intenzione. Spesso non la conosce nemmeno il team. Questo è il divario tra specifica e implementazione, dove vivono davvero i bug, e generare altra implementazione lo allarga, a meno che qualcuno non tenga stretta la specifica.

Fred Brooks aveva un termine per ciò che rende il software coerente: integrità concettuale, la sensazione che a decidere sia stata una mente sola, o poche menti allineate. La generazione fluida di codice non ci avvicina a questo. Anzi, rende più economiche mille micro-decisioni non allineate, ed è così che ottieni sistemi che sembrano progettati e si comportano come assemblati.

Mito 4: Il software invariato dimostra che la codifica con IA ha fallito

Ora il contrappunto, perché anche la tesi di Blow non è inattaccabile. Guarda oltre il software commerciale di massa e le cose si stanno muovendo. La scena dei giochi indie ha prodotto strategici con motori personalizzati, realizzati da piccoli team, che dieci anni fa avrebbero richiesto l'organico di Blizzard. Ancora più sorprendente per me è la silenziosa ascesa del software personale: persone che costruiscono i propri client email, app per il calendario, tracker finanziari e frontend per git, modellati esattamente su come pensano. Questi strumenti sono grezzi e non sopravvivrebbero alla distribuzione a diecimila sconosciuti. Ma esistono, vengono usati ogni giorno, e semplicemente prima non era conveniente costruirli.

Anche le istituzioni stanno cambiando in modi che la metrica principale non vede. Conosco organizzazioni il cui piano di modernizzazione consiste, in sostanza, nell'esporre il sistema legacy tramite API decenti e lasciare che il personale costruisca sopra, con uno strumento di codifica agentico, i propri endpoint e le proprie interfacce. Non è "il mio software è uguale". È software che si dissolve in qualcosa di più personale, invisibile se guardi solo le classifiche dello store delle app.

La ragione più profonda per cui l'osservazione di Blow sembra vera, però, è organizzativa più che tecnica. Il software commerciale è plasmato da ciò che le aziende ottimizzano (engagement, lock-in, cadenza dei rilasci, costo del supporto), e l'IA ti dà più di ciò che già vuoi, più in fretta. Non cambia ciò che vuoi. Un'azienda che ha spedito software gonfio perché il gonfiore non compariva nel suo bilancio costi, ora spedirà software gonfio con cicli di sviluppo più brevi. L'asticella di qualità per il software distribuito a migliaia di utenti la fissano incentivi, disciplina di test e gusto, nessuno dei quali è un output di modello.

C'è anche un semplice argomento di ritardo. La codifica IA davvero affidabile ha forse un anno; il periodo precedente era instabile, e prima ancora era un giocattolo. I prodotti richiedono anni per essere concepiti, costruiti e rilasciati. Giudicare oggi l'effetto di questi strumenti sul software rilasciato è come giudicare un nuovo aratro dal raccolto di un mese dopo la sua invenzione.

Mito 5: Il prossimo modello colmerà il divario

La versione più forte del caso degli ottimisti: ogni obiezione sopra descrive i modelli di oggi, e i modelli di oggi sono i peggiori che useremo mai. In parte è vero. Le finestre di contesto cresceranno, le API inventate diminuiranno, gli agenti diventeranno più bravi a eseguire i propri test. Mi aspetto guadagni reali, soprattutto su compiti ben specificati.

Ma nota quali colli di bottiglia sono problemi di capacità e quali no. La verifica diventa più facile man mano che i modelli diventano più affidabili, e questa è capacità. Decidere cosa valga la pena costruire, mantenere l'integrità concettuale, cambiare ciò che un'organizzazione ottimizza: nessuna di queste cose compare in una roadmap di modelli, perché non sono problemi del modello. E fai attenzione a usare i progressi nei benchmark come prova: i benchmark non colgono gran parte di ciò che il lavoro reale è, e il lavoro reale è proprio il tipo sottospecificato e carico di intenzioni.

Quindi ecco la mia scommessa, messa per iscritto: gli strumenti miglioreranno parecchio per i singoli costruttori e per i piccoli team con buon gusto, mentre il software di massa migliorerà marginalmente, se non affatto, perché lì il vincolo non è mai stato il codice. Se sembra pessimismo, non lo è. Significa che la leva sta nelle tue mani e nell'organigramma, non nella prossima release di un laboratorio.

Un giardiniere pota un bonsai su un banco da lavoro illuminato dal sole, con attrezzi manuali.
La qualità del software è ancora un problema di cura, non di produzione.

Cosa migliora davvero la qualità del software

Se generare è economico e verificare è costoso, la risposta razionale è spostare gli investimenti. Concretamente:

  • Tratta test e tipi come infrastruttura di produzione. Test basati su proprietà, controlli di invarianti e CI veloce sono ciò che trasforma una generazione economica in una generazione economica e corretta. Pianificali come pianifichi il calcolo.
  • Scrivi la specifica prima del prompt. La specifica è oggi l'artefatto a più alta leva che un team produce, perché è ciò che il modello non può fornire e ciò che i revisori verificano.
  • Usa l'IA dove è davvero forte: prototipi greenfield, migrazioni, boilerplate, strumenti personali, esplorazione rapida di uno spazio di design. Diffida di essa nei percorsi legacy portanti dove l'intenzione non è documentata.
  • Proteggi il tempo di design. Quando la velocità di generazione triplica, la pressione è riempire la roadmap tre volte. Resisti. Decidere è il lavoro.

Il collo di bottiglia non è mai stato la digitazione. È sempre stato il decidere, e il dimostrare.

La domanda di Blow ha una risposta, e se la leggi bene è una risposta speranzosa. Il software resta uguale perché la sua qualità è sempre stata vincolata dal decidere, dal verificare e dal curarsi, e gli assistenti di codifica IA, con tutta la loro reale utilità, accelerano la parte che non è mai stata lenta. Il che significa che gli strumenti per rendere il software migliore sono quelli di sempre: gusto, specifica e la disciplina di dimostrare le cose. I modelli hanno solo reso impossibile continuare a fingere il contrario.