SDLC sicuro con l’IA: l’IA che testa non sia quella che ha scritto il codice
Di Xavier Franco, CEO de Elternativa · Grupo Zemsania
· 6 min di lettura
Redatto con l’aiuto dell’IA e rivisto da Xavier Franco

In questo articolo
C’è una regola che in qualsiasi azienda seria nessuno discute: chi fa una cosa non è chi la dà per buona. La contabilità la controlla un’altra persona. Un pagamento importante lo firmano in due. Eppure, con l’IA, stiamo accettando esattamente il contrario: che lo stesso strumento che scrive il codice decida se il codice è corretto. Per questo insisto su una regola, che riassumo così: l’IA che testa non sia quella che ha scritto il codice.
Che cos’è l’SSDLC e perché torna a contare
L’SDLC sicuro (secure software development life cycle, SSDLC) è il ciclo di vita dello sviluppo software con la sicurezza dentro ogni passaggio: nel requisito, nella progettazione, nel codice, nei test e nel rilascio. Non è una fase alla fine, è un modo di lavorare.
Con l’IA che scrive buona parte del codice, l’SDLC sicuro torna al centro. Perché il volume cresce molto, e ciò che prima si rivedeva con calma ora arriva a un ritmo che nessuna persona può leggere riga per riga.
In pratica: chieda al Suo team quale parte del codice integrato questo mese è stata scritta da un’IA. Se nessuno lo sa, ha già il primo compito.
Che cosa dicono i dati sul codice generato dall’IA
Veracode ha pubblicato a luglio 2025 uno studio da tenere presente. Ha analizzato 80 compiti di programmazione con più di 100 modelli linguistici, e il codice generato ha introdotto vulnerabilità di sicurezza nel 45% dei casi. In Java, il tasso di errore ha superato il 70%. E un dato che mi sembra il più importante: i modelli più grandi non andavano significativamente meglio di quelli piccoli.
Cioè, aspettare il prossimo modello non risolve il problema. Il codice scritto da un’IA è, come quello di qualsiasi persona, codice da verificare.
Il rapporto DORA 2025 va nella stessa direzione da un’altra angolazione: il 30% dei professionisti dice di avere poca o nessuna fiducia nel codice generato dall’IA. E avverte che, senza sistemi di controllo solidi, come test automatici robusti, un controllo di versione maturo e cicli di risposta rapidi, un maggior volume di modifiche porta a più instabilità.
Perché la stessa IA non può testare sé stessa
Quando chiede a un’IA di scrivere un codice e, nella stessa conversazione, di scriverne i test, succede qualcosa di molto umano: i test confermano ciò che il codice già fa, non ciò che dovrebbe fare. Se il modello ha capito male il requisito, i test ereditano il malinteso e risultano verdi.
Per questo non basta «l’IA fa anche i test». Serve che la verifica parta da un altro punto:
- Dai criteri fissati prima di iniziare, non dal codice già scritto.
- Da un’altra istanza, che non ha visto come è stata ragionata la soluzione.
- Da una persona, che decide se ciò che è stato consegnato soddisfa quanto richiesto.
In pratica: riveda un compito recente svolto con l’IA. Se i test sono stati scritti nella stessa sessione del codice, si chieda che cosa sarebbe successo se il requisito fosse stato frainteso.
Separare chi scrive da chi verifica
Così lo impostiamo nel nostro metodo, passo per passo:
- Requisito e piano. Ogni compito nasce con il suo contratto e i suoi criteri di accettazione, fissati prima di iniziare. Quel contratto è il riferimento per tutto il resto.
- Sviluppo. Un’istanza di IA scrive il codice.
- Test. Li esegue un’istanza diversa da quella che ha scritto il codice, con una coda di test separata. Chi esegue non convalida il proprio lavoro.
- Revisione e convalida. Una persona convalida la chiusura guardando il codice, e la firma resta registrata.
- PR e rilascio. L’IA apre la pull request e rispetta il Suo Git e il Suo CI/CD, con i loro controlli di sempre.
Non è sfiducia verso l’IA. È la stessa separazione dei ruoli che applichiamo a qualsiasi processo importante.
I test, in linguaggio di business
Un test che capisce solo chi l’ha scritto non è nemmeno un controllo. Per questo mi piace che i casi di test siano scritti in linguaggio di business, con scenari del tipo «dato, quando, allora» che chiunque può leggere.
Così, chi decide se una cosa va bene non ha bisogno di leggere il codice dei test per sapere che cosa è stato verificato. E ogni caso resta collegato alla storia e alla decisione che lo hanno originato, con il suo risultato registrato come evidenza.
In pratica: chieda che Le mostrino i casi di test di una funzionalità critica. Se non li capisce senza aiuto, il Suo business non li sta convalidando.
Ciò che si impara resta come regola
Quando un test trova un difetto, la cosa più facile è correggerlo e andare avanti. L’utile è che quel difetto non si ripeta. Nel nostro metodo, ogni errore misurato viene conservato insieme alla difesa che lo sorveglia: un test automatico, un controllo nel codice o un vincolo nel database. E avvisa solo i ruoli e i compiti che riguarda.
Con l’IA questo conta più che mai, perché un’istanza non ricorda ciò che è successo nel compito precedente. Se la lezione non è nel sistema, si perde.
Da dove iniziare
- Misuri quale parte del Suo codice scrive già l’IA.
- Fissi criteri di accettazione prima di ogni compito, non dopo.
- Separi chi scrive da chi testa, anche se entrambi sono IA.
- Faccia convalidare a una persona ogni chiusura, con firma registrata.
- Trasformi ogni difetto in una regola che si verifica da sola.
Come La aiutiamo
In Agentic Data & Software Engineering orchestriamo le IA di sviluppo che ha già lungo tutto l’SDLC: ogni compito con il suo contratto e i suoi criteri fissati prima di iniziare, test eseguiti da un’istanza diversa da quella che ha scritto il codice e una persona del Suo team che convalida ogni chiusura guardando il codice. Il codice resta nel Suo Git e rispetta il Suo CI/CD.
Lo facciamo con Agentagile, la nostra metodologia per sviluppare con l’IA: ogni consegna viene testata e convalidata con le stesse regole, e nulla avanza senza il via libera del Suo team.
Chi testa oggi ciò che genera la Sua IA?
Le mostriamo in una demo come un’istanza scrive, un’altra, diversa, testa e una persona del Suo team convalida ogni chiusura guardando il codice.


