Superpowers Vs GSD Vs Compound Engineering

Three agent frameworks that disagree about exactly one thing

Superpowers, GSD, and Compound Engineering are the three Claude Code frameworks worth knowing, and they differ on one thing: how far the agent gets before it stops and shows you something. Superpowers stops it at a plan and a failing test, GSD at the end of each phase. Compound Engineering runs on top of either one, writing each correction into the rules file the next run loads.

🧭 Part 21 of the 🤖 Agents course

TL;DR

A coding agent is a climber on your rope, and every framework is a different belay.

• The rope: how far the agent gets on its own before it has to stop. Short rope means frequent checkpoints and slow progress. Long rope means it covers ground fast and you find out late where it went.

• The anchor points: each framework picks different places to clip in. A plan you approve, a test that has to fail first, the end of a phase.

• The fall: an unchecked agent does not stop at wrong. It keeps building on wrong, confidently, until you read the diff.

• The catch: the framework is not the safety. The tests you wrote are, and no belay holds if nobody is holding it.

Before the Frameworks, There Was the Loop

The rawest version of agentic coding has no checkpoints at all. Geoffrey Huntley’s “Ralph” technique is a bash while loop that feeds the same prompt to Claude Code over and over, fresh context each iteration, until the tests pass or you kill it. We took Claude Code’s own loop apart in How Claude Code Actually Works, and Ralph is that loop with the human removed.

Ralph works often enough to be tempting. Huntley’s own warning is why the frameworks exist. You will “wake up to broken codebases that don’t compile¹.”

That is a full night on the rope with no anchor. The agent never stopped to show anyone anything.

Why an Unchecked Agent Costs You More Than It Saves

You point Claude Code at a feature on a Friday. No framework, no checkpoints. By Monday you have a 600-line pull request across forty files. Every test the agent wrote passes. Thirty-eight of those files sit on a caching decision it made in hour one and got wrong.

The agent did what you asked. You asked it to build the feature and walked away, so now you are doing code archaeology on your own repo.

The expensive failure is not the wrong caching decision. An agent that gets something wrong and stops is cheap: you read twenty lines and correct it. An agent that writes wrong code and keeps going is expensive, because every decision after it assumes the wrong one was right. Cost grows with distance from the last checkpoint. This is the same failure we traced through production systems in Why AI Agents Keep Failing in Production, where almost nothing goes wrong at the model and almost everything goes wrong in the loop around it.

So the useful question about a framework is not how smart it makes the agent. It is where the agent has to stop.

⚠️ Confusion Alert: People shop these as four rival products. Only three are lengths of rope: Ralph, GSD, Superpowers. This matters because you never pick Compound Engineering instead of one of them. You add it when the same correction keeps coming back.

Superpowers, GSD, and Compound Engineering each answer the same four questions, in the same order. Where does it make the agent stop, what does that checkpoint cost you, can you trust it, and when should you skip it.

1 - Superpowers

What it is. A skills-first methodology that boots at the start of every Claude Code session through a hook. It ships /brainstorm, /write-plan, /execute-plan, and 20-plus skills.

The loop. Brainstorm the idea, write a spec shown back to you in readable chunks, write a plan, then run subagent-driven test-driven development (red, then green), a two-stage self-review, and finally an offer to open the PR. Plan before code, tests before implementation, baked in. The subagent pattern it leans on is the same one behind How Anthropic Built Multi-Agent Deep Research: a coordinator that spawns fresh workers and reads what they hand back.

Key innovation. The instruction hierarchy. Its using-superpowers meta-skill makes a skill-check mandatory before it acts, so the agent cannot freelance past its own playbook, and it puts your CLAUDE.md above its own skills. A framework that defers to your project’s rules composes with your harness rather than fighting it. That sounds small. It is the difference between a tool that adapts to your repo and one that imposes itself on it.

Trust and distribution. This is the one you can trust on provenance. Superpowers ships through Anthropic’s official plugin marketplace as an accepted plugin, installed with /plugin install superpowers@claude-plugins-official, and it runs cross-harness on Codex, Cursor, Gemini CLI, and more². Official distribution is the cleanest legitimacy signal in a category where a popular framework’s repo became a liability overnight. Cross-harness matters more than it sounds, because these tools diverge underneath. How Cursor Actually Works shows how differently one of them handles context, and a framework that survives the switch is one you learn once.

