GSD + Claude Code, Antigravity: This Simple PLUGIN makes your Claude Code & Antigravity 2X BETTER!

Key Concepts

• GSD (Get Done): An open-source, opinionated context engineering workflow layer designed for AI coding agents.
• Context Rot: The degradation of AI performance over long sessions due to bloated context windows, leading to memory loss and erratic behavior.
• Spec-Driven Workflow: A methodology that forces structured planning, requirements gathering, and verification before code implementation.
• Atomic Tasks: Breaking down large projects into small, manageable units that fit within fresh context windows.
• Parallel Agentic Execution: Running independent tasks simultaneously to improve efficiency and reduce dependency conflicts.
• Verification Loops: Explicit steps to test deliverables against user-facing requirements rather than just checking for compilation success.

---

1. Overview and Core Problem

GSD is not an IDE or a new AI model; it is a workflow system that sits on top of existing tools like Claude Code, CodeX, Gemini CLI, Open Code, Co-pilot, Cursor, and Antigravity. Its primary objective is to solve "context rot," where AI agents lose focus and decision-making capability as a conversation history grows. By enforcing a structured, repeatable process, GSD ensures that agents remain grounded in the project's architecture and requirements.

2. Installation and Setup

• Command: npx get-shit-done-cc@latest
• Compatibility: Works on Mac, Windows, and Linux.
• Integration: Supports multiple runtimes. For CodeX, it utilizes a "skills-first" approach, installing skill folders into the .codex directory to align with the tool's native architecture.
• Verification: Commands vary by runtime (e.g., /GSD:help for Claude Code, $GSD-help for CodeX).

3. The GSD Workflow Methodology

GSD replaces "vibe coding" (unstructured prompting) with a rigorous, step-by-step framework:

1. map-codebase: Spawns parallel agents to analyze the existing architecture, stack, and conventions. This front-loads understanding before any code is written.
2. new-project: Initiates the planning phase, generating essential documentation files: project.md, requirements.md, roadmap.md, state.md, and a research folder.
3. discuss-phase: Forces the agent to surface "gray areas" (e.g., UI layout, API flags, error handling) to ensure the user and the AI are aligned on product decisions.
4. plan-phase: Researches the specific phase and breaks it into atomic tasks that fit within fresh context windows.
5. execute-phase: Executes tasks in "waves" based on dependencies. Vertical slices are prioritized to reduce conflicts and ensure meaningful outcomes.
6. verify-work: Moves beyond simple compilation checks. It extracts testable deliverables and walks the user through them to ensure the feature functions as intended in a real-world scenario.
7. next: A utility command that suggests the next logical step to maintain momentum.

4. Key Arguments and Perspectives

• Against "Enterprise Theater": The author argues that GSD is not about adding bureaucratic overhead (like Jira) but about providing enough structure for solo developers to build complex features without the chaos of unmanaged AI sessions.
• Context Management as the Bottleneck: The core argument is that the limitation of current AI coding is not the model's intelligence, but the lack of a structured "harness" or workflow around it.
• Atomic Commits: GSD encourages creating a Git commit for every task, ensuring cleaner history and easier rollbacks.

5. Practical Considerations and Downsides

• Not a Miracle Fix: If the user has vague requirements, the workflow will not produce high-quality results.
• Overkill for Small Tasks: For simple refactoring or minor bug fixes, the full GSD cycle is unnecessary and inefficient.
• Security Risks: The recommendation to use the --dangerously-skip-permissions flag with Claude Code is noted as a potential security risk that requires user caution.
• Cost: While the tool is free, running parallel agents and extensive planning phases can significantly increase token consumption and API costs.
• Learning Curve: The tool is terminal-heavy and requires a shift in mindset toward structured, spec-driven development.

6. Synthesis

GSD represents a significant shift in AI-assisted development, moving away from "chat-based" coding toward "system-based" engineering. By separating discovery, planning, execution, and verification, it provides a robust framework for building medium-to-large projects. While it requires a higher level of discipline and is not suitable for every minor task, it is a highly effective solution for developers looking to move past the limitations of current AI agentic workflows.