GSD (Get-Shit-Done) — Spec-Driven Development System for Claude Code

Source: raw/gh-star-gsd-build-get-shit-done.md (GitHub star stub, 2026-05-20) + README extraction from github.com/gsd-build/get-shit-done.

GSD is a meta-prompting and spec-driven-development system for Claude Code (and 7 other AI runtimes) maintained by TÂCHES. It’s the toolchain behind the /gsd-* slash-command family available in this user’s Claude Code config (/gsd-do, /gsd-explore, /gsd-new-project, etc.). The system addresses context rot — the quality degradation that happens as your AI fills its context window — by maintaining five structured artifacts across sessions (PROJECT.md, REQUIREMENTS.md, ROADMAP.md, STATE.md, CONTEXT.md) and using a six-step slash-command loop with fresh subagent contexts.

Key Takeaways

• Six-step main loop: /gsd-new-project → /gsd-discuss-phase → /gsd-plan-phase → /gsd-execute-phase → /gsd-verify-work → /gsd-ship. The loop closes with PR creation.
• Five persistent artifacts: PROJECT.md (project identity), REQUIREMENTS.md (what’s being built), ROADMAP.md (multi-phase plan), STATE.md (current state), CONTEXT.md (cross-session continuity). Survives session boundaries.
• Multi-runtime support: Claude Code, OpenCode, Gemini CLI, Kilo, Codex, Copilot, Cursor, Windsurf. Single source of truth for spec across 8 AI coding tools.
• Multi-agent architecture with fresh contexts. Researchers, planners, and executors each get their own context window. Main session stays at 30-40% utilization while heavy work is offloaded — “exactly what they need.”
• MIT license maintained by TÂCHES. 63.3k stars, 5.4k forks (May 2026).
• One-line install: npx get-shit-done-cc@latest.
• /gsd-* family is what shows up in /help — this is the third-party framework behind dozens of /gsd-* slash commands in the user’s Claude Code session (gsd-new-project, gsd-explore, gsd-do, gsd-add-phase, gsd-ai-integration-phase, gsd-spec-phase, gsd-research-phase, gsd-ultraplan-phase, etc.).

The Six-Step Loop

1. /gsd-new-project — Initial questionnaire → research → requirements → roadmap. Establishes the five-artifact base layer.
2. /gsd-discuss-phase [N] — Capture implementation decisions for phase N. Forces the conversation onto disk so the next session inherits the trail.
3. /gsd-plan-phase [N] — Researcher + planner subagents research, plan, and verify tasks. Tasks are explicitly verifiable.
4. /gsd-execute-phase <N> — Run plans in parallel waves. Executor subagents share the artifact layer but operate in isolated contexts.
5. /gsd-verify-work [N] — Manual acceptance testing and diagnosis. Human in the loop here.
6. /gsd-ship [N] — Create the pull request from completed phases.

Plus utility commands: /gsd-progress, /gsd-complete-milestone, /gsd-new-milestone, /gsd-add-phase, /gsd-spec-phase, /gsd-research-phase, /gsd-ultraplan-phase, /gsd-spike, /gsd-debug, /gsd-extract_learnings, /gsd-pr-branch, /gsd-code-review-fix, and more (full list visible in the user’s local skill registry).

Architectural Approach

The interesting design choice is the explicit separation of context layers between main session and subagents:

• Main session: Curates artifacts, decides what subagents need, runs verification gates. Stays under 30-40% context utilization.
• Subagents: Receive scoped subsets of the artifact layer plus a focused task. Fresh context per phase.
• Artifact layer: Disk-backed (the five MD files). Survives /compact, /clear, and session restart.

Pattern overlaps with the Printing Press thesis (delegated context, CLI > MCP > API for token efficiency) and the specificity-paradox refactor 161→52 turns case study — both point at “context discipline beats raw context window” as the load-bearing concern at scale.

Implementation

Tool/Service: GSD (Get-Shit-Done) by TÂCHES Setup:

npx get-shit-done-cc@latest

Cost: Free (MIT). Token costs at usual Claude Code rates. Integration notes: Installs to ~/.claude/skills/gsd-*/ (Claude Code) or equivalent for other runtimes. The npx command bootstraps the five-artifact layer in the project root. Six core slash commands appear immediately; the long-tail utility commands populate as you progress through phases. Compatible with OpenSpec artifact-layer thinking but distinct in structure (GSD’s STATE.md is more granular than OpenSpec’s proposal.md).

Differentiation vs Adjacent Frameworks

Tool	Form factor	What it does	GSD vs
OpenSpec	Spec-driven framework	proposal.md + design.md + tasks.md + per-concern specs/	OpenSpec is artifact-first; GSD is loop-first (six-step + fresh subagent contexts)
Superpowers (Jesse Vincent)	Closed end-to-end methodology	Full SDLC methodology in skills bundle	Superpowers wraps the full lifecycle; GSD is project-scoped six-step + artifact layer
gstack (Garry Tan)	23-tool YC-CEO setup	Persona slash commands (CEO/QA/SRE/etc.)	gstack is role-persona; GSD is phase-loop
SuperClaude	Meta-programming framework	30 /sc:* slash commands + 20 agents + 8 MCP integrations	SuperClaude is broader; GSD is single methodology executed deeply

Open Questions

• TÂCHES — individual or org? README lists TÂCHES as the maintainer (individual creator per the WebFetch summary), but the brand styling suggests a studio name. Worth a follow-up before treating GSD as an org-backed project vs a solo build.
• Star-count provenance. 63.3K stars is exceptional but plausible given the npx-install entry point + multi-runtime support. Periodic check for normalization is worth scheduling.
• Cross-runtime parity. README claims 8 AI runtimes are supported. Worth testing whether the artifact-layer continuity actually holds across, e.g., Claude Code → Cursor handoff vs being effectively single-runtime in practice.
• Subagent isolation strength. “Fresh context windows” is the explicit claim, but how the system prevents context bleed (a known Claude Code subagent bug surfaced multiple times in this wiki) isn’t documented.

Related

• Claude AI topic
• OpenSpec — Spec-Driven Vibe-Coding Framework
• Superpowers — Agentic Skills Framework
• gstack — Garry Tan’s 23-Tool Setup
• SuperClaude Framework
• Context Management in Claude Code
• Claude Code Subagents

Try It

1. npx get-shit-done-cc@latest in a small side project — let the questionnaire seed PROJECT.md and watch the artifact layer get created.
2. Read the generated REQUIREMENTS.md and ROADMAP.md before running /gsd-plan-phase 1. The first plan is the structural test of whether the artifact layer captured what you meant.
3. Compare against OpenSpec on the same project — both are spec-driven; the difference is whether you want loop-first phase gates (GSD) or artifact-first per-concern specs (OpenSpec).
4. Verify subagent isolation by inspecting ~/.claude/skills/gsd-*/ after a /gsd-execute-phase run — fresh subagent context is GSD’s load-bearing claim and worth observing once.
5. Couple with Printing Press when execution involves a CLI factory — GSD handles the spec layer; Printing Press handles the CLI generation layer. Token-economics-friendly.