Lo spec-driven development è un metodo di sviluppo software in cui una specifica scritta, non il codice, è il riferimento principale del progetto: prima si definisce cosa il sistema deve fare, poi si genera l’implementazione a partire da quella specifica. Riduce il rischio tipico del codice scritto “a sensazione” con l’AI (vibe coding), soprattutto quando si interviene su un sistema già esistente. Non è una garanzia automatica di qualità: su un task piccolo e già chiaro può costare più tempo di quanto ne faccia risparmiare.
Perché una demo perfetta può diventare un problema due mesi dopo?
Hai mai ricevuto una demo che sembrava perfetta, e poi, due mesi dopo, ti sei ritrovato con un ticket dietro l’altro sulla stessa funzione? Succede più spesso di quanto pensi. E spesso la causa non è la competenza di chi ha scritto il codice. È il metodo con cui è stato scritto.
Il limite del “generare e vedere cosa succede”
Negli ultimi due anni, generare codice con l’intelligenza artificiale è diventato quasi immediato. Basta descrivere in linguaggio naturale cosa serve, e in pochi secondi ottieni un componente che sembra funzionante. Il problema è che la stessa richiesta, ripetuta due volte, può produrre due implementazioni diverse: le espressioni generiche vengono interpretate a modo loro a ogni generazione. Quello che passa il primo test nasconde spesso scorciatoie che emergono solo quando il sistema comincia a essere usato davvero, magari da un cliente, magari in un momento di picco.
Nel settore questo modo di lavorare ha un nome: vibe coding. Funziona bene per un prototipo veloce o per validare un’idea, ma diventa un rischio quando il software deve reggere nel tempo, integrarsi con altri sistemi ed essere modificato da qualcun altro un anno dopo.

