Get Shit Done (GSD) Hits 35K GitHub Stars — a Music Producer’s Fix for AI’s Context Rot Problem

AI coding agents are powerful — until they aren’t. Anyone who has used Claude Code, Codex, or Gemini CLI on a project longer than a few files knows the pattern: the agent starts sharp, produces clean code, follows instructions precisely. Then, about 60% into the context window, quality starts to slip. Variable names get reused. Instructions get ignored. The agent starts contradicting decisions it made five minutes ago.

Developers call this context rot, and it has become the defining bottleneck of agentic coding in 2026. One open-source project has turned solving this problem into a viral phenomenon — and it was built by a house music producer in Costa Rica.

The Context Rot Problem No One Wants to Talk About

Context rot is simple to describe but hard to fix. As an AI agent accumulates conversation history, partial decisions, debugging traces, and file contents in its context window, the signal-to-noise ratio degrades. The model can no longer reliably distinguish between current intent and stale context. The result: hallucinated variable names, forgotten constraints, and code that drifts further from the spec with every iteration.

The standard workaround — starting a fresh conversation — throws away all the project context the agent has built up. It’s the AI equivalent of rebooting your computer every time it slows down.

Get Shit Done, or GSD, takes a different approach. Instead of asking developers to manage context manually, it introduces an orchestration layer that treats context as a finite, precious resource — and manages it automatically.

How GSD Keeps Your AI Agent From Losing the Plot

GSD is a meta-prompting and spec-driven development system that works as a layer on top of AI coding agents. It currently supports six runtimes: Claude Code, OpenCode, Gemini CLI, Codex, GitHub Copilot, and Antigravity. Installation is a single npx command — for Claude Code, that’s npx get-shit-done-cc --claude --global.

The core architecture is built around three ideas:

Spec-driven planning. Before any code gets written, GSD creates structured specifications and breaks the project into a dependency graph of small, well-defined tasks. Each task has explicit needs (prerequisites), creates (outputs), and has_checkpoint (whether human review is required). All project state lives in structured Markdown files with YAML frontmatter — human-readable and machine-processable.

Wave-based parallel execution. Tasks are grouped into waves based on their dependency graph. Plans with no dependencies (or whose dependencies were satisfied in earlier waves) form the current wave and can execute simultaneously. Waves run sequentially to ensure downstream tasks always have their prerequisites met. This is not a simple task queue — it’s a parallel execution engine with dependency resolution.

Isolated subagent contexts. Here’s the key insight: the main orchestrator never does heavy lifting. It spawns specialized subagent executors, each getting a fresh ~200K-token context window built from project artifacts rather than accumulated chat history. The orchestrator itself stays lean at roughly 10-15% context usage. When a subagent finishes a task, its context is discarded. The main session stays at 30-40% context utilization throughout an entire project, no matter how large.

Every completed task produces an atomic git commit, so if something goes wrong, you can bisect your way back to the exact point of failure. Dedicated debugger agents handle errors in isolation rather than polluting the main context with stack traces and retry logic.

GSD vs BMAD vs Taskmaster: Picking the Right Framework

GSD didn’t emerge in a vacuum. Spec-driven development frameworks have become a crowded category in 2026, with over 30 tools competing for developer attention. The three most discussed are GSD, BMAD, and Taskmaster. Each takes a different philosophical stance on the same problem.

GSD is the minimalist. It rejects sprint ceremonies, story points, stakeholder syncs, and anything that smells like enterprise process. The philosophy is explicit: just enough structure to prevent context rot, nothing more. It’s built for solo developers and small teams who want to ship fast without spending weeks configuring a framework. The learning curve is measured in minutes.

BMAD is the enterprise option. It provides specialized AI personas for different development roles — architect, product manager, tester — and orchestrates collaboration between them. For complex projects with existing agile processes, BMAD offers the most complete structure. The tradeoff: a significant learning curve and overhead that doesn’t pay off for simpler projects.

Taskmaster focuses on task decomposition. It turns a PRD into a structured, dependency-aware task graph and acts more as a project manager than an executor. It’s purpose-built for Cursor users and shines at breaking projects into pieces small enough that context rot doesn’t have time to set in.

