Claude Code Get Shit Done Install: The Complete Setup Guide

If you like Claude Code but want it to work in disciplined phases instead of one long freewheeling session, GSD is the add-on to try. It turns "build me a feature" into a repeatable pipeline — discuss, research, plan, execute, verify — so the agent ships production-shaped work rather than a first draft. Below is the full Claude Code Get Shit Done install, both the marketplace and manual routes, plus the commands you'll use once it's in.

What the Claude Code Get Shit Done plugin is

GSD is a third-party plugin, not an official Anthropic feature — a Claude Code-native workflow system that wraps the agent in a structured process. Instead of a single open-ended chat, GSD breaks a project into phases and drives each one through the same loop: capture requirements, research the approach, write a detailed plan, execute it, then verify the result against the plan.

What it adds on top of plain Claude Code:

• A plan → execute → verify loop with explicit phase gates
• Atomic commits so every change is isolated and reversible
• Cross-session memory and project state, so a phase you planned yesterday survives a restart
• Drift-detection safeguards that flag when execution wanders from the agreed plan

Because it's a plugin, it rides on Claude Code's own extension system — the same one that powers Claude Code skills — which is exactly why the marketplace install is the recommended path.

Claude Code Get Shit Done install: the marketplace way

This is the recommended route because Claude Code manages updates for you. Inside a Claude Code session:

1. Open the plugin manager with /plugin.
2. Add the GSD marketplace — point it at the GSD plugin's GitHub repository (for example /plugin marketplace add jnuyens/gsd-plugin). The plugin's GitHub README lists the exact marketplace address to use, since GSD ships in a few community distributions.
3. Install the plugin from the list the manager shows, then reload plugins if prompted.

Claude Code's plugin system is documented in full in Anthropic's plugins guide — the /plugin command, marketplaces, and how installed plugins expose their slash commands. Once GSD is installed this way, its /gsd:* commands appear automatically in every session.

Claude Code Get Shit Done install via git clone

If you'd rather install manually, GSD is just files in your Claude config directory. The pattern is to clone the plugin repository into ~/.claude/ so Claude Code discovers it on startup:

git clone https://github.com/jnuyens/gsd-plugin.git ~/.claude/gsd

Then restart Claude Code (or run /reload-plugins) so it picks up the new commands. Check the repo's README for the exact target path it expects — the manual Claude Code Get Shit Done install is version-specific, and the marketplace route avoids having to track that yourself. Whichever way you go, you can confirm success by typing /gsd: and seeing the command list appear.

Using GSD after install: the core commands

Once your Claude Code Get Shit Done install is complete, you drive projects with a small set of phase commands. They're designed to be run in order:

The flow is deliberately front-loaded: you spend time in discuss, research, and plan so that execute is mostly mechanical. That's the same philosophy behind Claude Code's own plan mode — decide before you build — taken to a full project scale.

Troubleshooting a Claude Code Get Shit Done install

If the /gsd: commands don't show up after installing, work through these:

1. Reload plugins. Run /reload-plugins (or restart Claude Code) so it re-scans for newly installed commands.
2. Confirm the marketplace was added. Re-open /plugin and check the GSD marketplace appears and the plugin is marked installed.
3. Check your Claude Code version. Plugins and marketplaces are a relatively recent feature — if /plugin isn't recognized, update Claude Code first.
4. Verify the clone path. For a manual install, the repo must sit where Claude Code looks for plugins; a wrong path is the usual reason commands never appear.

Most failed installs are one of those four. For the exact, current commands, the GSD repository README is the source of truth — GSD is community-maintained, so its install details evolve faster than Anthropic's core docs.

When a Claude Code Get Shit Done install is worth it

GSD isn't for every task — for a quick one-file fix, plain Claude Code is faster and simpler. The plugin earns its keep on work that benefits from structure:

• Multi-phase features where you want each stage planned and verified before the next begins, rather than one long session that quietly drifts off-spec.
• Production-shaped projects that need atomic commits and a clear trail of what changed and why — GSD's commit discipline makes review far easier than untangling one giant diff.
• Long-running work across days, where cross-session memory means you don't re-explain the project every morning. A completed Claude Code Get Shit Done install turns your .planning/ directory into durable project state that survives restarts.
• Teams that want consistency, because the same discuss → research → plan → execute → verify loop produces predictable, reviewable output no matter who runs it.
• Unfamiliar codebases, where the research and planning phases force the agent to understand the ground before it starts changing things.

The trade-off is overhead. GSD front-loads discussion and planning, so a trivial change carries more ceremony than it needs. Our rule: reach for a Claude Code Get Shit Done install when the cost of a wrong implementation is high — a real feature, a migration, anything you'll have to defend in code review — and stay on plain Claude Code for quick edits. The two aren't mutually exclusive; you can run a GSD project in one repo and an ordinary session in another.

It also pairs naturally with the rest of your setup. Because GSD is a plugin, it coexists with your skills, MCP servers, and hooks, and it runs in normal Claude Code sessions you can resume later. A Claude Code Get Shit Done install doesn't replace how you already work — it adds a disciplined mode you switch into when a project genuinely deserves the rigor.