Get Shit Done (GSD)

Get Shit Done (GSD)

Research Date: 2026-02-01 Source URL: https://github.com/glittercowboy/get-shit-done npm Package: https://www.npmjs.com/package/get-shit-done-cc Version at Research: v1.11.1 License: MIT

Overview

Get Shit Done (GSD) is a lightweight meta-prompting, context engineering, and spec-driven development system for Claude Code, OpenCode, and Gemini CLI. It solves "context rot" - the quality degradation that occurs as Claude fills its context window - by implementing multi-agent orchestration with fresh context per task.

Created by solo developer TACHES, GSD provides a structured workflow that transforms vibe coding into reliable, production-quality development. The system handles context engineering, XML prompt formatting, subagent orchestration, and state management behind a simple command interface.

Problem Addressed

Key Statistics

Key Features

Core Workflow Commands

Multi-Agent Architecture

GSD implements 11 specialized agents:

Context Engineering Files

XML Task Format

Every plan uses structured XML optimized for Claude:

<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>

Model Profiles

Three configurable profiles for quality vs cost tradeoffs:

Multi-Runtime Support

Technical Architecture

Orchestration Pattern

Every stage uses the same pattern: a thin orchestrator spawns specialized agents, collects results, and routes to the next step.

ORCHESTRATOR (Main Context ~30-40%)
    |
    +-- Spawns --> RESEARCHER agents (parallel, fresh context)
    |
    +-- Collects results
    |
    +-- Spawns --> PLANNER agent (fresh context)
    |
    +-- Validates --> CHECKER agent (verification loop)
    |
    +-- Spawns --> EXECUTOR agents (parallel waves, fresh 200k each)
    |
    +-- Spawns --> VERIFIER agent (goal confirmation)

The orchestrator never does heavy lifting. Work happens in fresh subagent contexts, keeping the main session fast and responsive.

Parallel Execution Waves

Plans are grouped into waves based on dependencies:

1. Wave 1: Independent tasks run in parallel
2. Wave 2: Tasks depending on Wave 1 outputs
3. Wave N: Sequential chains resolved

Each executor gets a fresh 200k token context purely for implementation.

Atomic Git Commits

Each task produces its own commit immediately after completion:

abc123f docs(08-02): complete user registration plan
def456g feat(08-02): add email confirmation flow
hij789k feat(08-02): implement password hashing
lmn012o feat(08-02): create registration endpoint

Benefits: git bisect locates failures, tasks are independently revertable, clear history for future Claude sessions.

Git Branching Strategies

Installation and Usage

Quick Start

# Interactive install
npx get-shit-done-cc

# Non-interactive options
npx get-shit-done-cc --claude --global   # Claude Code, global
npx get-shit-done-cc --opencode --global # OpenCode, global
npx get-shit-done-cc --gemini --global   # Gemini CLI, global
npx get-shit-done-cc --all --global      # All runtimes

Verify Installation

/gsd:help

Update to Latest

npx get-shit-done-cc@latest

Recommended Usage

claude --dangerously-skip-permissions

Stopping to approve date and git commit 50 times defeats the purpose of automation.

Workflow Example

# New project
/gsd:new-project

# For each phase
/gsd:discuss-phase 1      # Capture implementation preferences
/gsd:plan-phase 1         # Research + create verified plans
/gsd:execute-phase 1      # Parallel execution with fresh contexts
/gsd:verify-work 1        # User acceptance testing

# Complete milestone
/gsd:complete-milestone
/gsd:new-milestone        # Start next version

Brownfield Projects

/gsd:map-codebase         # Analyze existing codebase first
/gsd:new-project          # Then initialize with awareness

Relevance to Claude Code Development

Applicable Patterns

1. Fresh Context per Task: Spawning subagents with isolated 200k context prevents quality degradation from context pollution - directly applicable to skill execution patterns

2. File-Based State Management: Using markdown files (STATE.md, ROADMAP.md) for persistent state across sessions provides a reliable pattern for long-running workflows

3. XML Task Structures: Structured XML with explicit <action>, <verify>, <done> fields improves Claude's task comprehension and completion accuracy

4. Orchestrator-Worker Separation: Thin orchestrators that spawn specialized workers preserves main context while enabling complex workflows

5. Model Profile Configuration: Quality/balanced/budget profiles demonstrate practical cost/quality tradeoff management for multi-agent systems

6. Atomic Commits per Task: One commit per completed task creates traceable, revertable git history ideal for AI-generated code

7. Verification Loops: Plan-checker and verifier agents create feedback loops that catch errors before they compound

Integration Opportunities

Key Differentiators from Similar Tools

References

1. GitHub Repository - https://github.com/glittercowboy/get-shit-done (accessed 2026-02-01)
2. npm Package - https://www.npmjs.com/package/get-shit-done-cc (accessed 2026-02-01)
3. README Documentation - https://raw.githubusercontent.com/glittercowboy/get-shit-done/main/README.md (accessed 2026-02-01)
4. Agent Definitions - https://github.com/glittercowboy/get-shit-done/tree/main/agents (accessed 2026-02-01)
5. Command Definitions - https://github.com/glittercowboy/get-shit-done/tree/main/commands/gsd (accessed 2026-02-01)
6. Discord Community - https://discord.gg/5JJgD5svVS (referenced in README)

Freshness Tracking