In 2026 a new category of Claude Code tooling went from niche to unavoidable: the skills framework. These are open-source collections of skills, prompts and rules you install into the Claude Code CLI to make agents behave — follow a process, keep context straight, stay in their lane. Three names dominate the conversation: Superpowers, GSD and gstack, each with tens of thousands of GitHub stars and a passionate following.
The question everyone asks is "which one should I use?" It's the wrong question, and this piece is about why. The better questions are: what does each one actually constrain, why do experienced users run more than one at a time, and where does a skills framework stop being the right tool at all?
what a "skills framework" actually is
Claude Code, on its own, is a very capable terminal agent with almost no opinion about how you work. A skills framework adds that opinion. It ships a set of reusable skills (structured prompts the agent can invoke), workflow rules, and conventions — installed into the CLI, usually free and open-source, living entirely in your terminal. It doesn't replace Claude Code; it disciplines it.
What they don't do is change the surface: you're still in the CLI, still driving, still reviewing diffs yourself. The framework is a layer of behavior, not a new application.
the three that matter
Superpowers — constrains the process
Superpowers (by Jesse Vincent / obra) is the biggest of the three, and its central bet is test-driven development. It pushes the agent to write tests first, work in disciplined increments, and lean on a large, composable library of skills. The effect is that the development process gets constrained: less cowboy coding, more red-green-refactor. If your failure mode is agents that charge ahead and produce plausible-but-wrong code, Superpowers is aimed squarely at you.
GSD — constrains context
GSD ("Get Shit Done"), from TÂCHES, is a lightweight meta-prompting, context-engineering and spec-driven system (npx get-shit-done-cc). Its concern is context rot — the way long agent sessions drift as the window fills with noise and the model loses the thread. GSD leans on specs and disciplined context management to keep a longer, multi-step build coherent. If your failure mode is "it was going great, then twenty steps in it forgot what we were doing," GSD is aimed there.
gstack — constrains perspective
gstack is a scaffolding and governance framework: you pre-define your stack and give the agent role-based structure so it reasons from a clear, bounded technical context rather than an open-ended one. It went from open-sourced to ~50k stars in a couple of weeks. Its concern is the decision-making perspective — making sure the agent operates inside guardrails you set, not whatever it infers. If your failure mode is agents making architectural calls you never sanctioned, gstack is aimed there.
The one-liner the community landed on: gstack thinks, GSD stabilizes, Superpowers executes. Three different failure modes, three different constraints — which is exactly why the "which one" framing breaks down.
why people stack them instead of choosing
Here's the part the "vs" articles miss: these frameworks aren't really competitors. They constrain different things, so experienced users run several at once — gstack to bound the decisions, GSD to hold context across a long build, Superpowers to keep execution disciplined. The honest answer to "which framework" is often "a combination, tuned to whichever failure mode bites you most."
That's a genuinely powerful setup. If you love living in the terminal, composing your own toolchain, and tuning it to your taste, a stack of skills frameworks gives you enormous control for zero dollars. For a lot of engineers, that's the dream.
the catch nobody puts on the box
Assembling and running a stack of frameworks is itself work — and it's worth being honest about the cost before you commit:
- You own the seams. Three frameworks that each move weekly means three changelogs, occasional conflicts, and a config that's yours to keep coherent. The stack is powerful because it's composable; it's fragile for the same reason.
- It's all text. Skills frameworks operate in prompts, tests and rules. There's no visual step — no place to see a UI before it's built. For anything with an interface, design still happens in your head or another tool.
- You're still the orchestrator. Parallel work, worktrees, reviewing what each agent did, remembering decisions across sessions — the framework disciplines the agent, but the coordination is still on you, in the terminal.
None of this makes skills frameworks a bad choice. It makes them a particular choice: maximum control, in the CLI, at the cost of assembly and coordination that you do by hand.
when you want an app instead
There's a different answer to the same problem, and it's worth knowing about even if you end up preferring the stack. Instead of installing behavior into the CLI, you can use an application that has the structure built in.
That's the category defract is in — full disclosure, it's the tool we build. Rather than composing frameworks, it runs Claude Code through one integrated lifecycle — story → design → architecture → implementation → review → release — with the things a text-only stack can't easily give you: a visual design stage where agents render HTML mockups you approve before any code is written, git-worktree parallelism managed for you, agent-reviewed merges, and memory that carries decisions across builds. Nothing to install or keep in sync; you download it and open it.
The trade is real and cuts both ways. An app is more opinionated and less composable than a skills stack — if you want to hand-tune every rule, that's a downside, not a feature. And skills frameworks are cross-platform and free-as-in-freedom in a way a macOS app isn't yet. The honest split is: reach for a skills stack if you want maximum terminal control and don't mind assembling it; reach for an app if you'd rather the structure — and a design stage — come built in. We wrote a fuller side-by-side in defract vs Superpowers.
how to actually decide
- Agents charge ahead and ship plausible-but-wrong code? Start with Superpowers (TDD discipline).
- Long builds drift and lose the thread? Add GSD (context engineering).
- Agents make calls you never sanctioned? Add gstack (role-based governance).
- Hitting all three and tired of maintaining the seams? That's the signal you might want an integrated app rather than a bigger stack.
- Building something with a UI? Note that none of the frameworks give you a visual design step — that gap is real regardless of which you pick.
The skills-framework wave is one of the healthiest things to happen to agentic coding this year, because it's a bet on structure over raw speed — the same bet we think the whole field is quietly making. Whether you get that structure by composing Superpowers, GSD and gstack in your terminal, or by opening an app that has it wired in, the lesson is the same: unconstrained agents don't ship trustworthy software, and the tools worth using are the ones that add the right constraints. Pick the failure mode that hurts most, and start there.
defract is in open beta
the structure a skills stack gives you — visual design stage, parallel orchestration, agent-reviewed merges — built into one app. free, no caps, no signup.