Se una funzionalità che chiedi a un assistente è abbastanza grande da non stare in una sola conversazione, il rischio non è che il lavoro sia difficile: è che a metà il contesto sia pieno di vecchie ipotesi e che le risposte peggiorino senza che tu te ne accorga. Get Shit Done (GSD) risponde con una regola: il piano sta in file nel repository, e ogni esecutore riparte da un contesto vuoto che legge solo ciò che gli serve. Qui ti spiego come è fatto, in quale ordine si usa e dove l'ho visto aiutare e dove no.
Indipendenza: non sono affiliato agli autori di GSD né a Anthropic. Ho letto il README e la documentazione di GSD Core il 2026-11-13; non ho eseguito GSD per scrivere questa pagina, quindi i comandi sono quelli della documentazione e i passi che dipendono dall'assistente sono dichiarati come tali. Dove racconto un'esperienza mia lo faccio senza cifre che non ho misurato. Il contesto della serie è nella guida di apertura; la parte sulle skill è nella pagina di Superpowers.
Che cos'è e da dove si scarica oggi
GSD si presenta come un sistema leggero di meta-prompting, context engineering e sviluppo guidato da specifiche per Claude Code, e oggi anche per altri ambienti. Il repository originale, gsd-build/get-shit-done, lo attribuisce a TÂCHES, è con licenza MIT ed è stato archiviato con un rimando: lo sviluppo continua in open-gsd/gsd-core. Un repository qrx/get-shit-done, che si trova citato in testi vecchi, non è il progetto: la fonte da usare è il nuovo repository, la cui installazione passa da npx @opengsd/gsd-core@latest, come scrive il README.
La sua tesi è nel README e nella pagina sul ciclo di fase: il degrado della qualità cresce con il contesto, quindi il lavoro pesante (ricerca, pianificazione, esecuzione) gira in sub-agent a contesto fresco, mentre la sessione principale resta leggera e lo stato sta in file. Non è magia e non è un runtime: sono comandi che avviano agenti, più una cartella di file Markdown. Se non vuoi i comandi, i file restano comunque leggibili da te.
Che cosa c'è dentro .planning/
Lo stato di un progetto GSD vive in una cartella .planning/ alla radice del repository. Il documento di architettura di GSD Core mostra i file di base, che elenco con la funzione che hanno nel ciclo.
PROJECT.md: che cosa è il progetto e le decisioni che valgono per tutto il resto.REQUIREMENTS.md: i requisiti, a cui i piani rimandano.ROADMAP.md: le fasi, ciascuna con il suo obiettivo.STATE.md: dove si è arrivati; la documentazione descrive un lock sul file per evitare che due agenti lo scrivano insieme.config.json,phases/eresearch/: impostazioni, una cartella per fase con piani, contesto e ricerca, e il materiale di ricerca.codebase/: la mappa di un progetto esistente, prodotta da/gsd-map-codebase.
La lettura utile è questa: PROJECT.md e REQUIREMENTS.md cambiano di rado e dicono perché, ROADMAP.md e phases/ dicono che cosa e in che ordine, STATE.md dice a che punto sei. Tutto è testo versionabile, e quando torni su una fase mesi dopo hai la traccia di che cosa era stato deciso. Questa è la parte del metodo che per me ha contato di più, più dei comandi stessi.
Il ciclo di fase, comando per comando
Ogni fase ripete cinque passi: discutere, pianificare, eseguire, verificare, consegnare. I comandi sono quelli del riferimento di GSD Core, con il trattino nel nome (negli articoli più vecchi si trova la forma con i due punti, che non è più quella documentata).
/gsd-phase aggiunge una fase alla ROADMAP
/gsd-discuss-phase 3 raccoglie le decisioni in CONTEXT.md
/gsd-plan-phase 3 ricerca, piani e verifica dei piani
/gsd-execute-phase 3 esegue i piani a ondate
/gsd-verify-work 3 verifica con te e produce UAT.md
/gsd-ship pull request e chiusura della fase
/gsd-quick un compito piccolo, senza il ciclo
Sono comandi interni a Claude Code: non li ho eseguiti, il blocco è uno schema da adattare. Il 3 è il numero della fase; senza numero /gsd-plan-phase prende la prossima fase non ancora pianificata. La separazione fra discutere e pianificare è la meno ovvia e la più utile: la documentazione spiega che senza il passo di discussione il pianificatore deve decidere da solo come costruire, e quando indovina «plausibilmente ma male» lo scopri a esecuzione finita. Il passo produce un file CONTEXT.md letto da pianificatore, esecutore e verificatore.
Ondate: da dove vengono, e come controllarle
Un piano di GSD è un'unità di lavoro delimitata: i file da toccare, le modifiche, i criteri di accettazione. I piani sono ordinati in ondate di dipendenza: quelli senza dipendenze vanno nella prima, quelli che dipendono dalla prima nella seconda, e così via; gli esecutori di una stessa ondata girano in parallelo, quelli di ondate diverse in sequenza. La documentazione lo mostra con cinque piani: 01 e 02 senza dipendenze, 03 dipendente da 01, 04 da 02, 05 da 03 e 04. Il risultato sono tre ondate: 01 e 02, poi 03 e 04, poi 05.
Ho riprodotto quell'esempio con uno script, che legge il campo depends_on dal frontmatter di cinque file di prova e calcola le ondate. Controlla anche i due errori che rendono un insieme di piani inesecutibile: una dipendenza verso un piano che non esiste e una dipendenza circolare. È una mia riscrittura per capire la regola, non il codice di GSD, e non pretende di descrivere come il programma lo calcoli davvero.
# fasi/ok/03-PLAN.md (gli altri quattro hanno la stessa forma; 01 e 02 hanno depends_on: [])
---
phase: 03
depends_on: ["01"]
---
# Piano 03
# onde.py
"""Raggruppa i piani di una fase in ondate, a partire da `depends_on` nel frontmatter di ogni PLAN.md."""
import glob
import re
import sys
def leggi_piani(cartella):
piani = {}
for percorso in sorted(glob.glob(f"{cartella}/*-PLAN.md")):
sigla = percorso.split("/")[-1].split("-")[0]
testo = open(percorso, encoding="utf-8").read()
m = re.search(r"^depends_on:\s*\[(.*?)\]\s*$", testo, re.M)
elenco = [d.strip().strip("\"'") for d in m.group(1).split(",")] if m and m.group(1).strip() else []
piani[sigla] = elenco
return piani
def ondate(piani):
sconosciuti = {(p, d) for p, deps in piani.items() for d in deps if d not in piani}
if sconosciuti:
raise ValueError(f"dipendenze verso piani inesistenti: {sorted(sconosciuti)}")
livello = {}
while len(livello) < len(piani):
pronti = [p for p, deps in piani.items() if p not in livello and all(d in livello for d in deps)]
if not pronti:
raise ValueError(f"dipendenza circolare fra: {sorted(set(piani) - set(livello))}")
for p in pronti:
livello[p] = 1 + max((livello[d] for d in piani[p]), default=0)
return {n: sorted(p for p, v in livello.items() if v == n) for n in sorted(set(livello.values()))}
for cartella in sys.argv[1:]:
print(f"== {cartella}")
try:
for n, gruppo in ondate(leggi_piani(cartella)).items():
print(f"ondata {n}: {', '.join(gruppo)}")
except ValueError as errore:
print(f"ERRORE: {errore}")
# Uscita (python3 -I onde.py fasi/ok fasi/rotta fasi/ciclo):
# == fasi/ok
# ondata 1: 01, 02
# ondata 2: 03, 04
# ondata 3: 05
# == fasi/rotta
# ERRORE: dipendenze verso piani inesistenti: [('02', '07')]
# == fasi/ciclo
# ERRORE: dipendenza circolare fra: ['01', '02']
Nel primo caso l'uscita coincide con l'esempio della documentazione. Nel secondo il piano 02 dichiara una dipendenza da un 07 che non c'è, e lo script lo rifiuta con il nome della coppia colpevole. Nel terzo 01 e 02 si aspettano a vicenda e non si trova nessun piano pronto da eseguire, ed è il ciclo che dà il messaggio. Il livello di un piano è uno più il massimo dei livelli da cui dipende: lo vedi nella riga livello[p] = 1 + max(...). Eseguito due volte con uscita identica; i file di prova sono creati in una cartella mia fuori dal repository.
Il parallelismo ha un costo che la documentazione dichiara: gli esecutori della stessa ondata devono toccare parti non sovrapposte, e per evitare conflitti ci sono due meccanismi, i commit con --no-verify (gli hook pre-commit girano una volta a fine ondata) e il lock su STATE.md. Quanto tempo risparmi dipende dai tuoi piani, e non ho una misura da darti: non ho un fattore da garantirti. Il articolo 11 parte da qui.
Il plan-checker e la dimensione della fase
Dopo che il pianificatore ha scritto i piani, un terzo agente, il plan-checker, verifica che siano completi, coerenti e dentro lo scopo. Il documento di architettura lo inquadra in un ciclo di verifica con un massimo di tre iterazioni; esiste un'opzione per saltarlo, --skip-verify, ma non la consiglio come abitudine. Una nota che mi ha fatto rivedere un'idea: nel confronto di ogni piano con un budget di token, il checker produce una stima che la documentazione dichiara consultiva, che non blocca mai la pianificazione. Un avviso non è un divieto.
Ricordo una fase in cui il plan-checker mi ha fatto notare che un piano dipendeva da un componente che il piano precedente aveva soltanto abbozzato: l'ho scoperto prima di eseguire, ed è il tipo di errore che un piano scritto bene non fa vedere. È un episodio, non una statistica; per la quantità di errori che un controllo del piano intercetta in media non ho dati. Per la dimensione, la documentazione sul ciclo è netta: una fase troppo grande diventa un progetto di ricerca a sé, e in caso di dubbio conviene dividerla.
Un progetto che esiste già
Per partire da un codebase esistente il README indica /gsd-onboard, che passa da /gsd-map-codebase per creare la mappa in .planning/codebase/, con quattro agenti paralleli o, con --fast, uno solo. Se hai già documenti di pianificazione, ADR o specifiche, /gsd-ingest-docs costruisce o fonde la cartella .planning/ da quei documenti e produce un rapporto dei conflitti. Sono tre punti di ingresso diversi per tre situazioni diverse: codice senza documenti, codice con documenti, progetto nuovo.
Quando non serve
GSD ha un costo fisso di cerimonia: discutere, pianificare, controllare. Per una correzione da pochi minuti il costo supera il lavoro, ed è la stessa documentazione a dirlo: sotto la soglia in cui il ciclo aggiunge valore, per esempio correggere un refuso nel README, si usa /gsd-quick. Quel comando può comunque aggiungere discussione, ricerca e controllo del piano con le opzioni --discuss, --research e --validate; con --validate il controllo dei piani ha un massimo di due iterazioni. La mia regola personale è che se il lavoro entra in una frase sola, non apro una fase.
Domande frequenti
Chi ha creato Get Shit Done?
Il repository originale, gsd-build/get-shit-done, lo descrive come opera di TÂCHES. È stato archiviato e lo sviluppo continua come GSD Core in open-gsd/gsd-core; per codice e documentazione correnti usa quel repository.
GSD funziona solo con Claude Code?
No. Il README di GSD Core elenca anche OpenCode, Codex, Copilot, Cursor, Windsurf e altri ambienti, e l'installatore chiede il runtime. Questa serie parla del caso Claude Code.
Che differenza c'è fra una fase e un piano?
La fase è un obiettivo nella ROADMAP, dentro una milestone. Un piano è un'unità di lavoro delimitata dentro la fase, con file da toccare e criteri di accettazione; i piani si raggruppano in ondate in base alle dipendenze.
Posso saltare il controllo dei piani?
Sì, con --skip-verify su /gsd-plan-phase, come dice il riferimento dei comandi. Il controllo serve a catturare ambiguità prima dell'esecuzione, quando costano meno: salta solo quando la fase è davvero banale.
Che cosa sai fare adesso
Sai dove vive lo stato di un progetto GSD e che cosa contiene ciascun file, sai in quale ordine si usano i comandi del ciclo e quale repository consultare oggi. Sai calcolare a mano le ondate di un insieme di piani e riconoscere subito una dipendenza mancante o circolare. Sai anche scegliere fra una fase completa e /gsd-quick. Il passo successivo è il confronto fra fasi orizzontali e verticali.
Nella stessa serie trovi anche la skill di brainstorming e il plan-checker.
Fonti
- GSD Core, README - ciclo in cinque passi, installazione, comandi
/gsd-new-projecte/gsd-onboard, ambienti supportati, consultata il 2026-11-13 - GSD Core, riferimento dei comandi - opzioni di
/gsd-plan-phase,/gsd-execute-phase,/gsd-quick,/gsd-map-codebase,/gsd-ingest-docs, consultata il 2026-11-13 - GSD Core, architettura - file di
.planning/, modello a ondate, ciclo di verifica con massimo tre iterazioni, sicurezza dei commit paralleli, consultata il 2026-11-13 - GSD Core, il ciclo di fase - funzione di discussione, piano ed esecuzione, scopo di una fase, consultata il 2026-11-13
- gsd-build/get-shit-done, repository originale archiviato - attribuzione a TÂCHES, licenza MIT e rimando al nuovo repository, consultata il 2026-11-13
- Misura nel repository:
python3 -I onde.pysu file di prova, eseguito due volte con uscita identica, 2026-11-13
Commenti
Caricamento commenti...
Accedi per commentare