The community consensus, echoed across Medium articles and Threads posts, is pragmatic: start with GSD for speed, graduate to BMAD or Taskmaster if you need more structure. As one developer put it on Threads: “I’ve tried most of the spec-driven dev tools for Claude Code. BMAD, SpecKit, Taskmaster. They all work, but they make you feel like you’re setting up Jira for a team that doesn’t exist. GSD is different.”

35K Stars and a Community That Won’t Stop Building

The numbers tell a clear story. GSD has accumulated over 35,000 GitHub stars, ranking it #938 globally on GitHub and placing it consistently on trendshift.io’s global trending list. The repository gains roughly 4,500 stars per week, with 68 pushes and 77 issues closed in a typical week. It’s maintained under the MIT license, making it fully free and open source.

The project was created by Lex Christopherson (GitHub handle: glittercowboy), a house music producer turned developer based in Costa Rica, operating under the TACHES organization. In a March 2026 Hacker News thread, the community reaction was cautiously optimistic. One commenter captured the general sentiment: “It’s working, and I’m enjoying how productive it is, but it feels like a step on a journey rather than the actual destination.”

That honesty is part of what makes the GSD community interesting. There’s no cult-of-personality marketing here. Engineers at Amazon, Google, Shopify, and Webflow are using it in production, and the ecosystem is growing organically — community members have built forks for OpenCode, multi-CLI support, and cost-saving optimizations.

GSD has also spawned a second generation: GSD-2, a standalone CLI built on the Pi SDK. Where GSD v1 relies on prompting the LLM to manage context, GSD-2 has direct TypeScript access to the agent harness. It can programmatically clear context between tasks, inject specific files at dispatch time, manage git branches, track cost and tokens, detect stuck loops, recover from crashes, and auto-advance through milestones without human intervention.

What GSD Tells Us About the Future of AI-Assisted Development

The explosive growth of GSD and its competitors signals something bigger than any single tool. The spec-driven development pattern — specify, plan, execute, verify — is converging across the entire ecosystem. The basic loop is settled; what’s still up for debate is how much process to wrap around it.

GSD’s bet is that less is more. By keeping the orchestration minimal and letting the subagent isolation do the real work, it stays out of the developer’s way. The framework doesn’t try to replace your workflow — it patches the one critical weakness (context management) that makes long-running agent sessions unreliable.

Whether GSD itself becomes the long-term standard or gets absorbed into the AI coding tools themselves remains an open question. Claude Code and Gemini CLI are both rapidly improving their built-in context management. But for now, GSD is the most popular open-source answer to a problem that every developer using AI coding agents hits eventually.

FAQ

Is Get Shit Done (GSD) free to use?
Yes. GSD is fully open source under the MIT license. There is no paid tier or premium version. Lex Christopherson confirmed on X that “GSD can now be used for completely free,” including through OpenCode with free models like Gemini and local LLMs.

What AI coding tools does GSD support?
GSD supports six runtimes: Claude Code, OpenCode, Gemini CLI, Codex, GitHub Copilot, and Antigravity. Each has its own installation command via npx. Claude Code is the primary and most tested runtime.

How does GSD compare to using Claude Code without any framework?
Without GSD, your Claude Code session accumulates all conversation history, file reads, and debugging output in a single context window that progressively degrades. With GSD, the main session stays at 30-40% context usage while subagents handle heavy tasks in isolated, disposable contexts. The practical effect is consistent code quality across large projects rather than a quality cliff at the 60-70% context mark.

Can I use GSD on an existing project or only new ones?
GSD can be added to existing projects. The initialization process creates its own spec and planning files alongside your existing codebase. It does not require restructuring your project.

What is the difference between GSD v1 and GSD-2?
GSD v1 works through prompt engineering — it instructs the LLM to manage context, spawn subagents, and track state. GSD-2 is a standalone CLI with direct programmatic control over the agent harness via TypeScript. This means GSD-2 can enforce context clearing, manage git branches, track costs, and recover from crashes at the system level rather than relying on the LLM to follow instructions.

Top AI Product

Leave a comment Cancel reply