Skip to content
/
Tier B A10 Memory engine

GSD for Antigravity

gsd-for-antigravity · toonight/get-shit-done-for-antigravity · ★ 862 · last commit 2026-04-01

Make AI coding reliable through context engineering: structured SPEC→PLAN→EXECUTE→VERIFY loop with wave-based atomicity and model-agnostic portability.

Best whenModel-agnostic adapter files make the framework portable to any capable LLM without rewriting workflows — model selection is an explicit engineering decision…
Skip ifEnterprise theater (sprint ceremonies, story points, Jira), Loading files without searching first
vs seeds
agent-os(markdown workflow scaffold) but 6x larger with 27 commands vs 5, 11 agent skills, cross-platform PowerShell+bash script…
Primitive shape 38 total
Commands 27 Skills 11
00

Summary

GSD for Antigravity — Summary

GSD for Antigravity is a multi-model, multi-runtime context-engineering framework that extends the original glittercowboy/get-shit-done pattern with 29 slash-command workflows, 11 agent skills, model-agnostic adapters (Claude, Gemini, GPT), cross-platform scripts (PowerShell + bash), and a token budget management system. It ships as a clone-and-copy template (no package manager) — users copy .agent/workflows/, .agents/skills/, .gsd/, and adapters/ into their project. The .gsd/ directory persists SPEC.md, ROADMAP.md, STATE.md, ARCHITECTURE.md, DECISIONS.md, and JOURNAL.md across sessions. The 29 commands cover full project lifecycle from /new-project (deep questioning → SPEC.md) through wave-based /execute (parallel shard execution) to /sprint and session /pause//resume. The framework explicitly refuses enterprise theater ("No sprint ceremonies, story points, stakeholder syncs") in favor of atomic, evidence-based development.

Differs from seeds: Closest to agent-os (markdown scaffold + structured workflow files) but far more extensive: 29 workflows vs agent-os's 5 commands, explicit multi-model adapter system, wave-based parallel execution in a single agent, cross-platform PowerShell+bash parity, and a model_capabilities.yaml capability registry. Unlike spec-driver or superpowers (Claude Code-only skill packs), GSD for Antigravity explicitly targets Gemini, GPT, and any capable LLM via model-agnostic workflow files and IDE-specific adapter files.

01

Overview

GSD for Antigravity — Overview

Origin

GitHub: toonight/get-shit-done-for-antigravity (862 stars, 137 forks, MIT). Built by toonight, based on glittercowboy/get-shit-done (explicitly credited as "Based on GSD" in badges). PowerShell is the primary language for scripts (cross-platform parity with bash). Version 1.5.0.

Philosophy

From README:

"Stop vibecoding. Start shipping." "Vibecoding has a bad reputation — and it deserves it. You describe what you want, AI generates code, and you get inconsistent garbage that falls apart at scale. GSD fixes that. It's the context engineering layer that makes AI coding reliable."

Key principles (from philosophy section):

"Plan before building — SPEC.md matters more than you think" "Fresh context > polluted context — State dumps prevent hallucinations" "Proof over trust — Screenshots and command outputs, not 'looks right'" "Aggressive atomicity — 2–3 tasks per plan, atomic commits" "Search before reading — Don't load files blindly" "Token-efficient — Every token counts" "Model-agnostic — Works with any capable LLM" "No enterprise theater — Solo dev + AI workflow only"

Explicit Anti-Enterprise Stance

"No enterprise roleplay. No sprint ceremonies, story points, stakeholder syncs, or Jira workflows. Just an incredibly effective system for building cool stuff consistently."

The framework targets:

  • Solo developers needing consistency
  • Small teams wanting structure without overhead
  • Anyone tired of AI-generated inconsistency

Relationship to Original GSD

GSD for Antigravity extends glittercowboy/get-shit-done by adding:

  • Multi-model adapter system (Claude, Gemini, GPT)
  • Cross-platform PowerShell scripts
  • 11 agent skills (context compressor, token budget, verifier, etc.)
  • Wave-based parallel execution in /execute
  • Sprint management commands
  • Milestone management
  • Model capabilities registry
02

Architecture

