What is Get Shit Done (GSD) and How Does It Solve AI Coding Assistant Context Rot?

Apr 21, 2026

I kept noticing a pattern with AI coding assistants. The first few exchanges would be great—clean code, good suggestions, helpful refactoring. But as the conversation grew longer, the quality would drop. The AI would forget earlier decisions, make inconsistent choices, and start producing code that didn’t fit the project.

At first I thought it was just me being picky. Then I saw other developers complaining about the same thing on Twitter and Discord. We called it “vibecoding”—describe what you want, get generated code, and hope it works. But vibecoding got a bad reputation because the results were inconsistent. The longer you worked with an AI assistant, the worse it got.

The root cause turned out to be what the GSD project calls “context rot.”

The Problem: Context Rot

Every AI coding assistant has a context window—the amount of text it can “see” at once. As you work, this context window fills up with:

Your original request
The AI’s responses
Code snippets shared back and forth
Error messages and fixes
Follow-up questions and clarifications

When the context window gets full, the AI starts losing track of earlier information. It forgets conventions you established, ignores earlier architectural decisions, and produces code that conflicts with what came before.

I tried various workarounds. I’d start fresh conversations frequently. I’d paste in summaries of earlier decisions. I’d use shorter prompts. But none of these approaches scaled. For small fixes, they worked fine. For complex multi-phase projects, they fell apart.

What I needed was a system that could orchestrate multiple AI agents, each with a fresh context window, while maintaining consistent state across the entire project.

Enter GSD: Get Shit Done

GSD (Get Shit Done) is a meta-prompting, context engineering, and spec-driven development system. It sits between you and your AI coding assistant, managing the context problem through a specific architecture.

The key insight: instead of one long conversation with a single AI agent, GSD spawns multiple specialized agents. Each agent gets up to 200,000 tokens of fresh context. When one agent finishes its task, it writes its output to structured files. The next agent picks up from those files with a clean slate.

This approach solves context rot by design. No accumulated garbage. No forgotten decisions. Each agent sees only what it needs to see.

How GSD Works: The Core Architecture

GSD uses a file-based state system. All project state lives in a .planning/ directory as Markdown and JSON files:

.planning/
├── PROJECT.md        # High-level project overview
├── REQUIREMENTS.md   # Detailed requirements spec
├── ROADMAP.md        # Phase breakdown
├── research/         # Research artifacts
├── plans/            # Implementation plans
└── progress/         # Execution tracking

Thin orchestrator files called “workflows” coordinate between agents. They don’t do heavy lifting themselves. They read from the state files, spawn the right agents, and write results back to the state files.

The workflow follows a spec-driven pipeline:

Requirements → Capture what you’re building
Research → Gather context and information
Plans → Design the implementation approach
Execution → Build with atomic commits
Verification → Confirm it works as intended

Each phase gets input captured, research done, plans verified, execution with atomic commits, and human verification before moving on.

The Command Flow: One Command Per Phase

GSD exposes a simple command interface. You type one slash command, and GSD handles the orchestration:

/gsd-new-project     # Initialize project structure
/gsd-discuss-phase   # Capture requirements through discussion
/gsd-plan-phase      # Research and create implementation plan
/gsd-execute-phase   # Build the feature with atomic commits
/gsd-verify-work     # Test and verify the implementation
/gsd-ship            # Deploy or finalize

I tested this flow on a side project. Instead of trying to hold all the context in my head (or the AI’s context window), each phase had its own dedicated agent. The requirements agent focused purely on understanding what I wanted. The research agent gathered relevant documentation and examples. The planning agent designed the approach. The execution agent wrote the code. The verification agent checked everything worked.

When the verification agent found issues, GSD spawned a new agent to fix them—with fresh context, but access to all the state files from previous phases.

Built-in Quality Gates

One thing I appreciate about GSD: it doesn’t pretend you’re running a 50-person engineering org. It focuses on problems that actually affect solo developers:

Schema drift — When your database schema diverges from what your code expects
Security issues — Basic vulnerabilities that sneak into generated code
Scope reduction — When the AI quietly drops features because they’re “too complex”

GSD includes verification steps that catch these problems. Not enterprise-theater compliance checks, but practical quality gates that prevent real headaches.

What GSD Is For (And What It Isn’t)

GSD is built for solo developers who want to describe their vision and have it built correctly. It works well when you:

Have a clear idea of what you want to build
Need to break complex projects into manageable phases
Want AI assistance without the context degradation problem
Prefer structured workflows over open-ended chat

It’s not a magic solution for vague requirements. You still need to know what you’re building. GSD helps you express that clearly and execute it reliably with AI assistance.

Compatibility and Adoption

GSD works with most AI coding assistants:

Claude Code
OpenCode
Gemini CLI
Cursor
Windsurf
GitHub Copilot
And others like Codex, Kilo, Antigravity, Augment, Trae, Qwen Code, Cline, and CodeBuddy

Installation is straightforward:

npx get-shit-done-cc@latest

The project has gained traction among developers. Engineers from Amazon, Google, Shopify, and Webflow use it, according to the README. That’s not surprising—context rot affects anyone doing extended AI-assisted development, regardless of company size.

The Meta-Prompting Angle

GSD describes itself as a “meta-prompting” system. What does that mean in practice?

Instead of writing one big prompt that tries to cover everything, you write a series of focused prompts. Each prompt targets a specific task. GSD manages the handoff between these prompts, ensuring that:

Each prompt gets fresh context (no accumulated noise)
Outputs from previous prompts feed into subsequent prompts
The overall workflow stays coherent across phases

This is “meta-prompting” in the sense that you’re not just prompting the AI—you’re designing a system of prompts that work together.

Context Engineering as a Discipline

GSD represents an emerging discipline: context engineering. Just as prompt engineering focuses on crafting individual prompts, context engineering focuses on managing the broader context in which AI operates.

Key principles GSD demonstrates:

Fresh context per agent — Avoid the degradation problem
Structured state — Store everything in files, not conversation history
Thin orchestrators — Coordination logic, not heavy processing
Phase separation — Different agents for different concerns

These principles apply beyond GSD. Any system that orchestrates multiple AI agents can benefit from this approach.

Summary

In this post, I explained what Get Shit Done (GSD) is and how it solves the context rot problem in AI coding assistants. Context rot—the quality degradation that happens as AI context windows fill up—affects anyone doing extended AI-assisted development. GSD solves this through multi-agent orchestration, where each agent gets a fresh 200k-token context window and writes state to structured files.

GSD works well for solo developers who want structured, reliable AI assistance without the overhead of enterprise tooling. It includes quality gates for real problems like schema drift, security issues, and scope reduction. The command flow is simple: one slash command per phase, with GSD handling the agent orchestration behind the scenes.

If you’ve experienced context rot in your AI coding workflow, GSD offers a practical solution. Install it with npx get-shit-done-cc@latest and try it on your next project.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!