get-shit-done-redux: Get Shit Done Redux: The AI Coding Framework That Treats Context Like a Finite Resource

A spec-driven workflow for orchestrating AI agents with phase gates, atomic commits, and fresh context windows.

9 min read • View on GitHub • More from open-gsd

A wide desk scene shows four workstations arranged in sequence, each one marked by a different phase of a workflow. Paper folders move through narrow gates while a separate filing cabinet stores project memory outside the workers' heads. The image explains how the system turns AI coding into a governed pipeline instead of a drifting chat session. — The core idea is simple: keep memory outside the conversation and move work through bounded phases.

Key Takeaways

GSD Redux is less a coding assistant than a control system for AI work, with memory moved into files and execution broken into bounded phases.
Its real trick is context discipline, using fresh sub-agents and atomic commits to keep one long session from collapsing into noise.
The repo's austerity is intentional, because a zero-dependency CommonJS core is easier to audit, port, and trust across runtimes.
The fork matters because governance became part of the product, so technical reliability and trust restoration now sit in the same design.

The real problem is context rot

Most AI coding tools fail quietly. The chat gets longer, the assumptions get fuzzier, and the model starts solving the memory of the task instead of the task itself. GSD Redux is built around that failure mode. It assumes context is scarce, fragile, and worth managing like a production resource.

That is why the project is interesting. It does not try to make the model smarter in the abstract. It tries to make the work environment sturdier, so the model can keep doing useful work after the conversation has already gotten messy.

A cracked hourglass is formed from stacked context windows. The top chamber is crowded with notes, half-finished code, and drifting fragments, while the bottom chamber is clean and labeled fresh context. A hand pulls one artifact out of the old chamber and places it into the new one, showing how the system preserves useful output while resetting the working context. — The framework treats context like a consumable. Preserve the artifact, reset the workspace.

Redux is a process, not a prompt

The workflow reads like a state machine: Discuss, Plan, Execute, Verify. The six-command surface built around that lifecycle turns vague intent into a sequence of gated outputs, with each stage producing artifacts that survive the session.

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

Supporting commands:
/gsd-map-codebase
/gsd-new-project

The system keeps the main conversation lean by pushing memory into files and execution into fresh sub-agents.

That structure matters because it forces the model to stop improvising once the work has a shape. Discuss captures nuance. Plan turns it into constraints. Execute pushes work into fresh context. Verify sends failures back to planning instead of letting the conversation drift into a new theory of the problem.

Why the stack is so boring on purpose

The core library is plain CommonJS JavaScript with Node built-ins and no external dependencies. That sounds conservative until you remember what this tool is coordinating: AI runtimes, shell commands, file state, and rollback. In that setting, boring is a feature.

Dimension	GSD Redux	Typical prompt-first workflow
Memory model	Artifacts live in files and phase outputs	Memory stays in the chat thread
Workflow enforcement	Strict command sequence and gates	Ad hoc prompting and manual discipline
Rollback	Atomic commits make failures reversible	Undo is usually informal or partial
Runtime portability	Minimal Node core and no dependency sprawl	Often tied to one client or plugin stack
Security posture	Path validation and array-based exec calls	More room for shell and prompt misuse
Complexity overhead	Higher upfront structure, lower drift	Low setup, higher long-session entropy

The tradeoff is obvious. You pay in ceremony up front. In return, you get a system that is easier to move between runtimes, easier to inspect, and less likely to collapse when the AI session gets long enough to become unreliable.

The hidden security model

The repo's trust story is not an afterthought. The security logic leans on defensive file handling, including path validation and execFileSync with array arguments instead of shell strings. That is exactly the kind of choice that looks mundane until an agent starts touching real files and real commands.

The governance layer is just as important. A rules file acts like a constitution for the AI, restricting edits and forcing the workflow path. In practice, that means the system is not only trying to produce correct code. It is trying to constrain blast radius when the code generator misbehaves.

I personally was not involved in the token at all — I am against that whole world. However, I believed in GSD and what it did for me, and I had been contributing full time for several months, mostly just playing the Wizard of Oz: keeping updates going and building features I wanted. The last time I spoke to the original creator was April 1st, 2026. After that, I got no responses.

A project contributor, Core Contributor/Maintainer · Picking up the Pieces · Discussion #1

What makes Redux different from other agentic tools

The market is crowded with tools that promise agentic coding. The difference here is narrower and more practical: GSD Redux cares less about novelty and more about repeatability, verification, and context discipline.

Tooling approach	Strength	Weakness	Where GSD Redux fits
Native plan mode	Fast to start	Often depends on a long-lived chat	GSD Redux is stricter and more durable
Prompt-only workflow	Minimal overhead	Memory and rollback are weak	GSD Redux externalizes both
General agent frameworks	Flexible and powerful	Can become loose and hard to audit	GSD Redux adds phase gates and artifacts
Workflow plugins	Easy to adopt	Usually narrow and client-specific	GSD Redux is broader and runtime-agnostic

For a developer who wants the AI to feel like a controlled junior team, that matters more than raw convenience. The point is not to chat better. The point is to ship with fewer surprises.

Why the fork matters

The fork story gives the project a second layer of meaning. The community did not just copy code. It re-established ownership, re-audited the surface, and made trust part of the product definition. That is unusual, but it fits the rest of the project perfectly.

A project contributor, Core Contributor/Maintainer · Picking up the Pieces · Discussion #1

That quote explains the tone of the repo better than any slogan could. The project is engineered as if trust can vanish, because in this case it did. The result is a framework that treats continuity, auditability, and security as first-class features rather than maintenance chores.

The point of the whole system

GSD Redux makes AI collaboration look more like engineering and less like improvisation. It assumes the model should not hold the whole project in its head. The system should hold the work.

That is the enduring idea. Externalize memory. Bound the phases. Reset the context. Verify the output. If the AI is unreliable as a long-term thinker, build around that reality instead of arguing with it.