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 + raw/reddit-1tktl4w.md (r/ClaudeAI, 2026-05-22, 448 score / 75 comments — TÂCHES rug-pull + community fork advisory).

2026-05-22 — TÂCHES rug-pulled the project. Migrate to get-shit-done-redux.

The original maintainer (TÂCHES) abandoned the project, launched a $GSD crypto token alongside it, drained the liquidity once enough buyers loaded in, and disappeared. Uninstall the old NPM package immediately — the rug-puller still has publish access to the original namespace and could push a malicious update. The community has forked the project to get-shit-done-redux, run a security sweep, and that’s the migration target. See ## 2026-05-22 Status Update below + r/ClaudeAI 1tktl4w (448 score). Resolves the Open Question on whether TÂCHES was individual or org — individual creator, who exit-scammed.

GSD is a meta-prompting and spec-driven-development system for Claude Code (and 7 other AI runtimes) originally maintained by TÂCHES (rug-pulled 2026-05-22; the canonical fork is now get-shit-done-redux). 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

2026-05-22 Status Update — TÂCHES Rug-Pull, Migrate to get-shit-done-redux

The original creator (TÂCHES, confirmed individual after the exit-scam) launched a $GSD crypto token alongside the project, executed a classic rug-pull once enough buyers were in, and abandoned the codebase. The community responded by forking the project to get-shit-done-redux, running a security sweep, and treating the original NPM namespace as compromised because TÂCHES still has publish access to it. The Reddit advisory (r/ClaudeAI 1tktl4w, 448 score / 75 comments, u/linuxzinho) is the canonical PSA — uninstall the old packages, switch to redux.

Practical migration steps:

1. Uninstall the old packages. npm uninstall -g get-shit-done-cc (and any per-project get-shit-done-* installs). The risk isn’t what’s on your machine today — it’s what gets pushed to your machine tomorrow if the rug-puller decides to ship a malicious update.
2. Audit ~/.claude/skills/gsd-*/ for files that came from the old install. The skills layer on disk is mostly markdown/prompt files; less risk than the npm bootstrap script, but worth a git log-style review if you’ve been making your own edits on top.
3. Install the redux fork. Replace the npx get-shit-done-cc@latest entrypoint with whatever redux ships as its canonical install command (verify the fork URL + maintainer set on a third-party source before pasting any one-liner from the Reddit thread).
4. Watch the broader Anthropic/Claude-Code ecosystem for the same pattern. Single-maintainer NPM packages with npx-installer convenience are a structurally weak supply-chain shape; this is the first high-profile rug-pull in the Claude-skills ecosystem but it won’t be the last. The claude plugins marketplace surface (which has Anthropic + community gating) is the lower-blast-radius alternative for skills that have a marketplace listing.

The five-artifact + six-step pattern documented elsewhere in this article is the idea of GSD; that survives the maintainer change. Everything in the rest of this article that describes the loop, artifacts, and subagent architecture still applies — substitute get-shit-done-redux for get-shit-done-cc as the install entrypoint.

Open Questions

• TÂCHES — individual or org? Resolved 2026-05-22: individual creator, who exit-scammed via a $GSD crypto token rug-pull. The brand styling that suggested a studio was misleading.
• 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 — and post-rug-pull, expect the original repo’s stars to lag while redux’s stars climb.
• get-shit-done-redux maintainer set + security-sweep depth. Reddit reports the community ran a sweep before adopting redux as canonical; nothing in this article verifies who ran it or what was checked. Worth a fresh ingest of the redux repo to verify license + maintainer history + the sweep methodology before treating redux as load-bearing.
• 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.