The ceiling. It forces plan-before-code and TDD on everything, which is overhead you do not want for a throwaway script. For a five-line fix, the ceremony costs more than the fix. Drop to a bare prompt when you could describe the diff in one sentence.

2 - GSD (Get-Shit-Done)

What it is. Spec-driven development as a chain of slash commands, roughly 29 skills and 12 custom agents, with no proprietary runtime.

The loop. Each phase runs in a fresh 200K-token subagent context to defeat context rot, the slow decay of an agent’s judgment as its window fills with old turns. The main session stays at 30 to 40 percent utilization while subagents do the heavy lifting and report back.

Key innovation. Two of them, and both are worth stealing even if you never install GSD. First, aggressive atomicity: 2 to 3 tasks per plan, each sized to fit half a fresh window, so every unit is small enough to verify and revert. Second, goal-backward verification. Instead of checking “did it run,” GSD asks “what must be TRUE for the goal to be met,” then checks each condition. For “add rate limiting,” it derives conditions like “the sixth request in the window returns a 429” and “the counter resets after the TTL,” and verifies each one rather than just confirming the file compiles. That catches the gap between code that executes and code that is correct.

Trust and distribution. Here is the cautionary tale of the whole category. GSD’s original repo can no longer be trusted, following ownership concerns that included a meme-coin incident, and the original author is no longer involved. Development moved to open-gsd governance, so run the open-gsd or redux fork and never the original³. The framework is good. The source went bad. That is the supply-chain risk of installing other people’s agent automation in one sentence.

The ceiling. It is the heavyweight. The fresh-context-per-phase machinery and the spec ceremony are built for substantial, multi-session work. On a small task it is slower than just prompting, the same way a CI pipeline is overkill for a one-character typo fix.

3. Compound Engineering

What it is. A doctrine, and a plugin, built on one line: “each unit of engineering work makes the next easier.” It comes from Kieran Klaassen and Dan Shipper at Every, the team building Cora. It sits in the same layer as the rest of The Open-Source Agent Toolkit in 2026: not a runtime, a discipline you bolt onto one.

The loop. Plan, work, review, compound. The first three look like any disciplined workflow. The fourth is the entire point.

Key innovation. The compound step. Every bug, failed test, and insight gets written into a learning loop that future agents read, so a correction you make once becomes a rule the agent follows forever. It also runs tiered persona reviewers in parallel, security, correctness, and architecture reviewing at the same time with confidence-gating and dedup. And it inverts the ratio: Compound Engineering claims roughly 80 percent of the work is now planning and review, 20 percent execution. When the agent does the typing cheaply, your leverage moves to specifying and verifying.

Trust and distribution. Every runs five products with primarily single-person engineering teams on this system⁴. That is the strongest real-world proof point in the category: one engineer per product, sustained, on a workflow that compounds. The caveat is churn. The parallel reviewers are token-heavy, and it ships often enough that the commands have already been renamed once (the /ce- prefix is the current set), so docs and habits go stale fast.

The ceiling. If you want a stable, learn-it-once tool, the weekly churn will wear you down. And budget the tokens: a panel of reviewers multiplies your review cost by the number of reviewers on every change, so gate it to the pull requests that touch security or money rather than running it on every commit.

The Comparison

Read across the rows and the three stop looking like rivals. Every one of them takes the same move, an agent pausing to show a human something, and applies it at a different grain. Superpowers puts the pause before any code exists, so the thing you read is a plan. GSD puts it at the end of a chunk of work, so the thing you read is a shipped phase. Compound Engineering puts it after the review and then writes down what the review found, so the next run reads it instead of you.

The differences that look big in the docs are mostly ceremony. The difference that decides your week is how much work sits between two pauses.

Picking Your Checkpoint

Three questions decide it.

1. How expensive is this to undo? A throwaway script is free to throw away, so run a bare prompt or a Ralph loop and let it go. Anything touching production takes the plan gate, which puts you on Superpowers.