GSD for Antigravity — Architecture

Distribution

  • Type: Clone-and-copy template (standalone repo)
  • Install: Clone repo, copy directories into project
  • Package manager: None
  • Language: PowerShell (scripts), Markdown (workflows/skills)
  • License: MIT

Install

# Bash (Linux/Mac)
git clone https://github.com/toonight/get-shit-done-for-antigravity.git gsd-template
cp -r gsd-template/.agent ./
cp -r gsd-template/.agents ./
cp -r gsd-template/.gemini ./
cp -r gsd-template/.gsd ./
cp -r gsd-template/adapters ./
cp -r gsd-template/docs ./
cp -r gsd-template/scripts ./
cp gsd-template/PROJECT_RULES.md ./
rm -rf gsd-template

# PowerShell (Windows)
git clone ... gsd-template
Copy-Item -Recurse gsd-template\.agent .\
# etc.

Then run /new-project to initialize.

Directory Tree

PROJECT_RULES.md          # Canonical model-agnostic rules
GSD-STYLE.md              # Complete style guide
model_capabilities.yaml   # Optional LLM capability registry

.agent/
  workflows/              # 27 slash commands (markdown)
    new-project.md
    plan.md
    execute.md
    verify.md
    debug.md
    progress.md
    pause.md
    resume.md
    sprint.md (new/status/close)
    add-phase.md
    insert-phase.md
    remove-phase.md
    discuss-phase.md
    research-phase.md
    list-phase-assumptions.md
    plan-milestone-gaps.md
    new-milestone.md
    complete-milestone.md
    audit-milestone.md
    update.md
    whats-new.md
    help.md
    install.md
    add-todo.md
    check-todos.md
    web-search.md

.agents/
  skills/                 # 11 agent specializations
    codebase-mapper/
    context-compressor/
    context-fetch/
    context-health-monitor/
    debugger/
    empirical-validation/
    executor/
    plan-checker/
    planner/
    token-budget/
    verifier/

.gemini/
  GEMINI.md               # Gemini integration file

.gsd/                     # Project state (persistent)
  SPEC.md
  ROADMAP.md
  STATE.md
  ARCHITECTURE.md
  STACK.md
  DECISIONS.md
  JOURNAL.md              # Session audit log
  TODO.md
  templates/
  examples/

adapters/                 # Model-specific enhancements
  CLAUDE.md
  GEMINI.md
  GPT_OSS.md

docs/
  model-selection-playbook.md
  runbook.md
  token-optimization-guide.md

scripts/
  validate-all.ps1/.sh
  validate-workflows.ps1/.sh
  validate-skills.ps1/.sh
  validate-templates.ps1/.sh
  setup_search.ps1/.sh
  search_repo.ps1/.sh

Target AI Tools

Claude (primary via CLAUDE.md adapter), Gemini (via .gemini/ + GEMINI.md adapter), GPT (via GPT_OSS.md adapter). The .agent/workflows/ are model-agnostic; adapters add model-specific behavior on top.

03

Components

GSD for Antigravity — Components

Workflows / Slash Commands (27 in .agent/workflows/)

Core Workflow

Command Purpose
/map Analyze codebase → ARCHITECTURE.md
/plan [N] Create PLAN.md for phase N
/execute [N] Wave-based execution with atomic commits
/verify [N] Must-haves validation with proof
/debug [desc] Systematic debugging (3-strike rule)

Project Setup

Command Purpose
/install Install GSD from GitHub
/new-project Deep questioning → SPEC.md + ROADMAP.md
/new-milestone Create milestone with phases
/complete-milestone Archive completed milestone
/audit-milestone Review milestone quality

Phase Management

Command Purpose
/add-phase Add phase to end of roadmap
/insert-phase Insert phase (renumbers)
/remove-phase Remove phase (safety checks)
/discuss-phase Clarify scope before planning
/research-phase Deep technical research
/list-phase-assumptions Surface planning assumptions
/plan-milestone-gaps Create gap closure plans

Sprint

Command Purpose
/sprint new Create time-boxed sprint
/sprint status Show sprint progress
/sprint close Close sprint with retrospective

Navigation & State

