In breve. Il vibe coding è ottimo per problemi semplici e prototipi, ma la superficie di un software si somma, la sostanza si moltiplica. Il vero costo sta nella densità di regole e nel garantire che restino corrette in ogni combinazione, non nel numero di schermate.
La superficie si somma, la sostanza si moltiplica. Perché un'app creata in un weekend con l'IA può somigliare a un software maturo, e come valutare rischi, costi e preventivi senza farsi ingannare.
Cos'è il vibe coding e perché sembra una scorciatoia irresistibile

Forse ti è già successo: un collaboratore, un amico o un fornitore ti mostra un'applicazione costruita in due giorni con l'intelligenza artificiale. Ha le sue schermate, i suoi pulsanti, salva i dati e funziona davvero. A quel punto la domanda nasce da sola: se si fa in un weekend, perché il gestionale che usi in azienda è costato mesi di lavoro e un preventivo importante?
È una domanda legittima, e la risposta non è «quell'app è finta». Spesso è un software vero e corretto. Il punto è un altro: due programmi possono somigliarsi moltissimo in superficie ed essere oggetti completamente diversi nella sostanza. Capire questa differenza ti serve per decidere quanto investire, quando puoi fare da solo e quando invece rischi di costruire qualcosa che si rompe proprio nel momento in cui ne hai più bisogno.
In questa prima parte vediamo cos'è il vibe coding, perché è così convincente e in quali casi è davvero la scelta giusta. Nelle sezioni successive entriamo nel motivo per cui certe stime possono sbagliare di molto.
Programmare descrivendo: come funziona lo sviluppo con l'intelligenza artificiale
Con il vibe coding non scrivi codice: descrivi a parole quello che vuoi ottenere e un assistente di intelligenza artificiale lo scrive al posto tuo. Chiedi «voglio una pagina per registrare gli ordini dei clienti», provi il risultato, segnali cosa non va e lo fai correggere. Vai avanti così, un passo alla volta, finché l'applicazione non fa quello che avevi in mente.
Il nome dice molto del metodo: si procede a sensazione, guardando se il risultato «sembra giusto», senza leggere né capire davvero il codice prodotto. Per chi non è un programmatore è una possibilità nuova e concreta, perché abbassa moltissimo la soglia d'ingresso. Proprio per questo, però, chi lo usa vede quasi solo quello che appare sullo schermo.
L'effetto «l'ho rifatto in un weekend»: da dove nasce l'errore di percezione
Il ragionamento tipico è questo: «Loro ci hanno messo un anno, io ho fatto una cosa uguale in un weekend». Stesse schermate, stesse funzioni principali, e funziona. La conclusione sembra ovvia: il prodotto sviluppato in un anno vale poco, o è stato pagato troppo.
L'errore sta nel metro di giudizio. Confrontiamo quello che vediamo, cioè schermate e funzionalità, e diamo per scontato che rispecchi tutto il resto. Ma un software non è l'insieme delle sue pagine: è il modo in cui si comporta in tutte le situazioni in cui può trovarsi. Un ordine confermato ma non pagato, una pratica aperta ma sospesa, un cliente con condizioni particolari. Queste situazioni non si vedono, ma sono proprio quelle che fanno la differenza, e una prova fatta nel fine settimana di solito non le incontra.
Dove il vibe coding funziona davvero bene
Detto questo, il vibe coding non è da evitare. Quando il problema è semplice, è spesso la soluzione più sensata. Pensa a un calcolatore interno per preparare i preventivi, a un modulo per raccogliere le richieste del personale, a uno strumento che automatizza un'operazione ripetitiva o a un prototipo per verificare se un'idea sta in piedi prima di investirci sul serio.
Sono casi con poche regole, pochi intrecci e poche eccezioni. Lì costruire in fretta e ottenere comunque un risultato corretto è possibile, e spendere mesi di sviluppo sarebbe uno spreco. Il problema nasce solo quando si prende questa facilità e la si applica a sistemi in cui ogni decisione dipende da molte cose insieme: pagamenti, tipologia di cliente, magazzino, fatturazione. Lì la somiglianza con il progetto da weekend finisce.
Il software non sono le schermate: cos'è lo spazio degli stati