Cos’è lo spec-driven development?
Lo spec-driven development, lo sviluppo guidato da specifica, è un metodo di lavoro in cui, prima di scrivere anche una sola riga di codice, si scrive una specifica precisa di cosa il sistema deve fare: i casi d’uso, i casi limite da gestire, i vincoli tecnici non negoziabili. Quella specifica, non il codice, diventa il riferimento principale del progetto. Quando qualcosa cambia, si aggiorna prima la specifica, e da lì si rigenera l’implementazione.
Non è un’idea nuova di zecca: chi lavora con il test-driven development conosce già la logica di definire prima cosa ci si aspetta da una funzione e poi scrivere il codice che lo soddisfa. Lo spec-driven development porta lo stesso principio un passo oltre, in un formato che un agente AI può leggere e usare direttamente per generare l’implementazione.
Quando conta davvero, per chi commissiona software?
Per chi commissiona software, la parte che conta davvero non sono le sigle o gli strumenti, è piuttosto capire quando questo approccio fa la differenza sul risultato. E il caso in cui conta di più non è quello, più raro, di un progetto costruito da zero. È quello in cui si interviene su un sistema che esiste già: che sia un gestionale che gira da anni, un’integrazione tra due software che nessuno ha mai documentato del tutto o un processo che si è stratificato nel tempo tra vecchie personalizzazioni e nuove esigenze.
In questi contesti la specifica costringe chi lavora sul progetto a rendere esplicito quello che prima era solo nella testa di una persona: come si integrano i moduli, quali vincoli tecnici non si possono violare, cosa succede nei casi limite. Questo riduce il rischio più comune quando si tocca codice esistente con l’aiuto dell’AI: una modifica che funziona in isolamento, ma rompe qualcosa altrove, magari un mese dopo, magari in un modulo che nessuno stava guardando.
Quali sono i limiti dello spec-driven development?
In DonQ cerchiamo sempre di essere diretti: lo spec-driven development non è una garanzia automatica di qualità, ed è giusto diffidare di chi te lo racconta come tale. Per una modifica piccola e ben capita, scrivere una specifica formale può costare più tempo di quanto ne faccia risparmiare. C’è chi, testando questi strumenti su un bug fix di pochi minuti, si è visto generare quattro user story e sedici criteri di accettazione per una correzione minima.
Resta poi un limite di fondo che nessuna specifica, per quanto dettagliata, elimina del tutto: gli agenti AI restano probabilistici, quindi la stessa specifica può produrre implementazioni leggermente diverse a seconda di quando viene eseguita. La specifica riduce l’ambiguità, purtroppo non la elimina.
Cosa chiedere, in pratica, a chi ti scrive il software
Se stai valutando un fornitore o un progetto in corso, tre domande semplici dicono già molto: esiste una specifica scritta di cosa il sistema deve fare, oltre al codice? Chi la tiene aggiornata quando il progetto evolve? E se domani cambia un requisito, si riparte da lì o si va a modificare il codice a mano, sperando che nessuno se ne accorga?
Per chi vuole entrare nel dettaglio tecnico
Chi lavora nello sviluppo sa che dietro l’etichetta “spec-driven development” convivono oggi pratiche molto diverse tra loro. Una distinzione diventata il riferimento del settore, proposta dalla Distinguished Engineer di Thoughtworks Birgitta Böckeler, individua tre livelli cumulativi: spec-first, dove la specifica guida la prima implementazione e poi viene di fatto abbandonata; spec-anchored, dove la specifica resta viva e guida anche l’evoluzione successiva del sistema; spec-as-source, il livello più radicale, dove l’unico artefatto che le persone modificano è la specifica, e il codice è un output rigenerato, mai toccato a mano.
Nella pratica, il flusso di lavoro più diffuso si articola in quattro fasi:
- si specifica cosa il sistema deve fare (Specify)
- si definiscono i vincoli tecnici e l’architettura (Plan)
- si scompone il piano in attività verificabili una a una (Tasks)
- si genera il codice un pezzo alla volta, validandolo contro la specifica (Implement).
Strumenti come GitHub Spec Kit, open source e agnostico rispetto all’agente AI usato, oppure Kiro di AWS, lanciato a livello internazionale nel maggio 2026, seguono in modi diversi questa stessa logica.
Se lavori nello sviluppo e vuoi il quadro completo, tra i tre livelli, la mappatura degli strumenti reali e i casi in cui questo approccio non conviene, abbiamo scritto un approfondimento dedicato: [link alla traccia tecnica].
Il punto
Il codice generato dall’AI continuerà a migliorare, ed è già oggi uno strumento potente. Quello che fa la differenza, sempre di più, non è quanto velocemente arriva un’implementazione, ma quanto è chiaro, verificabile e duraturo quello che sta dietro a quell’implementazione.
È anche per questo che, quando lavoriamo su un progetto esistente, la prima cosa che scriviamo non è mai il codice.
Domande frequenti
È un metodo di sviluppo software in cui una specifica scritta, comprensibile sia da persone che da agenti AI, diventa il riferimento principale del progetto. Il codice viene generato a partire da quella specifica, invece che da un prompt generico.
Nel vibe coding si genera codice direttamente da un prompt, spesso senza un documento intermedio che ne fissi il comportamento atteso: la stessa richiesta può produrre risultati diversi a ogni tentativo. Nello spec-driven development, la specifica viene scritta e validata prima, e resta il riferimento a cui tornare quando qualcosa cambia.
No. È spesso più utile sui sistemi già esistenti, dove rende esplicito ciò che prima era solo nella testa di chi conosce il sistema: vincoli tecnici, integrazioni, comportamenti nei casi limite. Su un progetto costruito da zero il beneficio c’è, ma il rischio che questo approccio previene, cioè la modifica che rompe qualcosa altrove, è più tipico di chi interviene su codice esistente.
No. Riduce l’ambiguità della richiesta, ma non elimina la natura probabilistica dei modelli che generano il codice: la stessa specifica può produrre implementazioni leggermente diverse a seconda di quando viene eseguita. Resta comunque uno strumento in più, non una garanzia assoluta.
Chiedi se esiste una specifica scritta di cosa il sistema deve fare, oltre al codice, chi la mantiene aggiornata nel tempo, e cosa succede quando cambia un requisito: se si riparte dalla specifica o si modifica il codice a mano senza lasciarne traccia.
È un metodo di sviluppo software in cui una specifica scritta, comprensibile sia da persone che da agenti AI, diventa il riferimento principale del progetto. Il codice viene generato a partire da quella specifica, invece che da un prompt generico.