Get Shit Done: A Meta-Prompting, Context Engineering and Spec-Driven Dev System

English · 简体中文

A light-weight and powerful meta-prompting, context engineering and spec-driven development system for Claude Code, OpenCode, Gemini CLI, Codex, Copilot, and Antigravity.

Solves context rot — the quality degradation that happens as Claude fills its context window.

npx get-shit-done-cc@latest

Works on Mac, Windows, and Linux.

*"If you know clearly what you want, this WILL build it for you. No bs."

*"I've done SpecKit, OpenSpec and Taskmaster — this has produced the best results for me."

*"By far the most powerful addition to my Claude Code. Nothing over-engineered. Literally just gets shit done."

Trusted by engineers at Amazon, Google, Shopify, and Webflow.

Why I Built This · How It Works · Commands · Why It Works · User Guide

I'm a solo developer. I don't write code — Claude Code does.

Other spec-driven development tools exist; BMAD, Speckit... But they all seem to make things way more complicated than they need to be (sprint ceremonies, story points, stakeholder syncs, retrospectives, Jira workflows) or lack real big picture understanding of what you're building. I'm not a 50-person software company. I don't want to play enterprise theater. I'm just a creative person trying to build great things that work.

So I built GSD. The complexity is in the system, not in your workflow. Behind the scenes: context engineering, XML prompt formatting, subagent orchestration, state management. What you see: a few commands that just work.

The system gives Claude everything it needs to do the work and verify it. I trust the workflow. It just does a good job.

That's what this is. No enterprise roleplay bullshit. Just an incredibly effective system for building cool stuff consistently using Claude Code.

— TÂCHES

Vibecoding has a bad reputation. 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 Claude Code reliable. Describe your idea, let the system extract everything it needs to know, and let Claude Code get to work.

People who want to describe what they want and have it built correctly — without pretending they're running a 50-person engineering org.

npx get-shit-done-cc@latest

The installer prompts you to choose:

Runtime— Claude Code, OpenCode, Gemini, Codex, Copilot, Antigravity, or allLocation— Global (all projects) or local (current project only)

Verify with:

• Claude Code / Gemini: /gsd:help

• OpenCode: /gsd-help

• Codex: $gsd-help

• Copilot: /gsd:help

• Antigravity: /gsd:help

Note

Codex installation uses skills (skills/gsd-*/SKILL.md

) rather than custom prompts.

GSD evolves fast. Update periodically:

npx get-shit-done-cc@latest

Non-interactive Install (Docker, CI, Scripts)

# Claude Code
npx get-shit-done-cc --claude --global # Install to ~/.claude/
npx get-shit-done-cc --claude --local # Install to ./.claude/
# OpenCode (open source, free models)
npx get-shit-done-cc --opencode --global # Install to ~/.config/opencode/
# Gemini CLI
npx get-shit-done-cc --gemini --global # Install to ~/.gemini/
# Codex (skills-first)
npx get-shit-done-cc --codex --global # Install to ~/.codex/
npx get-shit-done-cc --codex --local # Install to ./.codex/
# Copilot (GitHub Copilot CLI)
npx get-shit-done-cc --copilot --global # Install to ~/.github/
npx get-shit-done-cc --copilot --local # Install to ./.github/
# Antigravity (Google, skills-first, Gemini-based)
npx get-shit-done-cc --antigravity --global # Install to ~/.gemini/antigravity/
npx get-shit-done-cc --antigravity --local # Install to ./.agent/
# All runtimes
npx get-shit-done-cc --all --global # Install to all directories

Use --global

(-g

) or --local

(-l

) to skip the location prompt. Use --claude

, --opencode

, --gemini

, --codex

, --copilot

, --antigravity

, or --all

to skip the runtime prompt.

Development Installation

Clone the repository and run the installer locally:

git clone https://github.com/glittercowboy/get-shit-done.git
cd get-shit-done
node bin/install.js --claude --local

Installs to ./.claude/

for testing modifications before contributing.

GSD is designed for frictionless automation. Run Claude Code with:

claude --dangerously-skip-permissions

Tip

This is how GSD is intended to be used — stopping to approve date

and git commit

50 times defeats the purpose.

Alternative: Granular Permissions

If you prefer not to use that flag, add this to your project's .claude/settings.json

:

{
"permissions": {
"allow": [
"Bash(date:*)",
"Bash(echo:*)",
"Bash(cat:*)",
"Bash(ls:*)",
"Bash(mkdir:*)",
"Bash(wc:*)",
"Bash(head:*)",
"Bash(tail:*)",
"Bash(sort:*)",
"Bash(grep:*)",
"Bash(tr:*)",
"Bash(git add:*)",
"Bash(git commit:*)",
"Bash(git status:*)",
"Bash(git log:*)",
"Bash(git diff:*)",
"Bash(git tag:*)"
]
}
}

Already have code?Run/gsd:map-codebase

first. It spawns parallel agents to analyze your stack, architecture, conventions, and concerns. Then/gsd:new-project

knows your codebase — questions focus on what you're adding, and planning automatically loads your patterns.

/gsd:new-project

One command, one flow. The system:

Questions— Asks until it understands your idea completely (goals, constraints, tech preferences, edge cases)Research— Spawns parallel agents to investigate the domain (optional but recommended)Requirements— Extracts what's v1, v2, and out of scopeRoadmap— Creates phases mapped to requirements

You approve the roadmap. Now you're ready to build.

Creates: PROJECT.md

, REQUIREMENTS.md

, ROADMAP.md

, STATE.md

, .planning/research/

/gsd:discuss-phase 1

This is where you shape the implementation.

Your roadmap has a sentence or two per phase. That's not enough context to build something the way you imagine it. This step captures your preferences before anything gets researched or planned.

The system analyzes the phase and identifies gray areas based on what's being built:

Visual features→ Layout, density, interactions, empty statesAPIs/CLIs→ Response format, flags, error handling, verbosityContent systems→ Structure, tone, depth, flowOrganization tasks→ Grouping criteria, naming, duplicates, exceptions

For each area you select, it asks until you're satisfied. The output — CONTEXT.md

— feeds directly into the next two steps:

Researcher reads it— Knows what patterns to investigate ("user wants card layout" → research card component libraries)Planner reads it— Knows what decisions are locked ("infinite scroll decided" → plan includes scroll handling)

The deeper you go here, the more the system builds what you actually want. Skip it and you get reasonable defaults. Use it and you get your vision.

Creates: {phase_num}-CONTEXT.md

/gsd:plan-phase 1

The system:

Researches— Investigates how to implement this phase, guided by your CONTEXT.md decisionsPlans— Creates 2-3 atomic task plans with XML structureVerifies— Checks plans against requirements, loops until they pass

Each plan is small enough to execute in a fresh context window. No degradation, no "I'll be more concise now."

Creates: {phase_num}-RESEARCH.md

, {phase_num}-{N}-PLAN.md

/gsd:execute-phase 1

The system:

Runs plans in waves— Parallel where possible, sequential when dependentFresh context per plan— 200k tokens purely for implementation, zero accumulated garbageCommits per task— Every task gets its own atomic commitVerifies against goals— Checks the codebase delivers what the phase promised

Walk away, come back to completed work with clean git history.

How Wave Execution Works:

Plans are grouped into "waves" based on dependencies. Within each wave, plans run in parallel. Waves run sequentially.