Imagine you are deep in a complex coding project with an AI assistant like Claude Code. Everything starts great — responses are sharp, code is clean. But then, somewhere around the third or fourth hour, quality starts degrading. The AI starts repeating itself, loses context of your architecture, and produces increasingly generic boilerplate. This is called context rot, and it is the number one complaint from power users of AI coding tools. The open-source project get-shit-done-redux (GSD) is specifically designed to fix this.

get-shit-done-redux (also known as GSD) is a meta-prompting, context engineering, and spec-driven development system for AI coding agents including Claude Code, OpenCode, Gemini CLI, Kilo, Codex, Copilot, Cursor, and Windsurf. Created by the open-gsd organization and maintained as an MIT-licensed open-source project, GSD currently has 1.2k GitHub stars with 72 forks and 88 open issues. It was born as a direct continuation of the original "get-shit-done" project after a trust and ownership transition in May 2026, and it continues to be actively maintained with regular commits.

The most impressive thing about GSD is its simplicity. Instead of trying to be another AI wrapper or prompt library, it focuses on a strict six-command workflow that keeps your AI agent's context window permanently fresh. The entire system is built around the concept that "if you know clearly what you want, this WILL build it for you." Unlike many AI productivity tools that add layers of complexity, GSD stays minimal — no new mental model to learn, no heavyweight framework to integrate.

From a practical standpoint, GSD is trusted by engineers at Amazon, Google, Shopify, and Webflow according to its README. The project maintains active CI/CD with automated tests, and the community is actively discussing improvements like Documentation-Driven Development (DDD) mode as a sibling to the main project initialization command. The fact that it has 88 open issues might look alarming, but most are enhancement requests and maintenance tasks — not bugs. This is a healthy open-source project in active development.

For solo developers and small teams, GSD solves a real problem: the inevitable quality degradation when you work on a large codebase for extended periods. Instead of starting a new conversation and losing all context, GSD re-indexes your codebase and rebuilds its understanding in seconds, letting you pick up exactly where you left off.

The README describes GSD as a system that solves context rot — the quality degradation that happens as your AI fills its context window. The core workflow is six simple commands:

1. /gsd-new-project — Questions, research, requirements, roadmap. You approve, then build.
2. /gsd-discuss-phase N — Captures decisions before planning, feeding into research and planning phases.
3. /gsd-plan-phase N — Research, plan, verify loop until plans pass.
4. /gsd-execute-phase N — Plans run in parallel waves. Each executor gets a fresh 200k-token context. Each task gets its own atomic commit.
5. /gsd-verify-work N — Walk through what was built. Broken things get diagnosed fix plans ready for immediate re-execution.
6. /gsd-ship N — Loop discuss, plan, execute, verify, ship until milestone is done.

One clever design choice: your main context window stays at just 30–40% utilization during execution because the actual work happens in subagents. This means you can keep working on the same project for days without hitting the context ceiling.

If you have a clear vision for a web application, GSD can take you from idea to deployed product through its structured workflow. You start with /gsd-new-project, answer questions about your tech stack and requirements, and get a complete roadmap. Then the system builds phase by phase with verified outputs.

When returning to an existing project after weeks away, run /gsd-map-codebase to re-index your entire codebase. GSD analyzes your stack, architecture, and conventions so the next /gsd-new-project session asks the right questions about your specific setup — no more starting from scratch with every new session.

GSD is designed for parallel execution. Each phase's tasks run as subagents with their own fresh context, meaning multiple developers can work on the same project simultaneously without context conflicts. Perfect for teams using AI coding assistants in parallel.

Here is how to get started with GSD in three steps:

Step 1: Install via npx

npx @opengsd/get-shit-done-redux@latest

The installer will prompt for your runtime (Claude Code, OpenCode, Gemini CLI, etc.)
and whether to install globally or locally.

Step 2: Grant permission for your AI coding tool

For Claude Code specifically:
claude --dangerously-skip-permissions

This allows GSD to run its automation commands without manual approval.

Step 3: Start a new project

/gsd-new-project

Answer the questions about what you want to build:
- Project type (web app, CLI tool, library, etc.)
- Tech stack preferences
- Key requirements

The system will generate a research report, requirements doc, and roadmap.
Approve the roadmap and start building.

