Risposta diretta
Nel mio racconto, non misurato con un cronometro, un modulo di prenotazione che avrei stimato in uno o due giorni è diventato un pomeriggio di circa quattro ore con il workflow agentico GSD: gli agenti hanno scritto endpoint, test e interfaccia in parallelo mentre io restavo la guida che decideva regole, dati e cosa mandare in produzione.
Gli agenti non mi hanno sostituito. Hanno tolto di mezzo le parti in cui ero più lento. Questa è la tesi scomoda che divide: chi teme il coding agentico immagina uno sviluppatore rimpiazzato, mentre la realtà del mio monorepo è l'opposto. Il collo di bottiglia non era mai scrivere il boilerplate: era il costo di context-switch tra decisione, scrittura, test e review. Il workflow agentico attacca proprio quel costo.
Nota di trasparenza. Tutto quanto segue è esperienza diretta sul mio portfolio brownfield (3 microservizi in produzione su VPS). L'agente di coding è uno strumento di accompagnamento, non il protagonista: le decisioni di prodotto, i dati reali e la review finale restano mie. Il provider AI dei servizi runtime del portfolio era, fino al 23 ottobre 2026, Ollama on-prem installato sul VPS - un tema separato dallo strumento con cui scrivo il codice.
Aggiornamento di novembre 2026: dal 23 ottobre al
12 novembre 2026 il provider AI dei servizi del sito è stato
OpenRouter (piano gratuito, costo zero). Ogni richiesta
portava l'impostazione data_collection: "deny", quindi i
prompt non venivano usati per addestrare i modelli; non posso invece
affermare che non venissero conservati, e il servizio non aveva
instradamento in-region UE, quindi i dati potevano uscire dall'Unione.
Dal deploy del 12 novembre 2026 il sito usa un motore AI
locale sul proprio server, in Europa, con una coda di lavori:
le richieste AI non sono inviate a fornitori terzi, e su CPU senza GPU i
tempi sono più lunghi. Le frasi «nessun dato esce» e «on-prem» più sotto
descrivono il periodo Ollama.
I numeri di questo articolo, a partire dalle «circa quattro ore», sono il resoconto che faccio di una sessione e non una misura che tu possa ripetere: li riporto come racconto personale e non come benchmark. Le affermazioni sugli strumenti, invece, hanno una fonte in fondo.
Il problema vero non è la velocità di battitura
Chi misura la produttività in righe scritte al minuto guarda la metrica sbagliata. Su una codebase reale il tempo se ne va altrove: capire dove mettere le mani, tenere il contesto mentre salti fra tre servizi, ricordare la convenzione di quel layer, e soprattutto non rompere nulla. La battitura è la parte facile, quindi ottimizzarla porta poco.
GSD (Get Shit Done) è il sistema di pianificazione fasata che uso. Il repository pubblico lo descrive come un sistema di spec-driven development che porta gli agenti di programmazione attraverso un ciclo ripetuto per ogni fase: discutere le decisioni prima di pianificare, pianificare e scomporre, eseguire i piani in ondate parallele (ognuno eseguito da un agente con un contesto pulito), verificare, e infine consegnare. L'agente che esegue un piano, secondo la sua descrizione, lavora con commit per ogni task. Questo è il cuore del metodo, ed è anche il motivo per cui regge: ogni piano è piccolo abbastanza da stare in un contesto fresco, e ogni task lascia una traccia in git che puoi rileggere. Sopra ci sono agenti specializzati per stack (uno per il backend Spring, uno per l'Angular, uno per la review, uno per la sicurezza): sono miei, non agenti di GSD, e nel repository pubblico di GSD non ne ho trovati per Spring o Angular.
La parte che un umano da solo non può fare è la parallelizzazione: i
piani senza dipendenze fra loro, dichiarate nei campi depends_on e
files_modified di ciascun piano, girano nella stessa
ondata. Come si controlla una dipendenza nascosta lo mostro nell'articolo
sul debug a cascata; qui
mi basta dire che è la condizione che decide se la parallelizzazione
funziona o produce conflitti.
Il caso reale: modulo di prenotazione in circa quattro ore
Volevo un modulo di booking custom al posto di un servizio esterno: slot di disponibilità, richiesta con approvazione via magic-link firmato, tre email transazionali, allegato .ics, più due superfici Angular (una pagina gated per l'account e una landing pubblica indicizzabile). Su carta è uno o due giorni di lavoro. Con il workflow agentico è diventato un pomeriggio.
Non è magia e non è vibe-coding. È un cambio di ruolo: smetto di essere la persona che scrive ogni riga e divento la persona che decide, orienta e verifica. Il valore che porto non è più la sintassi, è il giudizio.
Chi ha fatto cosa
- Io (la guida): le regole di dominio (finestre orarie Lun-Ven 8:00-8:30 e 18:30-19:30, Sab-Dom 8:00-19:30), la scelta richiesta-poi-approvazione invece della prenotazione diretta, i due indirizzi che approvano, il segreto del token, e la review finale su sicurezza e UX.
- Gli agenti (l'accompagnamento): gli endpoint REST di disponibilità e creazione pending, il flusso di approvazione con magic-link, la generazione delle email e dell'.ics, le due pagine Angular con stato ed errori gestiti, e la prima passata di test.
La divisione segue una regola semplice: a me le scelte che hanno conseguenze difficili da annullare (chi può approvare, come si firma un token, che cosa si pubblica), agli agenti le parti il cui risultato posso verificare leggendo il diff e facendo girare i test. Non è una divisione fra «cose difficili» e «cose facili»: gli endpoint non sono banali, ma sono verificabili, mentre la scelta fra prenotazione diretta e richiesta con approvazione non lo è.
Il dato: dove sono andate le quattro ore
Questa è la ripartizione della sessione come la riporto, separando il tempo di guida umana attiva dal tempo di lavoro degli agenti. I due non si sommano in wall-clock: molto lavoro agenti gira mentre io leggo, decido o mi occupo di altro, ed è proprio quella sovrapposizione a comprimere il totale. Sono minuti dichiarati da me, non registrati da uno strumento.
| Fase | Guida umana (min) | Agenti (min) |
|---|---|---|
| Discussione e decisioni di dominio | 40 | 0 |
| Planning e decomposizione in wave | 15 | 25 |
| Esecuzione (backend, email, .ics, 2 UI, test) | 20 | 110 |
| Review, fix e merge | 35 | 15 |
| Totale attivo | 110 | 150 |
Una tabella di numeri dichiarati si può almeno controllare per coerenza. Lo script seguente non misura niente: ricalcola i totali dalle righe, conta la quota di guida umana andata in discussione e review e mostra che cosa implicano i numeri sulla sovrapposizione.
"""Controllo aritmetico della tabella dei tempi dell'articolo: i dati sono quelli dichiarati dall'autore, non misurati qui."""
# (fase, minuti di guida umana, minuti di lavoro degli agenti), come dichiarati nel racconto.
FASI = [
("Discussione e decisioni di dominio", 40, 0),
("Planning e decomposizione in wave", 15, 25),
("Esecuzione (backend, email, .ics, 2 UI, test)", 20, 110),
("Review, fix e merge", 35, 15),
]
TOTALE_DICHIARATO = (110, 150)
WALL_CLOCK_MIN = 4 * 60 # "circa quattro ore"
umano = sum(f[1] for f in FASI)
agenti = sum(f[2] for f in FASI)
print("totali calcolati:", umano, agenti, "| dichiarati:", TOTALE_DICHIARATO, "| coincidono:", (umano, agenti) == TOTALE_DICHIARATO)
giudizio = sum(f[1] for f in FASI if f[0] in ("Discussione e decisioni di dominio", "Review, fix e merge"))
print(f"guida umana in discussione e review: {giudizio} su {umano} minuti = {giudizio / umano:.0%}")
print(f"quota degli agenti sul tempo attivo totale: {agenti} su {umano + agenti} = {agenti / (umano + agenti):.0%}")
print(f"tempo attivo {umano + agenti} min contro {WALL_CLOCK_MIN} min di orologio: sovrapposizione di almeno {umano + agenti - WALL_CLOCK_MIN} min")
# Output:
# totali calcolati: 110 150 | dichiarati: (110, 150) | coincidono: True
# guida umana in discussione e review: 75 su 110 minuti = 68%
# quota degli agenti sul tempo attivo totale: 150 su 260 = 58%
# tempo attivo 260 min contro 240 min di orologio: sovrapposizione di almeno 20 min
Le quattro righe dell'uscita dicono questo. I totali delle righe coincidono con quelli scritti nella tabella (110 e 150), quindi non ci sono errori di somma. La guida umana in discussione e review è di 75 minuti su 110, cioè il 68%: è un'indicazione di come si è spostato il mio tempo, non una misura. Gli agenti pesano il 58% del tempo attivo. Infine, 260 minuti attivi contro circa 240 di orologio implicano una sovrapposizione di almeno 20 minuti, ed è tutto ciò che i numeri dichiarati permettono di dire: la compressione c'è, ma la tabella non basta a quantificarla meglio.
Il numero che conta non è «150 minuti di agenti». È che la mia quota attiva si è spostata: più di due terzi del mio tempo si sono concentrati in discussione delle regole e review, ovvero dove il giudizio umano vale di più. La scrittura pura, prima dominante, è quasi sparita dal mio conto.
Dove gli agenti fanno perdere tempo
Sarebbe disonesto raccontare solo i risparmi. Il coding agentico ha un costo reale, e ignorarlo porta a delusioni. Tre punti dove ho pagato dazio su questa e altre sessioni.
- Convenzioni implicite. Un agente non conosce le mie gotcha storiche (per esempio: mai editare una migration Flyway già applicata, pena crash in produzione). Se non le metto nero su bianco nelle regole del progetto, le reinventa. Il tempo speso a scriverle una volta si ripaga, ma la prima volta è costo puro.
- Over-engineering di default. Lasciato libero, un agente aggiunge astrazioni che non ho chiesto. La review serve anche a togliere, non solo a validare. Su codebase reali sottrarre è più prezioso che aggiungere.
- Falsa sicurezza dei test verdi. Un test che passa non vuol dire un test che verifica la cosa giusta. Ho imparato a leggere gli assert, non solo il colore verde. Questo controllo è non-delegabile.
I tre punti hanno la stessa radice: l'agente fa esattamente ciò che il contesto gli permette di fare, e il contesto lo scrivi tu. Le regole implicite diventano errori perché non sono nel contesto, l'astrazione superflua nasce dove nessuno ha fissato un limite, il test inutile passa perché nessuno ha detto che cosa deve verificare. Per questo la prima voce è quella con più ritorno, e per questo il file di regole del progetto conta quanto il codice: Claude Code lo tratta come contesto e non come configurazione imposta, come spiego nell'articolo sulla memoria, e ciò che deve essere imposto va negli hook.
La regola che ne ho tratto: gli agenti accelerano ciò che già so valutare, e rallentano ciò che non so ancora valutare. Nello specifico, se non saprei giudicare l'output da solo, l'agente amplifica il rischio invece di ridurlo.
Il ruolo dell'AI: accompagnamento, mai regista
Qui sta il punto di posizionamento che tengo fermo. L'AI è la troupe, non il regista. Nel mio flusso decide sempre un umano: cosa costruire, con quali vincoli, cosa è accettabile mandare in produzione. Lo strumento esegue in fretta le parti meccaniche, ma la responsabilità del risultato resta di chi firma il commit.
La stessa disciplina la applico al prodotto. I servizi AI del portfolio giravano su Ollama on-prem sul VPS (fino al 23 ottobre 2026: nessun dato usciva dal server), poi su OpenRouter, piano gratuito, fino al 12 novembre 2026, con degradazione controllata se il provider era giù o limitava le richieste; oggi girano su un motore AI locale sul server del sito, con una coda di lavori (vedi nota di aggiornamento in apertura). Lo strumento con cui scrivo il codice è una cosa; il provider che serve gli utenti è un'altra.
Come adottare questo workflow (tu, non io)
Se scrivi software e vuoi provare questo modo di lavorare, il valore non è copiare i miei agenti: è cambiare il tuo ruolo. Parti da qui, in ordine di ritorno.
- Scrivi le tue regole. Un file di convenzioni del progetto (stack, gotcha, cosa è vietato) è ciò che rende un agente utile invece che pericoloso. È l'investimento con il ritorno più alto.
- Separa decisione da esecuzione. Prima decidi le regole e i confini, poi lascia eseguire. Non mescolare i due momenti: è lì che si perde il contesto.
- Rendi la review non-negoziabile. Leggi il diff, leggi gli assert dei test, chiediti cosa manca. La velocità a monte vale solo se il cancello a valle è serio.
- Parallelizza solo l'indipendente. Due task che non si toccano possono girare insieme; due che condividono lo stesso file no. Saperli distinguere è una competenza di architettura, non di prompt.
L'ordine è quello del ritorno sull'investimento, e non è intercambiabile: senza regole scritte la separazione fra decisione ed esecuzione non ha cosa trasmettere, senza una review seria la velocità produce solo errori più in fretta, e la parallelizzazione, che è l'ultimo passo, moltiplica sia i risultati sia i difetti. Chi parte dall'ultimo punto, perché è quello che fa notizia, ottiene il risultato opposto a quello che cerca.
Cosa ho imparato scrivendo questo pezzo
La sorpresa più grande è stata rendermi conto di quanto poco del mio valore fosse nella battitura. Per anni ho misurato la mia giornata in codice prodotto; oggi la misuro in decisioni prese bene e problemi non creati. Infatti il workflow agentico non mi ha reso meno sviluppatore: mi ha costretto a essere più chiaro su cosa voglio, perché adesso qualcuno esegue letteralmente ciò che scrivo.
È l'ultimo articolo di una serie che parte da una guida pratica e che ho chiuso con l'integrazione fra skill, agent e piano: è il racconto di un lavoro vero, mentre gli altri sono i pezzi con cui è fatto.
Cluster correlato: la skill debugging Serve un modulo custom come questo? Parliamone
Domande frequenti
Il coding agentico sostituisce lo sviluppatore?
No. Nel mio flusso sposta il valore dallo scrivere codice al decidere, orientare e verificare. L'agente esegue in fretta le parti meccaniche, ma le regole di dominio, i dati reali e la review finale restano responsabilità umana. Chi non sa valutare l'output non dovrebbe delegarlo.
Come fai a costruire un modulo in circa quattro ore?
Nel mio racconto, non misurato: non ottimizzo la velocità di battitura ma il context-switch. GSD divide il lavoro in fasi e task atomici, gli agenti specializzati eseguono i piani indipendenti in parallelo mentre io decido e verifico, e la sovrapposizione tra guida umana e lavoro degli agenti comprime l'orologio.
Quali sono gli svantaggi del workflow agentico?
Gli agenti reinventano le convenzioni non scritte, tendono all'over-engineering e producono test verdi che non sempre verificano la cosa giusta. Accelerano ciò che già sai valutare e amplificano il rischio su ciò che non sai ancora giudicare. La review resta non-delegabile.
Quale provider AI usa il portfolio?
Dal 23 ottobre al 12 novembre 2026 i servizi AI runtime del portfolio hanno girato su OpenRouter (piano gratuito, costo zero), con data_collection: "deny" in ogni richiesta: i prompt non venivano usati per addestrare i modelli, ma i dati potevano uscire dall'Unione e non dichiaravo che non venissero conservati. Fino al 22 ottobre 2026 giravano su Ollama on-prem sul VPS. Dal deploy del 12 novembre 2026 i servizi AI usano un motore AI locale sul server del sito, in Europa, con una coda di lavori: le richieste AI non sono inviate a fornitori terzi, e su CPU senza GPU i tempi sono più lunghi. Lo strumento con cui scrivo il codice è una cosa distinta dal provider che serve gli utenti finali.
Fonti
- open-gsd/gsd-core, README - il ciclo discutere, pianificare, eseguire in ondate parallele con contesto pulito, verificare, consegnare. Consultata il 2026-11-13.
- open-gsd/gsd-core, agente gsd-executor - esecuzione dei piani con commit per ogni task. Consultata il 2026-11-13.
- Exploring Generative AI - Martin Fowler - raccolta di note di Thoughtworks sulle pratiche di sviluppo con l'AI, compresi esperimenti di ingegneria agentica; letta come contesto, nessuna cifra ne è ripresa. Consultata il 2026-11-13.
- How Claude remembers your project - i file CLAUDE.md come contesto e non come configurazione imposta; per bloccare un'azione si indica un hook PreToolUse. Consultata il 2026-11-13.
- Ollama - sito del progetto, citato per il passo sul provider dei servizi del portfolio. Consultata il 2026-11-13.
Commenti
Caricamento commenti...
Accedi per commentare