Get Shit Done (GSD): What It Is & How It Fixes AI Context Rot for Coding Agents

TL;DR

Quick Answer Box (Google Search Featured Snippet):

• What is Get Shit Done (GSD)? GSD is an open-source meta-prompting and context-engineering framework for AI coding agents (Claude Code, Gemini CLI, Codex, OpenCode) that eliminates “context rot” by orchestrating isolated sub-agents - Researcher, Planner, Executor, Checker - each receiving a fresh, focused context window.
• Why it matters: Solves the universal problem where AI agents produce degraded, confused output after long conversations by segmenting tasks into atomic XML plans with verifiable bash commands.
• Quickstart: Run npx get-shit-done-cc@latest then issue /gsd:new-project in Claude Code.
• Official Repository: benolot/get-shit-done on GitHub

---

3-Minute Fast Path: From Zero to Agentic Project Execution

1. Install GSD: Run npx get-shit-done-cc@latest in your terminal to inject the GSD command set into Claude Code or your chosen agent CLI.
2. Initialize your project: Issue /gsd:new-project - the Researcher sub-agent reads your codebase and generates a PROJECT.md, REQUIREMENTS.md, and phased ROADMAP.md.
3. Plan and execute a phase: Run /gsd:plan-phase 1 to produce atomic XML task blocks, then /gsd:execute-phase 1 to dispatch parallel Executor agents - one fresh 200k-token context per task.
4. Verify and iterate: Use /gsd:verify-work 1 for acceptance testing, then repeat across phases. For routing agent traffic across multiple LLM providers during execution, pair GSD with OmniRoute.

---

Welcome back to another GitHub deep dive! Today we are looking at get-shit-done (GSD), a lightweight but astoundingly powerful meta-prompting, context engineering, and spec-driven development system for Claude Code, OpenCode, Gemini CLI, Codex, and general AI-agent workflows.

If you have ever been frustrated by AI generating code that gets more sloppy and confused as a conversation runs along, you are experiencing "context rot." GSD solves that permanently by structuring information flow for any advanced AI agent.

Part 1: Foundations (The Mental Model)

Think of standard AI coding tools like a single, brilliant contractor trying to hold an entire blueprint, a stack of change requests, and every line of code they have written in their short-term memory at the same time. At a certain point, the context degrades. The memory fills up, and the output quality curves downward into what we call "context rot."

The Mental Model for GSD is to turn that single contractor into a finely-tuned agency. Instead of one continuous, bloated conversation, GSD injects a context engineering layer. It orchestrates ephemeral sub-agents (Researchers, Planners, Executors, Checkers) that receive strictly isolated, fresh windows of context. When an Executor is writing your code, it has exactly the roadmap and exact XML atomic plan it needs to execute - using a fresh, high-capacity context window entirely for implementation, without the baggage of earlier brainstorming loops.

By structuring work incrementally and keeping your agent’s memory pristine per task, GSD gets shit done quickly, efficiently, and with incredible consistency.

Part 2: The Investigation

When we open the hood of the get-shit-done repository, we immediately see that it avoids arbitrary complexity. There are no bloated sprints or "story points"; rather, the complexity lives deep inside its system.

The architecture contains three core directories making up the magic:

• commands/: The entry point orchestrators, such as new-project.md, plan-phase.md, and execute-phase.md.
• agents/: Heavy-duty markdown files acting as specialized system prompts that dictate exact behavior for the sub-agents (e.g., gsd-planner.md, gsd-executor.md).
• .planning/: This is where GSD drops the state of your project. It cleanly separates PROJECT.md, REQUIREMENTS.md, ROADMAP.md, and creates phase folders housing precise XML-formatted PLAN.md tasks and SUMMARY.md completed reports.

The beauty of the system lies in how these orchestrators act as thin wrappers around the AI runtime (Claude, Gemini, or OpenSource), dispatching parallel agents that are highly trained on custom philosophies to prevent analysis paralysis.

Part 3: The Diagnosis

What does GSD actually do for developers in the trenches?

1. Goal-Backward Planning

Instead of just asking an AI to "build a feature", the gsd-planner runs "Goal-Backward Methodology". It asks: "What must be TRUE for this goal to be achieved?" It then plans tasks down to the observable truth, requiring automatic verifiability. Plans are turned into rigid XML structures that tell the executor exactly what files to touch, exactly what to do, and the exact Bash command to prove it works.

<task type="auto" tdd="true">
  <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>
    <automated>curl -X POST localhost:3000/api/auth/login returns 200 + Set-Cookie</automated>
  </verify>
  <done>Valid credentials return cookie, invalid return 401</done>
</task>

2. Wave-Based Parallel Execution

When running /gsd:execute-phase, it groups the plans into dependency graphs (Waves). Independent features are written concurrently in fresh, 200k-token LLM contexts. If Task B depends on Task A, Task B waits for Wave 2. This execution structure mimics a true multi-threaded engineering team, all running locally on your machine.

3. Automatic Deviation Handling

The gsd-executor contains explicit deviation rules. If something breaks mid-task - say the code is missing a crucial dependency or an import is broken - GSD fixes it instantly without bugging you. If it decides it needs a major schema architecture change, only then will it STOP and throw a checkpoint:decision requesting your input.

4. Atomic Git Commits

For every micro-task completed, GSD fires an atomic git commit tracking the specific hash and updating a SUMMARY.md. If a feature breaks down the line, you know exactly which 15-minute chunk of AI execution introduced the bug, and it is cleanly revertible.

Part 4: The Resolution

GSD is ideal for solo developers looking to ship fast without enterprise roleplaying.

To use it, install the CLI for your desired tool (Claude Code, OpenCode, Gemini, etc.):

npx get-shit-done-cc@latest

The workflow is simple:

1. Initialize Project: /gsd:new-project - State your goals. GSD researches and generates a roadmap.
2. Discuss & Plan: /gsd:discuss-phase 1 followed by /gsd:plan-phase 1. You set your preferences before it writes XML sub-tasks.
3. Execute: /gsd:execute-phase 1 - Step back and watch the sub-agents write code, perform checks, and commit it atomically.
4. Verify: /gsd:verify-work 1 - The system creates a user-acceptance test loop allowing you to visually verify the feature block.
5. Repeat across phases!

If you just need a quick bug fix without the planning bureaucracy, jump into the codebase and use /gsd:quick!

When running GSD across multiple long sessions or with different LLM providers per phase, pairing it with OmniRoute prevents rate-limit interruptions during heavy Executor wave runs. For applying agent discipline frameworks on top of GSD’s execution structure, see Superpowers and the focus techniques in I Have ADHD: Coding Agent Skill.

Final Mental Model

Get Shit Done (GSD) is the perfect distillation of autonomous "vibecoding" cured of its greatest flaw: memory degradation. By segmenting the AI’s responsibilities into researchers, planners, and executors - and giving each their pristine slate - it acts less like a single chatbox and more like an entire engineering firm. Just bring the vision, and it will legitimately just get shit done.