Quando guardi un software, vedi schermate: un modulo, un elenco di ordini, un pulsante «conferma». È naturale giudicarlo da lì, perché è l'unica parte che si mostra. Se due applicazioni hanno le stesse pagine e fanno le stesse cose sotto i tuoi occhi, viene spontaneo pensare che valgano uguale e che richiedano lo stesso lavoro.
Il problema è che le schermate sono solo la facciata. Quello che un software fa davvero, e quello che lo rende affidabile o fragile, sta in una parte che non si vede. Si tratta di tutte le situazioni diverse in cui può trovarsi mentre lavora per te, giorno dopo giorno, con i tuoi clienti, i tuoi ordini e le tue eccezioni.
Un'app nata in un weekend può somigliare a un gestionale costruito in anni senza esserne l'equivalente. Per capire perché, serve un concetto che chi sviluppa conosce bene ma che di solito non arriva a chi decide e paga: lo spazio degli stati. Non è teoria per addetti ai lavori. È la chiave per leggere un preventivo, stimare un progetto e non farsi sorprendere quando il sistema è già in uso.
Ogni dato è una coordinata: il software come macchina che si trova sempre in uno stato
Un software, in ogni istante, si trova in uno stato, cioè nella combinazione di tutti i valori che conosce e ricorda in quel momento. Ogni dato ne fa parte: un ordine confermato ma non ancora pagato, una pratica aperta ma sospesa, un cliente con uno sconto attivo, un prodotto esaurito in un magazzino e disponibile in un altro. Ognuna di queste informazioni è una coordinata, come latitudine e longitudine su una mappa.
Il compito del software non è mostrarti delle pagine. È comportarsi correttamente in ogni stato in cui può legittimamente trovarsi. Se un ordine è confermato ma non pagato, cosa deve succedere quando il cliente chiede di modificarlo? E se nel frattempo la fattura è già stata emessa? Ogni risposta giusta è una regola che il sistema deve rispettare sempre, non solo nei casi che ti vengono in mente.
State space explosion: la superficie si somma, la sostanza si moltiplica
Qui sta il punto che sfugge quasi a tutti. La superficie di un software cresce in modo additivo: una schermata in più è una schermata in più, una funzione in più è una funzione in più. Lo spazio degli stati, invece, cresce in modo moltiplicativo, perché ogni nuova variabile si combina con tutte quelle che c'erano già. È quello che in informatica si chiama state space explosion, l'esplosione dello spazio degli stati.
Basta un conto semplice per vederlo. Prendi informazioni che possono avere solo due valori, sì o no: pagato o non pagato, spedito o non spedito. Con dieci ottieni oltre mille combinazioni possibili, con venti circa un milione, con trenta circa un miliardo. La superficie cresce come una somma, la sostanza come un prodotto. Ecco perché due software con le stesse pagine possono avere complessità che non si possono nemmeno paragonare.
Perché l'interfaccia mostra un solo stato alla volta e nasconde la complessità
Se la complessità è così grande, perché non si vede? Perché un'interfaccia, per come è fatta, ti mostra un solo stato alla volta: l'ordine che stai guardando adesso, con i dati che ha adesso. I milioni di altre combinazioni in cui il sistema deve restare corretto non compaiono da nessuna parte. Restano dietro le quinte, finché una di queste non si presenta davvero.
Per questo una demo convince così facilmente. Mostra il percorso principale, quello in cui tutto fila liscio, e lungo quel percorso un'app costruita in un weekend e un gestionale maturo possono comportarsi in modo identico. La differenza emerge con il cliente che paga in due rate, cambia indirizzo dopo la fattura e chiede un reso parziale. È lì, nelle combinazioni che nessuna schermata mostra, che si misura il vero valore di un software.
Software piatto e software denso: due oggetti diversi che si assomigliano

