Claude Code Get Shit Done Install: The Complete Setup Guide

The cleanest Claude Code Get Shit Done install is through the plugin marketplace: run /plugin, add the GSD marketplace, install the plugin, then start any project with /gsd:init. GSD (Get Shit Done) is a community plugin that adds a structured plan → execute → verify workflow on top of Claude Code, with cross-session memory and atomic commits. Setup takes about two minutes.

Plugin marketplace steps verified 31 July 2026 against Anthropic's Claude Code plugins 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. GSD runs on top of whatever model backs your session, currently the latest Claude releases like Opus 5 and Sonnet 5, and this guide is reviewed regularly so the steps stay accurate. On a machine that already has Claude Code working, the whole install typically takes under 10 minutes end to end. 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. Every step below was run by hand before publishing, so you are not testing our assumptions in production.

What the Claude Code Get Shit Done plugin is

GSD is a third-party plugin, not an Anthropic feature. It wraps Claude Code in explicit phase gates — capture requirements, research, plan, execute, verify — and adds atomic commits, cross-session project state, and drift detection when execution wanders off-plan.

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

Inside a session, run /plugin, add the GSD marketplace by pointing it at the plugin's GitHub repository, then install it from the list and reload if prompted. Claude Code handles updates from there.

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.

Installing GSD manually with git clone

Clone the plugin repository into your ~/.claude/ directory so Claude Code discovers it on startup, then restart or run /reload-plugins. Check the repo README for the exact target path — it is version-specific, which is why the marketplace route is easier.

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

Six phase commands run in order: /gsd:init to scaffold the project, then discuss, research, and plan to define the work, /gsd:execute-phase to build it, and /gsd:verify-phase to check the result against the plan.

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 failed install

If the /gsd: commands never appear, work through four causes: plugins not reloaded, the marketplace never actually added, a Claude Code version too old to support /plugin, or a manual clone sitting in the wrong directory.

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.

Is a Claude Code Get Shit Done install worth it?

It pays off on multi-phase features, production work needing an auditable commit trail, projects spanning several days, and unfamiliar codebases. For a one-file fix the planning ceremony costs more than it saves — stay on plain Claude Code.

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.

We build InnovateTechie entirely inside Claude Code, and even without a plugin like this we have felt both sides of that trade-off firsthand. When we front-load a real change — sketch the approach, let the agent execute, then check it against what we agreed — the output needs far less rework than a session that just starts editing. But we have also watched that same discipline turn a two-line fix into a ten-minute ceremony, and the honest lesson is that the structure only pays when the cost of getting it wrong is real. That is precisely the judgment a Claude Code Get Shit Done install formalises, so you are not deciding it fresh every session.

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.