Command Purpose
/progress Show current position
/pause Save state for session handoff
/resume Restore state from saved handoff
/update Update GSD to latest version
/whats-new Show changelog
/help Show command reference
/web-search Research tool
/add-todo Quick capture
/check-todos Review TODO list

Agent Skills (11 in .agents/skills/)

Skill Purpose
codebase-mapper Analyze codebase → ARCHITECTURE.md
context-compressor Compress context for token efficiency
context-fetch Search-first file loading
context-health-monitor Detect context quality degradation
debugger Systematic 3-strike debugging
empirical-validation Evidence-based verification
executor Plan shard execution
plan-checker Validate plan quality
planner Phase planning
token-budget Track and manage token usage
verifier Post-execution verification

Validation Scripts (6)

Script Purpose
validate-all.ps1/.sh Run all validators
validate-workflows.ps1/.sh Validate workflow files
validate-skills.ps1/.sh Validate skill files
validate-templates.ps1/.sh Validate template files
setup_search.ps1/.sh Configure search tools
search_repo.ps1/.sh Search repository wrapper

Model Adapters (3 files)

  • adapters/CLAUDE.md — Claude-specific behavior rules
  • adapters/GEMINI.md — Gemini-specific behavior rules
  • adapters/GPT_OSS.md — GPT/open-source model rules

Persistent State Files (.gsd/)

File Purpose
SPEC.md Project specification (start here)
ROADMAP.md Phases and progress
STATE.md Session memory
ARCHITECTURE.md System design (/map output)
STACK.md Tech inventory
DECISIONS.md Architecture Decision Records
JOURNAL.md Session log (audit trail)
TODO.md Quick capture
05

Prompts

GSD for Antigravity — Prompts

Excerpt 1: /execute workflow (.agent/workflows/execute.md)

Technique: Role declaration + objective framing + context injection + PowerShell/bash dual-mode commands.

---
description: The Engineer — Execute a specific phase with focused context
argument-hint: "<phase-number> [--gaps-only]"
---

# /execute Workflow

<role>
You are a GSD executor orchestrator. You manage wave-based parallel execution of phase plans.

**Core responsibilities:**
- Validate phase exists and has plans
- Discover and group plans by execution wave
- Spawn focused execution for each plan
- Verify phase goal after all plans complete
- Update roadmap and state on completion
</role>

<objective>
Execute all plans in a phase using wave-based parallel execution.

Orchestrator stays lean: discover plans, analyze dependencies, group into waves, execute sequentially within waves, verify against phase goal.

**Context budget:** ~15% orchestrator, fresh context per plan execution.
</objective>

Excerpt 2: /new-project workflow (.agent/workflows/new-project.md)

Technique: Procedural workflow with explicit abort conditions, cross-platform scripts, brownfield detection.

<objective>
Initialize a new project through unified flow: questioning → research (optional) → requirements → roadmap.

This is the most leveraged moment in any project. Deep questioning here means better plans, better execution, better outcomes. One command takes you from idea to ready-for-planning.
</objective>

<process>

## Phase 1: Setup
**MANDATORY FIRST STEP — Execute these checks before ANY user interaction:**

1. **Abort if project exists:**
   **Bash:** `if [ -f ".gsd/SPEC.md" ]; then echo "Error: Project already initialized. Use /progress" >&2; exit 1; fi`

2. **Initialize git repo** (if not exists):
   **Bash:** `if [ ! -d ".git" ]; then git init; fi`

3. **Detect existing code (brownfield detection):**
   **Bash:** `code_files=$(find . -type f \( -name "*.ts" -o -name "*.js" -o -name "*.py" \) -not -path '*/node_modules/*' | head -20)`

Excerpt 3: context-health-monitor skill (.agents/skills/context-health-monitor/)

Technique: Autonomous monitoring skill — activates without user invocation when context health degrades.

From README skills section:

📊 token-budget   — Track and manage token usage
🗜️ context-compressor — Compress context for efficiency
🔍 context-fetch  — Search-first loading
🩺 context-health-monitor — Detect quality degradation