2. Does the run outgrow one context window? Once it does, the agent starts building on decisions it can no longer see. That is what phase boundaries are for, which means GSD.

3. Are you making the same correction twice? A tighter checkpoint will not fix that, because the checkpoint catches it and then forgets. Compound Engineering’s fourth step writes the correction down. It pays for itself once you are shipping several agent-written changes a week, and burns tokens if you are not.

Plainly: start with Superpowers. It is the default for most operators because it gives you plan-before-code and TDD without GSD’s ceremony or Ralph’s risk. Reach for GSD when the work is large enough that context rot becomes your enemy, the kind of multi-day build where the agent forgets decisions it made an hour ago. Add Compound Engineering when you are running enough volume that capturing lessons pays for itself, which for most people means a real team or a real product rather than a weekend project.

The Honest Take

The framework is not the safety. The tests you own are, the ones asserting what the feature must do rather than the ones the agent wrote to make itself green. Your leverage sits in what surrounds the agent: those tests, the CLAUDE.md, and the lint and type gates that tell it when it is wrong. Point Superpowers, GSD, or Compound Engineering at a repo without those three and it ships slop faster, with better formatting. Thomas Ptacek called an effective agent “simple systems code, wired to ground truth.”

Provenance is the part nobody weighs. What happened to GSD is the risk model of agentic coding made visible: you install a stranger’s automation, then grant it broad permissions on your codebase. Prefer an official marketplace or community governance over a single maintainer you cannot reach.

Mitchell Hashimoto built the same tests-plus-rules setup on his own. Every line of his Ghostty AGENTS.md traces back to one past agent failure. Call the file CLAUDE.md, AGENTS.md, or anything else. Writing failures into it is the durable idea in this category.

The One Thing to Remember

Six months from now the version numbers will be wrong and the commands will have new names. The question underneath will not change: how far does the agent get before it stops, and what do you read when it does. Ralph, GSD, and Superpowers are three answers, and Compound Engineering runs on top of GSD or Superpowers, whichever you land on. The part that compounds is yours. Every test you write yourself buys the agent a little more rope, because that test catches what you used to catch by reading.

---

💬 Running one of these in production? Tell me in the comments which checkpoint actually saved you, and which one you ripped out.

---

Where to Next?

• 📖 Go deeper: How OpenAI Codex Works, what a fully sandboxed agent gives up in exchange for running unattended.

• 🔀 Related: AI Coding Tools: What Changed in the Last 6 Months, the field these frameworks compete in.

• 🔗 Prerequisite: What is an AI Agent?, the loop all of this wraps.

🔜 Tuesday: Why Your Multi-GPU Training Job Keeps Dying. Four ways a small multi-GPU run kills itself, and the logging that tells you which one it was.

FAQ

Which Claude Code framework should I start with?
Superpowers, for most people. It enforces plan-before-code and test-driven development without GSD’s phase ceremony or Ralph’s autonomous risk, and it ships through Anthropic’s official marketplace, so the provenance is clean. Move to GSD when the work runs past what one context window holds.

Is GSD safe to install?
Install gsd-core under open-gsd governance, never the original packages. The original maintainer went unreachable in April 2026 and the project’s token picked up a public rug-pull link, so the community mirrored the code and stripped every token reference. The framework itself is good. The original supply chain is not.

What makes Compound Engineering different from Superpowers or GSD?
It is a discipline rather than a length of rope, built on a fourth loop step where every bug and correction gets written into the rules file future agents read. You can run it on top of another framework. Its costs are heavy token use from parallel reviewers, plus the engineer time that shifts into planning and review.

Do these frameworks make Claude Code write better code?
They make the process safer and more repeatable. They do not make the model smarter. What they buy you is earlier detection: the same wrong turn costs twenty lines of reading instead of a 600-line pull request you have to reverse-engineer on Monday.

1. The Ralph Wiggum technique, Geoffrey Huntley (July 2025)

2. Add superpowers plugin to marketplace, Anthropic (January 2026)

3. Welcome to GSD-Core, why the fork, what changed, what’s next, open-gsd (May 2026)

4. Compound Engineering: The Definitive Guide, Every (February 2026)