Short version: GSD is the lightweight, spec-driven one — keep contexts clean, stay out of your way. Superpowers is the opinionated one — it brings a full engineering methodology (TDD, disciplined debugging) and expects you to work its way. Neither is "better"; they suit different temperaments.
If you've run Claude Code on anything non-trivial, you've felt it: it starts sharp, then around the halfway mark of a long session the quality slides — requirements drift, corners get cut. That's context rot, and it's the problem both of these frameworks exist to solve. Both are free and open-source, both split work into phases, and both spawn fresh subagents with clean context per task instead of one long, degrading session. The difference is what they do inside that structure.
GSD (Get Shit Done)
Created by TÂCHES (gsd-build/get-shit-done), GSD is a lightweight meta-prompting and spec-driven system, and it's the more popular of the two by a wide margin (30k+ GitHub stars). Its whole philosophy is context hygiene: split a task into plan → execute → review, and give each phase its own clean context window and a single clear objective, so Claude never has to hold the entire project in a degrading buffer.
- Bet: the problem is context, not discipline. Keep each phase's context clean and small, and quality stays high on its own.
- Feel: lightweight, spec-first, unopinionated about how you write code. It structures the workflow, not your engineering practice.
- Best when: you want speed and clean phased execution without a framework telling you to write tests first, and you value a large, active community.
Superpowers
Created by Jesse Vincent / obra (obra/superpowers), Superpowers installs a set of structured "skills" into Claude Code — reusable mental models it invokes instead of improvising each time. Where GSD is minimal, Superpowers is a full engineering methodology with strong opinions: red-green-refactor TDD (tests must fail before you implement), a four-phase debugging process that demands root-cause analysis before any fix, and Socratic brainstorming to pin down requirements before code. Each task runs in a fresh subagent with a two-stage review — spec compliance first, then code quality.
- Bet: the problem is discipline, not just context. Bake rigorous practices into the agent and the output gets genuinely production-grade.
- Feel: heavier and more prescriptive. It will make you (and Claude) work a certain way — that's the point.
- Best when: you want the framework to enforce test-driven, root-cause-first engineering, and you're happy to adopt its methodology to get it.
Side by side
| GSD (Get Shit Done) | Superpowers | |
|---|---|---|
| Core idea | Lightweight, spec-driven context engineering | Opinionated engineering methodology as skills |
| Structure | Plan → execute → review, clean context per phase | Brainstorm → plan → execute, skills + subagents |
| Methodology | Unopinionated — no imposed practice | Enforces TDD + disciplined debugging |
| Context strategy | Fresh subagent, clean window per task | Fresh subagent per task, two-stage review |
| Weight | Light, fast to adopt | Heavier, more prescriptive |
| Community | Very large (30k+ stars) | Growing, methodology-focused |
| Pick it if | You want clean phases without a methodology imposed | You want rigor (tests-first, root-cause) enforced |
Both are free and open-source and evolve quickly; check each repo for the current state before you commit.
So which one?
It comes down to how much opinion you want from your tools. Reach for GSD if you already have your own engineering habits and just want Claude to stop degrading over long sessions — it's the lighter touch and the bigger community. Reach for Superpowers if you want the guardrails — if "it forces me to write tests first and actually root-cause bugs" sounds like a feature, not friction. Plenty of people try both and keep the one that matches how they already like to work.
A third option: if you want the app, not the framework
Both GSD and Superpowers are things you install into the Claude Code terminal and drive yourself — prompts, skills, and commands you compose. If what you actually want is that same phased, review-gated discipline delivered as an integrated app instead of a framework you assemble, that's a different category — and it's what we build.
defract runs the whole lifecycle — story → design → architecture → review → ship — as a desktop app: the phases, fresh git-worktree parallelism, and agent-reviewed merges come built in, plus a visual design stage where agents render mockups you approve before any code is written. Same core insight as these frameworks (structure beats a single degrading session); different form factor (an app with a UI, not skills in a terminal). If you live in the CLI and love composing your own setup, GSD or Superpowers is your answer. If you'd rather it came out of the box, that's us.