Budget Thresholds:
| Usage | Status | Action |
|:-----:|:------:|--------|
| 0–50% | 🟢 OK | Proceed normally |
| 50–70% | 🟡 Warning | Compress, use outlines |
| 70%+ | 🔴 Critical | State dump required |

Excerpt 4: PROJECT_RULES.md Philosophy Block

Technique: Explicit anti-pattern declaration + principles. Model-agnostic — no tool-specific syntax.

🎯 Plan before building — SPEC.md matters more than you think
🧹 Fresh context > polluted context — State dumps prevent hallucinations
🔬 Proof over trust — Screenshots and command outputs, not "looks right"
⚛️ Aggressive atomicity — 2–3 tasks per plan, atomic commits
🔍 Search before reading — Don't load files blindly
💰 Token-efficient — Every token counts
🤖 Model-agnostic — Works with any capable LLM
🚫 No enterprise theater — Solo dev + AI workflow only
09

Uniqueness

GSD for Antigravity — Uniqueness

Differs from Seeds

Most similar to agent-os (markdown scaffold, file-based workflow) but larger in every dimension. GSD for Antigravity extends the original GSD pattern with: (1) explicit multi-model adapter system (Claude, Gemini, GPT, any LLM) — no seed provides model-agnostic adapters as first-class components; (2) 29 workflows vs agent-os's 5 commands; (3) cross-platform PowerShell+bash parity for all scripts; (4) 11 named agent skills vs agent-os's 0; (5) wave-based parallel execution within a single model session via /execute; (6) JOURNAL.md as persistent audit log for all sessions; (7) token budget management as an explicit skill (token-budget, context-compressor, context-health-monitor). Unlike spec-kit or openspec (which have mirrored command+skill pairs), GSD keeps workflows and skills orthogonal — workflows are the user-facing commands, skills are autonomous specializations. Unlike BMAD (persona-based), GSD is task-workflow-based without role personas.

Positioning

  • Target user: Solo developers and small teams wanting model-agnostic reliability without enterprise ceremony
  • Key differentiator: High cross-tool portability with explicit multi-model adapter files — only framework in the batch designed from the ground up to work identically across Claude, Gemini, and GPT
  • Unique capability: /pause//resume session handoff enables switching models mid-project

Observable Failure Modes

  1. Clone-and-copy install: No package manager; updating requires re-cloning or manual patch — /update command handles this but requires network access
  2. No automated test validation: /verify requires human proof (screenshots, output) rather than running tests automatically
  3. Context budget monitoring is advisory: context-health-monitor detects degradation but can't stop the agent from continuing
  4. Large workflow surface: 29 commands creates discovery friction; /help required to find the right command
  5. No MCP integration: Entirely file-based; no programmatic state management

Notable Innovation

The model_capabilities.yaml + model-selection-playbook.md combination creates a portable model selection guide — unique in the corpus. Other frameworks assume a specific model; GSD for Antigravity treats model selection as a documented engineering decision.

04

Workflow

GSD for Antigravity — Workflow

Primary Workflow

/new-project → SPEC.md + ROADMAP.md
    ↓
/plan 1       → .gsd/phases/1/PLAN.md
    ↓
/execute 1    → Wave-based parallel shard execution
    ↓
/verify 1     → Must-haves validation with proof
    ↓
(repeat for each phase)

Phase to Artifact Map

Phase Artifact
/new-project .gsd/SPEC.md, .gsd/ROADMAP.md, .gsd/STATE.md
/map .gsd/ARCHITECTURE.md
/plan [N] .gsd/phases/N/PLAN.md
/execute [N] Source code, atomic commits per shard
/verify [N] Verification report with proof (screenshots/output)
/pause .gsd/STATE.md session dump
/sprint new Sprint definition in ROADMAP.md
/sprint close Sprint retrospective

Wave-Based Execution

The /execute workflow (from source):

  1. Validate phase and plan exist
  2. Discover all plans in phase directory
  3. Analyze dependencies between plans
  4. Group plans into execution waves
  5. For each wave: spawn focused execution agents in parallel
  6. Verify phase goal after all waves complete
  7. Update ROADMAP.md and STATE.md
Context budget: ~15% orchestrator, fresh context per plan execution.

