Leader di pensiero
Perché i test devono far parte della linea di assemblaggio dell’IA fin dall’inizio

Punti chiaveL'IA accelera la programmazione ma espone test downstream deboli e riduce la stabilità…
Vedi di più
- L'IA accelera la programmazione ma espone test downstream deboli e riduce la stabilità delle consegne.
- Gli agenti che giudicano i propri test possono barare modificando i test falliti invece di correggere il codice.
- I test devono essere una stazione a sé stante al di fuori della CI, così ogni modifica affronta lo stesso verdetto.
Da oltre vent’anni sviluppo strumenti per i test e, per la maggior parte di questo tempo, le mie conversazioni con i team di ingegneria sono state piuttosto simili. Nel ciclo di vita del software, chi si occupava dei test si sentiva un cittadino di serie B. I test venivano eseguiti tardi, spesso ritagliando il tempo rimasto prima di una release, e inseriti in una pipeline CI progettata per tutt’altro. L’IA ha ormai trasformato il modo in cui scriviamo codice, e il suo impatto sui test è innegabile, nel bene e nel male. Per molti aspetti, l’IA ha reso la sfida più evidente.
Negli ultimi mesi ho partecipato a diverse conferenze sui test e sul cloud native (LeadDev, CloudX, StarWest) e quasi tutti i team con cui ho parlato stanno lavorando a una versione dello stesso progetto: un ciclo di vita dello sviluppo e della distribuzione del software guidato dall’IA, in cui gli agenti portano il lavoro da una specifica a qualcosa che gira in produzione, con il giusto livello di coinvolgimento umano lungo il percorso. Me lo immagino come una linea di assemblaggio. Gli agenti scrivono il codice, altri agenti lo revisionano e le pipeline lo compilano e lo distribuiscono. Gli esseri umani tengono d’occhio il processo. Si parla molto meno di quale posto occupino i test lungo quella linea.
Nessuno ha ancora capito come fare
Al momento è un po’ il Far West. Ogni poche settimane arrivano nuove capacità degli agenti, i grandi laboratori di IA continuano a rilasciare nuovi modelli e team e fornitori provano un po’ di tutto per vedere cosa funziona.
Alcuni dati suggeriscono che le lacune stiano già emergendo. L’ultimo rapporto DORA sullo sviluppo software assistito dall’IA di Google, basato su un sondaggio condotto tra quasi 5.000 professionisti della tecnologia, ha rilevato che l’adozione dell’IA è associata a una maggiore produttività nella distribuzione del software, il che è una buona notizia. È ancora associata, però, a una minore stabilità delle release. Secondo i ricercatori, l’IA accelera lo sviluppo e mette in evidenza le debolezze nelle fasi successive; indicano inoltre test automatizzati solidi come uno dei meccanismi di controllo che impediscono che un maggior numero di modifiche si traduca in una maggiore instabilità.
Non mi sorprende. Se fai passare molto più codice attraverso un processo progettato per gestirne molto meno, da qualche parte il processo rallenta o si rompe.
Gli sviluppatori sono più veloci, ma la maggior parte delle release no
Quando si immagina cosa possa andare storto con il codice generato dall’IA, si tende a pensare a un agente che manda in produzione qualcosa di terribile. Sono certo che succeda, e quando accade le conseguenze non sono piacevoli: bug, clienti insoddisfatti, magari un incidente di sicurezza. Ma, a dire il vero, non è ciò che mi capita più spesso.
Il Sondaggio 2026 di Stack Overflow sugli sviluppatori mostra in quali ambiti si concentra oggi l’uso dell’IA. Gli sviluppatori la usano soprattutto per generare codice in ambiti che già conoscono (67%) e per il debug (61%), mentre solo il 20% la usa per distribuire, gestire o risolvere problemi nei sistemi di produzione. Finora, l’IA ha accelerato soprattutto la scrittura del codice. La verifica di quel codice e la sua messa in produzione funzionano ancora, per lo più, come prima.
Questo corrisponde anche a ciò che vedo: i team producono molto più codice, ma non rilasciano più rapidamente. Un singolo sviluppatore o un team può avere l’impressione di realizzare il doppio delle funzionalità, ma queste restano bloccate nelle fasi successive, in attesa di una revisione, dei test o di un ambiente in cui eseguirli. Tutto quel codice in più intasa la pipeline e, in molti casi, rallenta persino la velocità complessiva di distribuzione dei team.
Le domande sulle misure di salvaguardia arrivano dai manager
Anche se la preoccupazione per i colli di bottiglia nel rilascio causati dall’IA è molto concreta, non è l’unica questione su cui i team ci interpellano. Gli sviluppatori vogliono soprattutto sapere come scrivere codice migliore più velocemente. Le domande sulle misure di sicurezza arrivano dai responsabili dell’ingegneria e da chi configura questi flussi di lavoro basati su agenti. Come possiamo assicurarci che gli agenti non sfuggano al controllo? Come facciamo a sapere che non introducano regressioni o che non trascurino di nascosto attività che avrebbero dovuto svolgere? Come possiamo assicurarci che i test che scrivono verifichino davvero (e in modo veritiero!) ciò che dovrebbero verificare?
Credo che dipenda dal fatto che guardano cose diverse. Uno sviluppatore considera una richiesta pull alla volta. Un responsabile dell’ingegneria risponde di tutto ciò che viene rilasciato da numerosi agenti e persone, ed è lui a doverne rendere conto quando qualcosa si rompe in produzione.
E hanno buoni motivi per essere cauti. I ricercatori hanno creato un benchmark chiamato ImpossibleBench basato su attività di programmazione in cui i test unitari contraddicono le specifiche, perciò l’unico modo per superarli è barare. I modelli più avanzati spesso hanno fatto proprio questo, per esempio modificando o cancellando i test non riusciti invece di correggere il codice (!!). Un studio sulle richieste pull scritte dagli agenti ha rilevato lacune nella capacità degli agenti di testare le proprie modifiche e cita ricerche precedenti secondo cui quasi un terzo delle richieste pull degli agenti integrate nel codice richiedeva ulteriori correzioni o refactoring.
La mia conclusione è che le misure di salvaguardia non possono risiedere solo nell’ambiente dell’agente, né intervenire soltanto dopo la distribuzione del codice. Se l’agente che ha scritto il codice decide anche se ha superato i test, il risultato dice ben poco. Questo non significa che gli agenti non debbano scrivere test. Significa che il giudizio deve provenire da un sistema che l’agente non possa modificare. I test devono occupare una stazione a sé lungo la linea, attraversata da ogni modifica, che sia stata scritta da una persona o da un agente.
Cosa serve a quella stazione
La risposta non consiste nell’inventare un nuovo tipo di testing. La maggior parte di ciò che serve è già da tempo tra le richieste dei buoni team QA. Semplicemente, ora è ancora più importante.
I test devono essere verificati per accertarne la conformità ai requisiti, proprio come il codice che testano. Devono anche essere eseguiti nell’ambiente in cui viene eseguito il software. Il fatto che un test passi nella sandbox di un agente non dice molto sullo staging o sulla produzione e può nascondere quali dipendenze siano state simulate — e in che modo. Un recente studio su quasi 180.000 file di test generati da agenti ha rilevato che gli agenti coprivano più casi limite rispetto ai test scritti da persone, ma che i loro test davano più spesso segni di instabilità, soprattutto perché gli agenti non conoscevano abbastanza l’ambiente in cui i test sarebbero stati eseguiti. Eseguire i test presto su infrastruttura reale permette di individuare il problema.
I test e i relativi risultati devono essere conservati. Se un agente scrive un test, dovrebbe poter consultare i test esistenti e i loro risultati, così da imparare sia dalla copertura sia dalla possibile instabilità. I test devono essere revisionati e sottoposti a controllo di versione come qualsiasi altro codice, in modo da essere rieseguiti alla modifica successiva, invece di scomparire al termine della sessione.
Un risultato positivo dovrebbe avere lo stesso significato indipendentemente da chi lo richiede: una pipeline, uno sviluppatore o un agente. Questo significa usare gli stessi test, eseguirli sulla stessa infrastruttura e raccoglierne i risultati in un unico posto.
E le persone dovrebbero continuare a usare il proprio giudizio. Sono ben contento di lasciare agli agenti il codice ripetitivo e i collegamenti. Decidere cosa vale la pena testare e cosa significhi un errore resta un compito umano (almeno per ora…).
Questo significa anche che il testing non può svolgersi solo all’interno della CI/CD (se c’è una sola cosa da ricordare di questo articolo, è questa!). Le pipeline CI sono state progettate per compilare e distribuire codice; non sono mai state pensate per eseguire test automatizzati su larga scala. Man mano che passiamo a un SDLC agentico e la quantità di codice continua a crescere, la CI si rivela ancora meno adatta a eseguire test. Il testing deve essere una componente fondamentale del processo di distribuzione del software, anziché una fase aggiunta alla fine di una pipeline. Questo significa coordinarlo come un sistema a sé stante, attraverso ogni strumento e ambiente usato dal team, a prescindere da chi lo gestisce: un agente o una persona.
Da dove iniziare
La maggior parte dei team ha già test affidabili in Playwright, Cypress, k6, Postman o negli strumenti su cui ha scelto di standardizzarsi, e questo è un ottimo punto di partenza. Ecco alcuni suggerimenti:
- Ricostruite il percorso che una modifica compie oggi dal prompt alla produzione e segnate ogni punto in cui viene eseguito un test. Se ce n’è uno solo, verso la fine, partirei da lì.
- Fate attenzione a non lasciare che gli agenti modifichino di nascosto i test esistenti. I ricercatori di ImpossibleBench hanno rilevato che limitare l’accesso degli agenti ai test riduceva i tentativi di barare. Quando un agente deve modificare un test, la modifica dovrebbe essere proposta tramite una pull request, da sottoporre alla revisione di una persona, come qualsiasi altro codice.
- Eseguite i test in ambienti di test, preferibilmente reali, invece che nelle sandbox degli agenti, il prima possibile, anche se si tratta solo di una piccola suite di smoke test eseguita in staging per ogni modifica generata da un agente. Se usate l’IA per scrivere test, non accettateli prima che siano stati eseguiti in quell’ambiente.
- Centralizzate i risultati dei test in un unico piano di controllo, che sia uno strumento di reportistica, la vostra soluzione APM o una piattaforma di testing dedicata. Assicuratevi che i risultati siano accessibili sia alle persone sia agli agenti.
- Misurate i risultati della distribuzione, non l’attività. Il numero di pull request dice ben poco. Le metriche di delivery di DORA, come il tempo di consegna delle modifiche e il tasso di fallimento delle modifiche, indicano molto meglio se l’IA è d’aiuto.
- Consentite agli agenti di usare la stessa infrastruttura di testing usata dal vostro personale, così che il loro lavoro venga verificato secondo gli stessi standard.
Ottimismo, a determinate condizioni
Quando si parla di IA, tendo a vedere il bicchiere mezzo pieno e penso che renderà i team software molto più capaci e, in definitiva, più produttivi. Ma per arrivarci, i team devono fidarsi abbastanza di ciò che producono i loro agenti da poterlo distribuire, e devono adottare un approccio olistico al testing nell’SDLC agentico: è lì che questa fiducia si costruisce o si perde.
Se state puntando a un SDLC agentico, che ruolo occupa oggi il testing al suo interno?