Mettiamo due software uno accanto all'altro. Hanno le stesse schermate, gli stessi pulsanti, gli stessi menu, e tutti e due funzionano: crei un cliente, registri un ordine, stampi un documento. Il primo è stato costruito in un weekend con l'intelligenza artificiale, il secondo è il risultato di anni di lavoro. A guardarli, la domanda viene da sé: se uno si fa in due giorni, quanto può valere l'altro?
La risposta onesta è che non li stai confrontando davvero. Il software del weekend non è per forza finto, incompleto o una semplice demo: può essere corretto e perfettamente adatto al suo scopo. Semplicemente è un oggetto diverso, che dell'altro ha preso solo l'aspetto. Per comodità chiamiamoli software piatto e software denso.
Il software piatto ha poche regole e pochi intrecci, quindi uno spazio degli stati piccolo: per questo si può costruire in fretta senza rinunciare alla correttezza. Il software denso, invece, ha regole che guardano più cose insieme, e ogni intreccio moltiplica le situazioni in cui deve comportarsi bene. Da fuori non lo vedi, ma è lì che sta quasi tutto il lavoro, e di conseguenza quasi tutto il costo.
La densità di regole come vera unità di misura, non il numero di funzionalità
Quando confronti due software, o due preventivi, viene naturale contare: quante schermate, quante funzioni, quanti report. È un metro comodo, ma misura solo la superficie, che cresce per somma: una schermata in più è una schermata in più. La sostanza segue un'altra logica. Ogni regola trasversale, cioè ogni regola che per decidere deve leggere più informazioni insieme, si combina con tutte le altre e moltiplica i casi da gestire.
Per questo la vera unità di misura è la densità di regole: quante decisioni dipendono da più fattori contemporaneamente e quanto sono intrecciate tra loro. Due gestionali con lo stesso elenco di funzionalità possono avere densità lontanissime. E un elenco di funzionalità, per quanto lungo e dettagliato, su questo punto non ti dice nulla.
Un esempio concreto: l'ordine che dipende da pagamento, cliente, sede e fatturazione
Prendi un ordine. Nel software piatto la regola è una sola: se è confermato, lo puoi spedire. Nel software denso la stessa domanda, «cosa posso fare con quest'ordine?», ha una risposta che dipende da più cose insieme: se il pagamento è arrivato, se è parziale o è stato stornato; che cliente è, privato o azienda con condizioni dedicate; da quale sede parte; cosa è già stato fatturato; che tipo di prodotto contiene.
Ognuno di questi fattori, da solo, è semplice. Il problema è che si combinano: l'ordine pagato ma con una fattura già emessa, spedito da una sede con regole diverse, a un cliente che ha un reso aperto. Sullo schermo vedi sempre lo stesso ordine, con gli stessi pulsanti. Dietro, il sistema deve dare la risposta giusta in ognuna di queste combinazioni, non solo in quella che hai davanti.
Più un sistema denso è fatto bene, più sembra facile da copiare
C'è un paradosso che conviene conoscere prima di stimare, chiedere o firmare un preventivo. Scrivere le regole è veloce, e con l'intelligenza artificiale lo è ancora di più. Quello che richiede tempo è garantire che ogni regola resti vera in tutte le combinazioni che contano, e tenere lo spazio degli stati sotto controllo perché resti governabile. Quando questo lavoro riesce, non si vede: chi usa il sistema trova tutto lineare e intuitivo.
Ecco perché più un sistema denso è fatto bene, più sembra replicabile in un weekend. La semplicità che percepisci è il risultato del lavoro, non la prova che il lavoro non serviva. Il consiglio pratico: prima di confrontare due soluzioni, metti nero su bianco in un piano scritto le regole e le eccezioni del tuo processo. Se faticheresti a descriverle tutte in un weekend, difficilmente qualcuno potrà realizzarle in un weekend.
I rischi concreti del vibe coding per una piccola e media impresa