Approval Gates

  1. SPEC.md finalization: /new-project requires SPEC.md to be finalized before proceeding
  2. Plan validation: /plan-checker skill validates plan quality before execution
  3. Verification gates: /verify [N] requires "must-haves" to pass with proof (screenshots, command output)
  4. Phase removal safety: /remove-phase includes safety checks before removing
  5. Debugging 3-strike rule: /debug tries 3 approaches before escalating to human

Token Budget Thresholds

Usage Status Action
0-50% OK Proceed normally
50-70% Warning Compress, use outlines
70%+ Critical State dump required

Session Continuity

/pause saves session state to STATE.md for handoff. /resume restores from STATE.md. JOURNAL.md logs session activity as persistent audit trail.

New-Project Deep Questioning

/new-project is the most leveraged entry point — it creates all .gsd/ files through a structured questioning process:

  1. Detect existing code (brownfield detection)
  2. Deep questioning → SPEC.md
  3. Tech stack selection
  4. Phase structure → ROADMAP.md
  5. Initial STATE.md
  6. ARCHITECTURE.md (if brownfield)
06

Memory Context

GSD for Antigravity — Memory & Context

State Storage

  • Type: File-based markdown
  • Persistence scope: Project (.gsd/ directory)
  • Search: Manual (search_repo.ps1/.sh wrapper for grep/find)

State Files

File Purpose
.gsd/SPEC.md Project specification (canonical source of truth)
.gsd/ROADMAP.md Phase structure and progress tracking
.gsd/STATE.md Session memory — current position, active work
.gsd/ARCHITECTURE.md System design (generated by /map)
.gsd/STACK.md Technology inventory
.gsd/DECISIONS.md Architecture Decision Records
.gsd/JOURNAL.md Session log (persistent audit trail)
.gsd/TODO.md Quick capture for ideas/tasks
.gsd/phases/N/PLAN.md Per-phase execution plans

Session Continuity

/pause serializes current session state to STATE.md:

  • Current position (phase, plan)
  • Active work in progress
  • Context needed to resume

/resume reads STATE.md and reconstructs context for the next session.

The JOURNAL.md serves as a persistent session audit log — each session's activity is appended, making it reviewable across sessions without needing the AI to summarize.

Compaction Handling

The context-health-monitor skill detects context quality degradation (not window compaction specifically). At 70%+ token budget, requires state dump to STATE.md before proceeding. The context-compressor skill can compress current context for continued use.

Token Budget Management

Explicit token tracking via token-budget skill:

  • 0-50%: Normal operation
  • 50-70%: Warning — compress, use outlines
  • 70%+: Critical — state dump required, fresh context recommended

Cross-Session Handoff

Yes — via STATE.md. Any session can be paused and resumed, including handoff to a different model (e.g., pause in Claude, resume in Gemini).

search_repo.ps1/.sh wraps grep/find for repository search. context-fetch skill enforces search-before-read pattern to avoid loading files blindly.

07

Orchestration

GSD for Antigravity — Orchestration

Multi-Agent: Yes (within single model)

The /execute workflow spawns "focused execution agents" per plan shard in a wave. These are not separate AI instances — they are fresh context windows within the same model session. The 11 agent skills provide specialized behavior but are invoked as tool calls, not separate agents.

Orchestration Pattern: Parallel-Fan-Out (within /execute)

Wave-based execution: plans are grouped into waves by dependency, then executed in parallel within each wave. The orchestrator uses ~15% of context budget; each plan execution gets fresh context.

Isolation Mechanism: None

Works in-place. No git worktree, no container. Atomic commits per shard provide rollback capability.

Execution Mode: Interactive-loop

Session-based: user invokes commands, AI executes. Not a daemon.

Multi-Model: Yes (adapter-based)

The framework explicitly supports multiple models via adapters/:

  • adapters/CLAUDE.md — Claude-specific rules
  • adapters/GEMINI.md — Gemini-specific rules
  • adapters/GPT_OSS.md — GPT/open-source rules
  • .gemini/GEMINI.md — Gemini IDE integration
  • model_capabilities.yaml — capability registry

