How Get Shit Done Solves Context Rot with Multi-Agent Orchestration

Hook

Your AI coding session starts brilliant at 10 AM. By 3 PM, Claude is suggesting solutions you already rejected twice. This is context rot, and Get Shit Done treats it like a distributed systems problem.

Context

AI coding assistants hit a wall that has nothing to do with intelligence: they forget. Not completely—Claude Code and its peers maintain conversation history—but as your context window fills with code, debugging attempts, and abandoned approaches, the signal-to-noise ratio plummets. By token 150k in a 200k window, your AI pair programmer starts contradicting itself, reintroducing bugs you fixed hours ago, and losing track of architectural decisions.

Traditional solutions involve starting fresh sessions (losing all context) or manually curating what stays in the conversation (tedious and error-prone). Get Shit Done, built by the TÂCHES team, takes a different approach: treat context management like you'd treat memory management in a distributed system. Keep a small, structured state in the main process. Spin up fresh worker contexts for compute-heavy operations. Persist decisions to durable storage. The result is a meta-prompting orchestration system that maintains coherence across sessions while keeping your primary AI context clean.

Technical Insight

The architecture revolves around five persistent markdown artifacts that act as your system's ground truth: PROJECT.md defines scope, REQUIREMENTS.md captures what you're building, ROADMAP.md breaks work into waves, STATE.md tracks completion, and CONTEXT.md maintains critical decisions. These files live in your repository and survive session restarts, functioning as a shared memory layer.

Here's what a typical workflow looks like in practice:

// Get Shit Done orchestration loop
// 1. Initialize - GSD reads existing artifacts or creates new ones
// Main context usage: ~15%

// 2. Discussion phase - You describe what you want
// Artifacts updated with requirements
// Main context usage: ~25%

// 3. Planning with verification
// GSD spawns researcher subagents in FRESH 200k contexts
// Each researcher investigates specific technical questions
// Results merged back into ROADMAP.md
// Main context usage: still ~25% (research happened elsewhere)

// 4. Execution in parallel waves
const wave1Tasks = [
  { id: 'auth-system', agent: 'executor-1', context: 'fresh-200k' },
  { id: 'database-schema', agent: 'executor-2', context: 'fresh-200k' },
  { id: 'api-routes', agent: 'executor-3', context: 'fresh-200k' }
];

// Each executor gets:
// - Complete PROJECT.md + REQUIREMENTS.md
// - Only their specific task from ROADMAP.md
// - Zero history of failed attempts from other tasks
// - Full 200k token budget for implementation

// 5. Atomic commits per task
wave1Tasks.forEach(task => {
  git.commit(`feat: ${task.id}`, { atomic: true });
});

// 6. Verification with debug agents
// If tests fail, GSD spawns debug agent with:
// - The failing test output
// - The task specification
// - Fresh context to analyze without bias

The crucial insight is workload isolation. When your authentication system task hits a complex bcrypt edge case, that debugging context pollution stays contained in executor-1's context. Executor-2 building your database schema never sees those false starts. The main orchestration context only receives the successful result and updates STATE.md.

Get Shit Done supports 15+ runtimes through adapter patterns. Each runtime (Claude Code, Cursor, Windsurf, etc.) has specific quirks in how they handle file operations and permissions. The installer detects your environment and configures accordingly:

# Runtime-specific installation
# For Claude Code (default)
get-shit-done init --runtime=claude-code --dangerously-skip-permissions

# For Cursor with different permission model
get-shit-done init --runtime=cursor

# Creates .gsd/ directory with:
# - artifacts/ (your persistent markdown files)
# - config.json (runtime-specific settings)
# - templates/ (prompt templates optimized per runtime)

The permission-skipping flag exists because true automation requires file system access without confirmation dialogs. In development mode with Claude Code, this means GSD can write ROADMAP.md, spawn three executor subagents that each write code files, run verification scripts, and commit results—all without you clicking 'Allow' seventeen times.

Verification deserves special attention. Rather than dumping test failures back into your main context (polluting it with error traces), GSD spawns a dedicated debug agent. This agent receives the failure, generates a fix plan, and only then does an executor apply the fix. If the fix fails, the debug agent iterates in its own context. Your main session just sees 'Task auth-system: failed → debugging → fixed → committed' in STATE.md.

The parallel wave execution model creates surprisingly clean git history. Traditional AI coding sessions produce commits like 'fix', 'actually fix', 'revert bad fix', 'fix for real this time'. With atomic task commits from isolated executors, your history shows 'feat: authentication system', 'feat: database schema', 'feat: API routes'—each one a complete, tested unit of work.

Gotcha

The --dangerously-skip-permissions flag isn't hyperbole. You're giving an AI agent unrestricted file system access. In a solo project on your local machine, this is liberating. In a shared repository or production environment, it's a incident waiting to happen. There's no granular permission model—it's all or nothing. If your AI hallucinates a destructive file operation, GSD will execute it without confirmation.

The system assumes you know what you want upfront. The entire architecture optimizes for 'clear requirements → structured plan → parallel execution'. If you're exploring a problem space, prototyping different approaches, or figuring out requirements through iteration, Get Shit Done's rigid workflow becomes friction instead of assistance. The discussion phase can capture ambiguity, but the planning phase demands concrete tasks. Vague requirements produce vague roadmaps, and garbage-in-garbage-out applies with full force. Additionally, the 60k+ GitHub stars combined with mentions of a cryptocurrency token ($TÂCHES) raise questions about whether community growth is driven by technical merit or speculative hype. The codebase itself is relatively young for such high visibility, suggesting caution around long-term stability and maintenance commitments.

Verdict

Use Get Shit Done if you're a solo developer or small team building greenfield projects where you can clearly articulate requirements upfront, you're suffering from context degradation in long AI coding sessions, and you're comfortable with aggressive automation in local development environments. The multi-agent orchestration genuinely solves the context rot problem, and the structured artifact system provides session persistence that vanilla AI coding assistants lack. Skip it if you work in regulated environments where unrestricted AI file access is unacceptable, you need enterprise process integration with existing project management tools (this deliberately avoids that), you're exploring problem spaces rather than executing known solutions, or the cryptocurrency token association and hype-to-maturity ratio makes you skeptical about long-term viability. For production or shared codebases, the permission model alone should give you pause—this is a powerful tool that demands trusted environments.