v1.9.6

6.2K 32K/mo

GSD: Get Shit Done

A light-weight and powerful meta-prompting, context engineering and spec-driven development system for Claude Code by TÂCHES.

Trusted by engineers at Amazon, Google, Shopify, and Webflow.

15:57

Stop Using Ralph Loops (Use This Instead)

Chase AI demonstrates why GSD might be a better fit for your Claude Code workflow, with a full demo comparing Ralph loops to GSD's structured approach.

"If you know clearly what you want, this WILL build it for you. No bs."

"I've done SpecKit, OpenSpec and Taskmaster — this has produced the best results for me."

"By far the most powerful addition to my Claude Code. Nothing over-engineered. Literally just gets shit done."

Why GSD Exists

Other spec-driven development tools exist (BMAD, SpecKit), but they make things way more complicated than they need to be—sprint ceremonies, story points, stakeholder syncs, retrospectives, Jira workflows—or lack real big picture understanding.

The Philosophy: The complexity is in the system, not in your workflow. Behind the scenes: context engineering, XML prompt formatting, subagent orchestration, state management. What you see: a few commands that just work.

Who this is for: People who want to describe what they want and have it built correctly—without pretending they're running a 50-person engineering org.

Key Features

Multi-Agent Orchestration

A thin orchestrator spawns specialized agents for Research, Planning, Execution, and Verification. Heavy lifting happens in fresh subagent contexts, keeping the main context window efficient (~30-40% utilization).

XML-Structured Tasks

Every task is formatted in XML with name, files, action, verify, and done elements. This provides Claude with precise, unambiguous instructions and built-in verification steps.

Atomic Git Commits

Each task results in its own atomic commit immediately upon completion. Commit format: type(phase-plan): description

Automatic Debug Agents

When verification fails, GSD spawns debug agents to diagnose root causes and generate verified fix plans that can be re-executed automatically.

The GSD Workflow

One command, one flow. The system gives Claude everything it needs to do the work and verify it.

Initialize Project

/gsd:new-project

Questions → Research → Requirements → Roadmap. Asks until it understands your idea completely (goals, constraints, tech preferences, edge cases). Spawns parallel agents to investigate the domain. Extracts what's v1, v2, and out of scope.

PROJECT.md

REQUIREMENTS.md

ROADMAP.md

STATE.md

.planning/research/

Discuss Phase

/gsd:discuss-phase 1

This is where you shape the implementation. Your roadmap has a sentence or two per phase—this step captures your preferences. The system identifies gray areas: Visual features (layout, density, interactions), APIs/CLIs (response format, error handling), Content systems (structure, tone, depth), Organization tasks (grouping, naming).

{phase}-CONTEXT.md

Plan Phase

/gsd:plan-phase 1

Researches how to implement this phase guided by your CONTEXT.md decisions. Creates 2-3 atomic task plans with XML structure. Verifies plans against requirements, loops until they pass. Each plan is small enough to execute in a fresh context window—no degradation.

{phase}-RESEARCH.md

{phase}-{N}-PLAN.md

Execute Phase

/gsd:execute-phase 1

Runs plans in waves—parallel where possible, sequential when dependent. Fresh context per plan (200k tokens purely for implementation, zero accumulated garbage). Commits per task—every task gets its own atomic commit. Verifies against goals—checks the codebase delivers what the phase promised.

{phase}-{N}-SUMMARY.md

{phase}-VERIFICATION.md

Verify Work

/gsd:verify-work 1

This is where you confirm it actually works. Extracts testable deliverables. Walks you through one at a time ('Can you log in with email?' Yes/no). Diagnoses failures automatically—spawns debug agents to find root causes. Creates verified fix plans ready for immediate re-execution.

{phase}-UAT.md

fix plans if issues found

Loop discuss → plan → execute → verify until milestone complete, then run /gsd:complete-milestone to archive and tag the release.

Quick Mode

`/gsd:quick`For ad-hoc tasks that don't need full planning

Quick mode gives you GSD guarantees (atomic commits, state tracking) with a faster path. Use for: bug fixes, small features, config changes, one-off tasks.

Same agents (Planner + Executor)

Skips research & plan checker

Atomic commits

Lives in .planning/quick/

/gsd:quick
> What do you want to do? "Add dark mode toggle to settings"

Creates: .planning/quick/001-add-dark-mode-toggle/PLAN.md, SUMMARY.md

Why It Works: Context Engineering

Claude Code is incredibly powerful if you give it the context it needs. Most people don't. GSD handles it for you:

File	What it does
`PROJECT.md`	Project vision, always loaded
`research/`	Ecosystem knowledge (stack, features, architecture, pitfalls)
`REQUIREMENTS.md`	Scoped v1/v2 requirements with phase traceability
`ROADMAP.md`	Where you're going, what's done
`STATE.md`	Decisions, blockers, position—memory across sessions
`PLAN.md`	Atomic task with XML structure, verification steps
`SUMMARY.md`	What happened, what changed, committed to history
`todos/`	Captured ideas and tasks for later work

Size limits based on where Claude's quality degrades. Stay under, get consistent excellence.

XML Prompt Formatting

Every plan is structured XML optimized for Claude. Precise instructions. No guessing. Verification built in.

<task type="auto">
  <name>Create login endpoint</name>
  <files>src/app/api/auth/login/route.ts</files>
  <action>
    Use jose for JWT (not jsonwebtoken - CommonJS issues).
    Validate credentials against users table.
    Return httpOnly cookie on success.
  </action>
  <verify>curl -X POST localhost:3000/api/auth/login returns 200 + Set-Cookie</verify>
  <done>Valid credentials return cookie, invalid return 401</done>
</task>

Getting Started

Installation

npx get-shit-done-cc

Works on Mac, Windows, and Linux. The installer prompts you to choose your runtime (Claude Code, OpenCode, or both). Verify with /gsd:help inside your Claude Code or OpenCode interface.

Staying Updated

GSD evolves fast. Check for updates periodically:

/gsd:whats-new

npx get-shit-done-cc@latest

Recommended: Skip Permissions Mode
GSD is designed for frictionless automation. Run Claude Code with claude --dangerously-skip-permissions. Stopping to approve date and git commit 50 times defeats the purpose.

Already Have Code?

Run /gsd:map-codebase first. It spawns parallel agents to analyze your stack, architecture, conventions, and concerns. Then /gsd:new-project knows your codebase—questions focus on what you're adding, and planning automatically loads your patterns.

Ralph vs GSD

Ralph Loops

Simple bash loop execution

Manual PRD task management

AGENTS.md for context

progress.txt for state

Lightweight, DIY approach

Best for: Learning fundamentals, small projects

GSD Framework

Multi-agent orchestration

XML-structured task plans

Built-in verification steps

Automatic debug agents

Atomic git commits per task

Best for: Production builds, larger projects

Token Usage: GSD is "token hungry" due to its multi-agent orchestration. Users on standard Claude Pro ($20/month) may hit limits quickly with larger codebases. Consider higher-tier plans for optimal use, though GSD's design aims to use less context per individual window by keeping them short.

Which Should You Use?

Both Ralph and GSD solve the same core problem: AI context degradation. The right choice depends on your project scale and preferences.

Choose Ralph if:

• You want to understand the fundamentals
• You're building something small
• You prefer DIY customization

Choose GSD if:

• You want batteries-included automation
• You're building production software
• You need verification & debugging