Il quadro, in cifre e con le fonti
Nel 2026 diversi lavori indipendenti hanno smesso di parlare di impressioni e hanno iniziato a misurare. Il dato più citato sta in una frase: solo circa il 35 % del codice backend generato dall'IA è al tempo stesso sicuro E corretto secondo le valutazioni empiriche. In altre parole, nella maggior parte dei casi il codice prodotto è sbagliato, oppure vulnerabile, oppure entrambe le cose, anche quando «sembra» funzionare.
La quota di codice che contiene almeno una vulnerabilità è stimata tra il 62 % e il 92 % a seconda dello studio. È una forbice ampia e va letta come tale: le metodologie differiscono (linguaggi testati, definizione di vulnerabilità, gravità considerata, corpus di prompt). Nessuna cifra singola di questa forbice va citata isolatamente senza precisare lo studio e il suo metodo; è la forbice, non un singolo punto, l'informazione onesta.
Il rischio non è teorico. Il «Vibe Security Radar» del Georgia Tech registra le CVE legate al codice generato dall'IA in forte accelerazione nel primo trimestre del 2026: 6 a gennaio, 15 a febbraio, 35 a marzo, ovvero, in questi tre mesi, più di tutto il 2025 messo insieme.
Sul fronte della percezione, la diffidenza segue i numeri: l'87 % degli sviluppatori dichiara di dubitare dell'affidabilità del codice generato dall'IA. Chi lo usa di più è spesso il primo a non fidarsene a occhi chiusi.
Una precisazione di metodo, per onestà: questo corpus è soprattutto ricerca di sicurezza industriale, report di società di sicurezza, audit, benchmark, e non un insieme di letteratura accademica sottoposta a revisione paritaria. Vi si conta un solo lavoro davvero accademico (un articolo arXiv); il resto viene dall'industria. Questo non rende false le cifre, ma impone di leggerle per ciò che sono: misurazioni indipendenti che convergono, non un consenso scientifico consolidato.
Uno di questi lavori merita di essere nominato, perché inquadra esattamente il dibattito: il benchmark indipendente Vibe-Eval (2026) cataloga le modalità di fallimento di diversi generatori diffusi, Lovable, Bolt, Cursor, Replit, v0, su criteri di sicurezza applicativa. È esattamente il terreno su cui un motore che pubblica una validazione a runtime datata può misurarsi frontalmente, invece di rimandare alla fiducia.
- ~35 % del codice backend generato dall'IA è al tempo stesso sicuro e corretto (valutazioni empiriche).
- Dal 62 % al 92 % del codice generato contiene vulnerabilità, forbice ampia, metodi differenti.
- CVE correlate: 6 → 15 → 35 al mese (gen. → mar. 2026, Vibe Security Radar, Georgia Tech).
- L'87 % degli sviluppatori dubita dell'affidabilità del codice generato dall'IA.
Perché: un modello probabilistico produce codice plausibile, non garantito
La causa è strutturale, non congiunturale. Un grande modello linguistico produce il token più probabile dato il contesto. Applicato al codice, questo dà la continuazione più verosimile, non necessariamente quella corretta né quella sicura. Il modello non ha una nozione interna di «questo schema compila», «questa query è parametrizzata», «questo controllo di accesso esiste»; ha una nozione di «come appare il codice di questo tipo».
È proprio questo a rendere il problema insidioso: il codice allucinato è plausibile. Si legge bene, a volte compila, viene distribuito e fallisce nell'uso, o peggio, funziona in apparenza pur lasciando aperta una SQL injection, un segreto in chiaro, un controllo di autorizzazione mancante. Le categorie di falle ricorrenti documentate dagli studi (injection, cattiva gestione dei segreti, assenza di validazione degli input, controllo di accesso difettoso) sono esattamente quelle che un modello riproduce perché abbondano nei suoi dati di addestramento.
Aggiungere un'istruzione al prompt («scrivi codice sicuro») sposta le probabilità, ma non cambia la natura dell'oggetto: nulla garantisce il risultato, perché nulla lo verifica. Un'istruzione non è una prova.
La distinzione che cambia tutto: l'IA scrive la specifica, un builder compila il codice
Blueprint Maker parte da questa constatazione e si rifiuta di far scrivere il codice al modello. La pipeline separa due ruoli che nulla obbliga a confondere. L'IA fa ciò che sa fare meglio: comprendere un dominio di business e produrre una specifica strutturata, uno schema di entità, relazioni e regole in formato JSON. Progetta, non scrive codice.
Poi dei builder deterministici, scritti una volta, testati, versionati, trasformano questa specifica in codice: schema del database, schermate, rotte, cruscotti. Il codice quindi non è mai «allucinato» dall'LLM: è prodotto da un programma di cui si conosce il comportamento. Le proprietà dei componenti non sono indovinate, sono derivate dalla specifica secondo regole fisse. La stessa specifica in ingresso produce sempre lo stesso codice in uscita.
Questa separazione non elimina magicamente ogni rischio, ma sposta il problema là dove è trattabile: invece di sperare che un modello probabilistico non abbia introdotto una falla in migliaia di righe uniche, si garantisce per costruzione che i pattern di codice (query, moduli, controlli) escano da un unico generatore, verificabile e correggibile una volta per tutte.
- L'IA → comprende il dominio → produce una specifica (non codice).
- I builder deterministici → compilano la specifica → producono il codice.
- Il codice non è dedotto riga per riga dal modello: è generato da un programma conosciuto.
La difesa verificabile: una validazione a runtime pubblicata (K-15 / Health Score)
Scrivere codice con un metodo più sicuro resta una promessa finché non lo si dimostra. La differenza decisiva non è affermare «il nostro codice è affidabile», è misurarlo e pubblicare la misura. Ogni applicazione prodotta da Blueprint Maker supera una validazione a runtime automatizzata, chiamata K-15: il codice viene compilato, l'applicazione effettivamente avviata, poi percorsa schermata per schermata da un browser automatizzato. Il criterio è binario: funziona, oppure no.
Il risultato aggregato, la quota di applicazioni che superano l'insieme di queste verifiche su una finestra mobile di sette giorni, è pubblicato e datato con il nome di Health Score. È una metrica di affidabilità verificabile: controllabile, non dichiarativa, prodotta da un giudice automatico e non da un argomento di marketing.
È esattamente ciò che nessun generatore puramente probabilistico pubblica, e per una ragione di fondo: produrre una misura del genere presuppone un modo deterministico e riproducibile di testare ogni output in condizioni reali. Una pipeline che fa scrivere il codice al modello e lo consegna così com'è non ha alcun gate a runtime sistematico da mostrare. La trasparenza sull'affidabilità è possibile solo se l'affidabilità è costruita per essere misurata.
I nostri limiti, con onestà
Una validazione a runtime dimostra che un'applicazione si costruisce, si avvia e si percorre correttamente; riduce fortemente la classe di errori «codice plausibile ma rotto». Non sostituisce un audit di sicurezza applicativa completo, un test di intrusione né una revisione di conformità. Blueprint Maker non rivendica, a oggi, una certificazione SOC 2 o ISO: preferiamo pubblicare una metrica reale e datata piuttosto che un logo che non dice nulla sul prodotto consegnato.
La lettura corretta è questa: il codice generato dall'IA ha un problema di affidabilità misurato; l'unica risposta credibile non è una promessa ma una verifica pubblicata; separare la progettazione (l'IA) dalla fabbricazione (i builder deterministici) rende questa verifica possibile e riproducibile. È una base, non una delega in bianco, e vale più di una cifra che non si mostra.
Fonti
Cloud Security Alliance, Vibe Coding / AI Governance Gap: https://labs.cloudsecurityalliance.org/research/csa-research-note-vibe-coding-ai-governance-gap-20260602-csa/
The Security Crisis in AI-Generated Code (2026): https://blog.vibecoder.me/security-crisis-ai-generated-code-2026
IOActive, The Security Gap in AI-Generated Code: https://www.ioactive.com/wp-content/uploads/2026/05/IOA-The-Security-Gap-in-AI-Generated-Code.pdf
AppStuck, AI-Generated App Security Risks (2026): https://www.appstuck.com/blog/ai-generated-app-security-risks
Vibe-Eval, AI App Security Benchmark 2026: https://vibe-eval.com/data-studies/ai-app-security-benchmark-2026/
Sherlock Forensics, AI Code Security Report 2026: https://www.sherlockforensics.com/pages/ai-code-security-report-2026.html
OX Security, Vibe Coding Security: https://www.ox.security/blog/vibe-coding-security/
arXiv, Coding With AI: https://arxiv.org/pdf/2512.23982