Step 4: Execute and verify

/gsd-plan-phase 1
/gsd-execute-phase 1
/gsd-verify-work 1

Repeat for each phase until /gsd-ship to release.

• Parallel Subagent Architecture: Execution happens in isolated subagent contexts, each with a fresh 200k-token context window. This prevents context pollution while keeping your main window at 30-40% utilization.
• Atomic Commit Strategy: Each task in the execution wave gets its own atomic commit. This means you can always identify exactly which change introduced a regression, and git history stays clean and navigable.
• Spec-Driven Development: Rather than letting the AI decide implementation details, GSD requires you to specify requirements upfront. The system then verifies that delivered code matches specifications before shipping.

⭐ 1.2k | 📈 +1.2k this week

vs. Claude Code Agent SDK: GSD works on top of Claude Code and similar tools rather than replacing them. It provides the project management layer that these tools lack out of the box. While the Agent SDK is about building individual agents, GSD is about orchestrating long-term project development with AI.

vs. SpecKit / OpenSpec: The README quotes users saying "I've done SpecKit, OpenSpec and Taskmaster — this has produced the best results for me." This suggests GSD takes the best ideas from these earlier spec-driven tools and integrates them into a more seamless AI-native workflow, with better context management.

View on GitHub

The project maintainers are rolling out branch protection rulesets for the main and release branches in three atomic PRs. This is a CI/CD maintenance task addressing the fact that the new repository started with zero branch protection — all workflow-side gates (closing-keyword, changeset, docs parity, template format) were bypassable by force-push or admin-merge. The three-PR plan involves checking in GitHub rulesets JSON files plus a sync script, then enabling enforcement. This shows the team takes code quality seriously — they are not just adding features but also hardening the development infrastructure for a project with growing community contributions.

View on GitHub

A community member proposed adding a Documentation-Driven Development (DDD) mode as a sibling to the existing /gsd-new-project command. The proposal keeps the same command shape, same downstream artifacts, and same agent topology, but adds a new mental model focused on starting with documentation rather than requirements. The enhancement has been reviewed positively — the maintainer flagged it as an enhancement rather than a feature because it extends existing behavior rather than creating a new concept. This kind of thoughtful, community-driven enhancement is exactly what keeps an open-source project alive and evolving.

View on GitHub

An enhancement request to cache workspace test-suite output across must-have queries. The requester identified that GSD's verification step (/gsd-verify-work) runs full test suites repeatedly during development, which becomes a bottleneck for large codebases. The proposed solution caches test results for unchanged files, only re-running tests when code actually changes. This is a practical performance optimization that many large-project users would appreciate — it shows the community is thinking about scalability alongside feature expansion.

• Do not skip /gsd-map-codebase: If you have an existing codebase and you jump straight to /gsd-new-project, GSD will ask generic questions instead of understanding your specific architecture. Always run /gsd-map-codebase first to let the system analyze your project structure before initialization.
• Grant skip-permissions for smooth automation: The --dangerously-skip-permissions flag is how GSD is intended to run. Without it, every GSD command will prompt for manual approval, destroying the automation experience. If you are uncomfortable with this, you can set up specific allowed commands instead of using skip-permissions globally.
• The six-command workflow is not optional: Some users try to cherry-pick individual commands. GSD is designed to be used as a complete loop — discuss, plan, execute, verify, ship. Skipping steps leads to degraded results. The workflow exists because each step feeds into the next.

get-shit-done-redux is a surprisingly practical tool in the crowded AI coding assistant space. Rather than adding more AI features on top of your existing workflow, it fundamentally changes how AI agents manage context over long coding sessions. The six-command loop is simple enough to learn in minutes but powerful enough to manage full-stack application development. Whether you are a solo developer working on personal projects or an engineer at a company like Amazon or Google, GSD offers a structured way to get more out of your AI coding tool without context degradation.

The project is actively maintained, has a healthy community discussing enhancements, and shows a clear commitment to code quality through its CI/CD infrastructure improvements. If you have been frustrated by context rot in long AI coding sessions, this is worth trying.

GitHub: https://github.com/open-gsd/get-shit-done-redux

Organization: https://github.com/open-gsd

NPM Package: @opengsd/get-shit-done-redux

🔗 More GitHub Trending Open Source Projects: Developer Tools