Fin qui abbiamo visto il principio: la superficie di un software si somma, la sostanza si moltiplica. Se guidi un'azienda, però, la domanda che conta è più pratica: cosa rischio davvero se tratto un sistema denso come se fosse piatto? La risposta raramente arriva il giorno in cui l'applicazione nasce. Quel giorno tutto sembra funzionare, le schermate ci sono e i casi che provi danno il risultato atteso.
I problemi si presentano dopo: quando devi stimare quanto costa e quanto tempo serve, quando lo strumento passa nelle mani di clienti e colleghi che lo usano in modi che non avevi previsto, quando devi cambiarlo perché è cambiata un'esigenza dell'azienda. In ognuno di questi momenti la densità di regole, che prima era invisibile, presenta il conto.
Non è un'accusa all'intelligenza artificiale né a chi la usa per costruire strumenti in casa. È un invito a guardare il costo reale di un software lungo tutta la sua vita, non solo nel weekend in cui prende forma. Vediamo i tre rischi che incontri più spesso.
Stime, preventivi e promesse sbagliati di ordini di grandezza
Il primo rischio è economico e nasce dal confronto sbagliato. Vedi un'app costruita in pochi giorni, assomiglia al gestionale che ti hanno preventivato in mesi, e la conclusione sembra ovvia: il preventivo è gonfiato. Oppure, al contrario, prometti a soci o clienti che il nuovo sistema sarà pronto in un mese, perché «tanto con l'IA si fa in fretta». In entrambi i casi stai misurando le schermate, mentre il lavoro vero sta nelle regole che si incrociano. L'errore non è di qualche settimana: può essere di ordini di grandezza. Il risultato sono budget che saltano, scadenze mancate e decisioni prese su un'idea di costo che non ha niente a che vedere con il problema da risolvere.
Errori che emergono solo in combinazioni rare, quando il sistema è già in uso
Quando provi un'applicazione, controlli i casi più comuni: l'ordine normale, il cliente abituale, il pagamento standard. E funzionano. Ma l'azienda vera produce combinazioni che nessuno ha messo alla prova: l'ordine pagato in parte, il cliente con due sedi, il reso arrivato dopo la fattura, lo sconto che si somma a una promozione. Ognuna di queste è uno stato in cui il software deve comportarsi bene, e in un sistema denso sono tantissime. Gli errori compaiono lì, in produzione, quando i dati sono già reali: una fattura sbagliata, una giacenza che non torna, un cliente che riceve la conferma di qualcosa che non ha comprato. E rimettere a posto a mano costa più tempo di quanto ne avevi risparmiato.
Manutenzione, debito tecnico e dipendenza da un codice che nessuno governa
Un software non si finisce mai davvero: cambiano i listini, le norme, i processi. Se il codice è stato generato in fretta, senza che nessuno abbia progettato come le regole si tengono insieme, ogni modifica diventa una scommessa. Correggi una cosa e se ne rompe un'altra, in un punto che non immaginavi collegato. È quello che si chiama debito tecnico: le scorciatoie di oggi diventano un costo che paghi domani, con gli interessi.
C'è poi la dipendenza. Se chi ha costruito lo strumento cambia lavoro, o semplicemente non ricorda più perché una regola è scritta in quel modo, ti ritrovi con un sistema che usi ogni giorno ma che nessuno sa più governare. Serve sempre qualcuno che conosca l'insieme, non solo il pezzo che funziona.
Domande frequenti sui rischi del vibe coding
Domande frequenti
Quali sono i principali rischi del vibe coding per un'azienda?
I rischi più frequenti sono tre. Il primo è stimare male tempi e costi, a volte di ordini di grandezza, perché si confrontano le schermate e non le regole che le governano. Il secondo sono gli errori che emergono solo in combinazioni rare, come un ordine pagato in parte con una fattura già emessa, quando il sistema lavora già su dati reali. Il terzo è il debito tecnico: codice generato in fretta, che nessuno ha progettato nel suo insieme, diventa difficile da modificare e finisce per dipendere da chi l'ha scritto.
Il vibe coding è adatto per creare un e-commerce o un gestionale?
Dipende da quanto è denso il problema. Per un catalogo semplice, un modulo di raccolta richieste o un prototipo da mostrare a un socio può bastare. Un e-commerce o un gestionale reale, invece, ha regole che dipendono da molti fattori insieme: pagamenti, tipologia di cliente, magazzino, sedi, resi, fatturazione. Ogni intreccio moltiplica le situazioni in cui il software deve comportarsi correttamente. In questi casi il vibe coding può servire per esplorare un'idea, ma affidargli la gestione quotidiana dell'azienda senza progettazione e verifiche è rischioso.
Un prototipo fatto con l'intelligenza artificiale può diventare un prodotto definitivo?
Può succedere, ma non in automatico. Un prototipo dimostra che un'idea funziona nel percorso principale, quello in cui tutto fila liscio. Un prodotto deve funzionare anche nelle eccezioni: dati incompleti, utenti che sbagliano, casi che si combinano in modi imprevisti. Per passare dall'uno all'altro serve descrivere con precisione regole ed eccezioni, verificare il codice, aggiungere test e decidere chi si occuperà della manutenzione. Spesso conviene usare il prototipo come base per chiarire i requisiti, non come sistema da mettere subito in produzione.
Perché lo sviluppo su misura costa tanto se l'IA scrive codice in pochi minuti?
Perché scrivere il codice non è la parte più lunga del lavoro. Le regole si scrivono in fretta, e con l'intelligenza artificiale ancora di più. Quello che richiede tempo è garantire che ogni regola resti vera in tutte le combinazioni rilevanti, e progettare il sistema in modo che resti governabile quando cambiano listini, norme o processi. In un preventivo serio paghi soprattutto questo: analisi, progettazione, verifiche e manutenzione. Quando il lavoro è fatto bene, il risultato sembra semplice, ed è proprio questa semplicità a farlo sembrare economico da replicare.
Cos'è l'esplosione dello spazio degli stati e perché riguarda anche le PMI?
Un software si trova sempre in uno stato, cioè nella combinazione di tutti i dati che conosce in quel momento: ordine pagato o no, spedito o no, cliente privato o azienda. Ogni nuova informazione si combina con tutte le altre, quindi le situazioni possibili crescono per moltiplicazione: con dieci informazioni di tipo sì o no si superano già le mille combinazioni. È la state space explosion. Riguarda le PMI perché anche processi che sembrano semplici, come la gestione di ordini e resi, nascondono molte più combinazioni di quante ne mostri lo schermo.
Come capisco se il mio progetto è troppo complesso per il fai da te?
Prova a mettere per iscritto le regole del processo che vuoi digitalizzare. Chiediti quante decisioni dipendono da più fattori contemporaneamente, quante eccezioni gestite oggi a mano, cosa succede se un'operazione resta a metà e quali errori costerebbero denaro o la fiducia dei clienti. Se le regole sono poche e indipendenti, uno strumento costruito in casa può essere la scelta giusta. Se invece faticheresti a descriverle tutte in un weekend, difficilmente qualcuno potrà realizzarle in un weekend, e conviene coinvolgere chi sa progettare sistemi complessi.
Come si confrontano due preventivi di sviluppo software?
Contare schermate e funzionalità non basta, perché misura solo la superficie. Chiedi piuttosto come ciascun fornitore ha compreso le regole e le eccezioni del tuo processo, quali casi limite ha previsto, come verificherà che il sistema si comporti correttamente e chi si occuperà della manutenzione nel tempo. Un preventivo molto più basso dell'altro può voler dire maggiore efficienza, ma anche che una parte del problema non è stata vista. Se la differenza è grande, fatti spiegare punto per punto cosa è incluso e cosa no.