Users copy the adapter for their model. The model-selection-playbook.md guides model choice by task type.

Model Role Mapping

The model_capabilities.yaml registry and docs/model-selection-playbook.md guide routing, but routing is manual (user selects model). No semantic blast scoring or automatic routing.

Consensus Mechanism: None

Prompt Chaining: Yes

SPEC.md → /plan → PLAN.md → /execute (reads PLAN.md) → /verify (reads ROADMAP.md). Each phase output feeds the next.

Auto-Validators

  • /verify [N] requires proof (screenshots, command output) — not automated testing
  • plan-checker skill validates plan quality
  • empirical-validation skill enforces evidence-based verification
  • validate-*.sh scripts validate framework file structure (not code quality)

TDD Enforcement

Not enforced. GSD for Antigravity is methodology-focused, not test framework-specific.

Git Automation

/execute creates atomic commits per shard. No auto-PR, no auto-merge, no branch management.

Cross-Tool Portability: High

Core workflows in .agent/workflows/ are model-agnostic markdown. Adapter files (adapters/CLAUDE.md etc.) add model-specific behavior. Works with Claude, Gemini, GPT, and any capable LLM that reads files.

08

Ui Cli Surface

GSD for Antigravity — UI / CLI Surface

CLI Binary

None. No dedicated CLI binary. The framework is invoked via slash commands in the AI chat interface.

The scripts/ directory contains PowerShell and bash utility scripts:

  • validate-all.ps1/.sh — Run all validators
  • setup_search.ps1/.sh — Configure search tools
  • search_repo.ps1/.sh — Search repository

These are manual scripts, not a CLI framework.

Local UI

None. No web dashboard, no TUI, no desktop app.

Slash Command UX

Commands are typed directly as chat messages (e.g., /plan 1). From README:

"Slash commands are typed directly as chat messages. They are NOT IDE autocomplete features — if your editor shows 'nothing found' when pressing '/', that's normal. Just type the full command and send it."

29 total slash commands across all categories (27 in .agent/workflows/ + 2 sprint subcommands).

Multi-Model Configuration

Model-specific adapters:

  • adapters/CLAUDE.md — Copy to project root as CLAUDE.md for Claude
  • adapters/GEMINI.md — Copy to project root for Gemini
  • adapters/GPT_OSS.md — For GPT/open-source models
  • .gemini/GEMINI.md — Gemini IDE-native integration

model_capabilities.yaml is an optional registry of model capabilities for the model-selection-playbook.md guidance.

IDE Integration

  • Claude Code: Full support (CLAUDE.md adapter)
  • Gemini CLI/IDE: .gemini/GEMINI.md integration
  • Other IDEs: Any that reads files (via GPT_OSS.md adapter)

Observability

  • .gsd/JOURNAL.md — Session log, appended each session
  • .gsd/STATE.md — Current state snapshot
  • /progress command — Show current position in roadmap
  • /sprint status — Sprint metrics

Cross-Platform Support

All scripts provided in both PowerShell (Windows) and bash (Linux/macOS). This is the most explicitly cross-platform framework in the batch.

Related frameworks

same archetype · same primary tool · same memory type

MemPalace ★ 53k
A10 Memory engine

Verbatim local-first AI memory with 96.6% R@5 retrieval on LongMemEval using zero API calls — structured into a palace hierarchy…

Beads (Yegge) ★ 24k
A10 Memory engine

Dolt-powered distributed graph issue tracker where AI agents track tasks with hierarchical IDs and dependency edges, claim work…

deepagents (LangChain) ★ 23k
A10 Memory engine

Opinionated Python agent harness on top of LangGraph with sub-agents, filesystem, memory, and context compaction bundled in

agentmemory ★ 18k
A10 Memory engine

Persistent, searchable memory for AI coding agents that captures every tool interaction, compresses it via LLM, and injects…

Open Multi-Agent ★ 6.3k
A10 Memory engine

Give a natural-language goal to a coordinator agent and get a dynamically decomposed, parallelized task DAG executed by…

Basic Memory ★ 3.1k
A10 Memory engine

Gives AI agents a persistent, human-readable knowledge graph of project decisions, observations, and relations stored as plain…