L’IA ha spostato il collo di bottiglia, non lo ha eliminato
Di Xavier Franco, CEO de Elternativa · Grupo Zemsania
· 7 min di lettura
Redatto con l’aiuto dell’IA e rivisto da Xavier Franco

In questo articolo
L’abbiamo vissuto noi prima di chiunque altro. Dà l’IA al Suo team di sviluppo, il codice comincia a uscire il doppio più in fretta e, qualche settimana dopo, qualcuno Le dice che le consegne non sono accelerate altrettanto. Il collo di bottiglia non è sparito: si è spostato. Se dirige la tecnologia, Le conviene sapere dove, perché lì sta la differenza tra avere l’IA e avere un’IA che scala.
Scrivere codice non è più il problema
Per anni il collo di bottiglia dell’SDLC, il ciclo di vita dello sviluppo software, stava nello scrivere codice. Mancavano le mani. L’IA ha risolto quella parte meglio di quanto ci aspettassimo: secondo il sondaggio di Stack Overflow del 2025, con più di 49.000 risposte, l’84 % degli sviluppatori usa già o pensa di usare strumenti di IA.
Ma il ciclo non finisce con la scrittura. Dopo bisogna revisionare, testare, integrare, documentare e verificare. E queste fasi continuano a funzionare al ritmo di prima, con le stesse persone.
Il risultato è facile da immaginare: ogni persona produce il doppio e chi revisiona resta lo stesso. La coda si accumula proprio dove avevamo già meno persone.
In pratica: guardi le Sue pull request dell’ultimo mese. Quanto tempo passa in media tra l’apertura e l’approvazione di una pull request? Se quel tempo è aumentato da quando usate l’IA, sa già dov’è il Suo nuovo collo di bottiglia.
Il tecnico vuole capire tutto, ed è ragionevole
C’è un punto che mi sembra importante, perché a volte viene presentato come un problema di atteggiamento e non lo è. Il tecnico vuole capire tutto ciò che fa l’IA prima di darlo per buono. È ragionevole: non ha il controllo.
I dati lo confermano. Nello stesso sondaggio di Stack Overflow, il 46 % degli sviluppatori dice di non fidarsi dell’accuratezza di ciò che generano gli strumenti di IA, contro il 31 % dell’anno precedente. E per il 45 %, una delle frustrazioni principali è che il debug del codice generato dall’IA richiede molto tempo.
A questo si aggiunge il disordine che nasce quando ciascuno lavora con la propria IA a modo suo:
- la stessa cosa fatta in due modi in due parti del sistema;
- ciò che si è imparato resta in una conversazione che nessuno rileggerà;
- nessuno sa chi ha scritto cosa: se una persona o un modello.
In queste condizioni, revisionare riga per riga non è sfiducia. È l’unica forma di controllo che abbiamo lasciato al tecnico.
In pratica: chieda al Suo team che cosa li preoccupa quando revisionano codice generato dall’IA. Le diranno dove manca il metodo.
Il controllo sta nel contratto, non nel leggere ogni riga
La soluzione non è revisionare più in fretta. È spostare il controllo all’inizio del ciclo. Se prima che l’IA scriva una riga è già stabilito che cosa deve fare, entro quali limiti e con quali test, la revisione smette di essere una lettura completa e diventa una verifica rispetto a qualcosa di concreto.
Così lo impostiamo noi, fase per fase:
- Requisito e piano. Ogni attività nasce con i criteri di accettazione fissati in anticipo. Non cambiano dopo.
- Sviluppo. Più istanze di IA lavorano in parallelo, senza che nessuno debba inseguirle.
- Test. Li esegue un’istanza diversa da quella che ha scritto il codice. Nessuno convalida il proprio lavoro.
- Revisione e convalida. Una persona del Suo team convalida la chiusura rispetto ai criteri, e la sua firma viene registrata.
- Pull request e rilascio. L’IA apre la pull request e rispetta il Suo Git e il Suo CI/CD.
- Evolutive e supporto. Nella stessa coda, con ciò che si è imparato trasformato in regole che l’attività successiva riceve già.
Il tecnico smette di inseguire l’IA. Definisce, convalida e decide.
In pratica: prenda la prossima funzionalità che intende costruire e scriva i suoi criteri di accettazione prima di cominciare. Già solo questo cambia la revisione.
Integrare, documentare e verificare fanno parte del ciclo
Le altre tre fasi che si inceppano hanno bisogno della stessa cosa: metodo, non più ore.
- Integrare. Uno stesso metodo e le stesse regole per ogni IA, e ogni attività riserva le risorse che le servono, in modo che due lavori in parallelo non si pestino i piedi.
- Documentare. La conoscenza del progetto (norme, decisioni e riunioni) vive in un sistema che l’IA consulta, non nella testa di una persona né in una conversazione perduta.
- Verificare. Tutto è tracciato: chi ha chiesto, chi ha fatto, chi ha convalidato e quanto è costato.
Quando queste fasi funzionano, l’effetto dell’IA si vede nelle consegne e non solo nella velocità di scrittura.
In pratica: cerchi nel Suo ultimo progetto una decisione tecnica importante. È scritta da qualche parte in cui la prossima persona, o la prossima IA, possa trovarla?
Che cosa misurare per sapere se l’IA scala
C’è un rischio che vedo spesso: misurare l’IA dalla sensazione di velocità. «Andiamo più veloci» è una percezione, non un dato. Il rapporto DORA 2025 di Google, con quasi 5.000 professionisti della tecnologia, lo mette in numeri: il 90 % usa l’IA al lavoro e più dell’80 % crede di aver guadagnato produttività. Ma il 30 % si fida poco o per niente del codice che genera.
E c’è un dato dello stesso rapporto che credo ogni direttore tecnologico dovrebbe avere in mente: l’adozione dell’IA è ormai associata a più velocità di consegna, ma resta associata a meno stabilità. Più modifiche, più in fretta, e più cose che si rompono se mancano test solidi, un controllo di versione maturo e cicli brevi. DORA lo riassume in una frase: l’IA non aggiusta un team, amplifica ciò che c’è già.
Per questo, se vuole sapere se la Sua IA scala, misuri sul Suo repository, non con sondaggi interni:
- consegne a settimana e tempo fino alla produzione;
- tempo di revisione di ogni pull request;
- rilavorazione, cioè quanto di ciò che è stato consegnato va ritoccato;
- guasti dopo il rilascio;
- quale parte delle consegne esce dal flusso con l’IA e quale parte si fa ancora a mano.
In pratica: ricavi oggi queste cinque cifre, prima di cambiare qualsiasi cosa. Senza una fotografia del prima, non saprà mai se il dopo è migliore.
Da dove cominciare
Il mio consiglio è di non cercare di cambiare tutto il ciclo in una volta:
- Misuri il collo di bottiglia attuale: tempo di revisione, rilavorazione e pull request aperte.
- Scelga un team e un tipo di lavoro circoscritto e ripetibile: evolutive, debito tecnico o test.
- Fissi i criteri prima di cominciare e separi chi costruisce da chi testa.
- Lasci che sia una persona a convalidare, rispetto ai criteri, non alla sua intuizione.
- Confronti per qualche settimana consegne, rilavorazione e tempo fino alla produzione, sul Suo repository.
Se i numeri migliorano, ha l’argomento per scalare. E se non migliorano, saprà esattamente in quale fase intervenire.
Come La aiutiamo
In Agentic Data & Software Engineering orchestriamo le IA di sviluppo che ha già, come Claude Code, Cursor, Codex o Copilot, lungo tutto l’SDLC: più istanze in parallelo, test eseguiti da un’istanza diversa e una persona del Suo team che convalida ogni chiusura. Il codice resta nel Suo Git e la conoscenza in un database Suo. Sul sito pubblichiamo ciò che misuriamo sul codice dei nostri clienti: fino a 2 volte più capacità in ingegneria dei dati e del software con lo stesso team.
Lo facciamo con Agentagile, la nostra metodologia per sviluppare con l’IA: la Sua IA sviluppa, testa e documenta; il Suo team decide. Niente avanza senza il Suo benestare.
Chi revisiona tutto ciò che scrive la Sua IA?
Le mostriamo in una demo come più IA di sviluppo costruiscono in parallelo, un’altra testa e il Suo team convalida ogni consegna.


