Direct answer
Superpowers and Get Shit Done solve two different problems of Claude Code: the first decides how the assistant behaves while it works (design before writing, write the test before the code, prove it before declaring it done), the second decides what gets done and in which order, and writes it into files that outlive the session. This article tells how I use them together and when they are not worth using.
If you have ever reopened a project after a week and had to explain to the assistant again what you had decided, and why, the problem is not the model: the decisions lived in the conversation, and the conversation is over. This is the starting guide of a first-person series about two third-party projects that run on top of Claude Code, Superpowers and Get Shit Done (GSD), and about how I put them to work together.
Independence: I am not affiliated with Anthropic or with the authors of the two projects. I describe a personal method, with its limits: where a fact comes from the documentation I say so and link it, where it is my own experience I present it as such, without numbers I have not measured. I did not run Claude Code to write this article: the commands you find here are the ones in the documentation, read today, and when a block is runnable it runs without any assistant.
Why you need two tools and not one
A coding assistant can fail in two ways that look alike but have different causes. The first is behaviour inside a task: it rushes into writing code without having understood what you are asking, fixes a symptom instead of the cause, declares «done» without having tried. The second is memory between one task and the next: what you decided yesterday is gone, and the conversation context fills up with old material until it makes the answers worse. In its documentation, GSD calls this second phenomenon context rot, the quality degradation that builds up as the context window fills.
Superpowers works on the first problem, GSD on the second. It is a division of labour I have found useful, not a law: the two projects also share some ground, because both have a design phase and a planning phase, and for the same task it is better to use only one of them, otherwise you plan twice. The rule I apply is simple: GSD decides the phases and plans of the project, Superpowers governs how work is done inside each plan, that is debugging, testing and review.
Superpowers: a method made of skills
The first correction concerns the name it is often described with. Superpowers is not a skill marketplace: the project README defines it as a complete software development methodology for coding assistants, built on a set of composable skills and on initial instructions that make the assistant use them. The marketplace exists, but it is a different thing: a repository you install the plugin from. In Claude Code you install it from Anthropic's official marketplace or from the author's own, with the commands the README lists.
/plugin install superpowers@claude-plugins-official
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace
These are the two installation routes the README lists in its Claude Code section: the first command goes through the official marketplace, while the other two together first register the author's marketplace and then install from there. I did not run them, because they require Claude Code (schema to adapt to your environment). Once installed, the plugin is not copied by hand into .claude/skills/: it sits in the plugin cache, and its skills are invoked with the plugin name as a prefix (/superpowers:skill-name), because the Claude Code documentation says that plugin skills live in their own namespace.
The README describes the basic flow in seven steps, each handed to a skill that activates on its own when the situation calls for it.
- brainstorming: before building anything, it asks questions to understand what you really want and then restates it so you can correct it.
- using-git-worktrees: once the design is approved, it creates an isolated workspace on a new branch and checks that the tests start from green.
- writing-plans: it breaks the work into small tasks, each with exact file paths and verification steps.
- subagent-driven-development or executing-plans: it carries out the plan, either with one sub-agent per task and a review after each, or all in the current session with a single final review.
- test-driven-development: it enforces the red-green-refactor cycle during implementation.
- requesting-code-review: between one task and the next, it reviews the work against the plan and reports problems by severity.
- finishing-a-development-branch: when the work is done it verifies the tests and offers to merge, open a pull request, keep or discard the branch.
The order matters here, because each step produces what the next one needs: the plan comes out of an approved design, the execution out of a plan, the review out of a diff. It is also why the README speaks of mandatory workflows and not of suggestions: the assistant checks whether a relevant skill exists before any task. How a skill actually gets chosen, though, is not a mechanism I can describe: the Claude Code documentation only says that the description is what decides when to load it.
What Claude sees of a skill, and what it costs
Every skill is a folder with a SKILL.md file, and the file starts with a frontmatter that declares at least a name and a description. This is the real frontmatter of the systematic-debugging skill, copied from version 5.1.0 of the plugin installed on the test machine:
---
name: systematic-debugging
description: Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes
---
The line that counts is description: it is the only part of each skill the assistant sees before deciding whether to load it, and indeed it starts with «Use when», that is, it says when to use the skill and not what it contains. The body of the file enters the context only once the skill is activated. To measure this asymmetry I wrote a script that reads the plugin's skills and counts, for each one, the characters of the description and the lines and words of the body. The script calls no model: it reads text files.
"""How much text each skill loads: level 1 (name + description) and level 2 (body of SKILL.md)."""
import glob
import os
import re
import sys
pattern = os.path.expanduser(sys.argv[1])
righe = []
for percorso in sorted(glob.glob(pattern)):
testo = open(percorso, encoding="utf-8").read()
m = re.match(r"---\n(.*?)\n---\n(.*)", testo, re.S)
frontmatter, corpo = m.groups()
nome = re.search(r"^name:\s*(.+)$", frontmatter, re.M).group(1)
descrizione = re.search(r"^description:\s*(.+)$", frontmatter, re.M).group(1)
righe.append((nome, len(descrizione), len(corpo.splitlines()), len(corpo.split())))
print(f"{'skill':32} {'descr.(chars)':>13} {'body(lines)':>13} {'body(words)':>14}")
for nome, d, r, p in righe:
print(f"{nome:32} {d:13d} {r:13d} {p:14d}")
print(f"{'TOTAL':32} {sum(x[1] for x in righe):13d} {sum(x[2] for x in righe):13d} {sum(x[3] for x in righe):14d}")
# Output (python3 -I costo_skill.py with the path of the skills of the installed plugin, version 5.1.0):
# skill descr.(chars) body(lines) body(words)
# brainstorming 200 160 1522
# dispatching-parallel-agents 106 178 901
# executing-plans 104 66 339
# finishing-a-development-branch 200 247 1034
# receiving-code-review 234 209 895
# requesting-code-review 107 99 375
# subagent-driven-development 85 275 1575
# systematic-debugging 91 292 1486
# test-driven-development 79 367 1480
# using-git-worktrees 196 211 1176
# using-superpowers 159 113 759
# verification-before-completion 225 135 630
# writing-plans 84 148 900
# writing-skills 97 651 3193
# TOTAL 1967 3151 16265
The output says two things. All fourteen descriptions together come to 1,967 characters: that is the fixed cost the catalogue imposes on every session, and it stays small. The bodies, instead, add up to 16,265 words, with peaks such as writing-skills at 3,193: loading them all, always, would be an enormous waste, and that is exactly what level-by-level loading avoids. I ran it twice with identical output; the numbers hold for version 5.1.0 and will change with updates. The level mechanism is explained well in article 02.
An honest note on names: the plugin has no skills called «code-reviewer» or «refactor-cleaner». The review is requesting-code-review, and cleaning up dead code is not a Superpowers skill. When I talk about these two things in the series I mean skills and agents I wrote myself, in ~/.claude/, and I say so where it comes up.
Get Shit Done: plan in files, execute in clean sessions
GSD started as a meta-prompting, context engineering and spec-driven development system for Claude Code. The original repository, gsd-build/get-shit-done, describes the project as the work of TÂCHES and is now archived with a pointer: development continues as GSD Core in the open-gsd/gsd-core repository, which today reaches version 1.7.0 in its own README. I mention it because it is the easiest attribution mistake to make: the project is not owed to a single author under one name or another, and the place to look for the current documentation has changed.
The cycle is the same for every phase of a milestone, and the README describes it in five steps: discuss (capture the implementation decisions before planning), plan (research, decomposition and a check that the plan fits in a clean context window), execute (plans in parallel waves, each executor starting from an empty context), verify (walk through what was built and diagnose), ship. State lives in a .planning/ folder with four reference files, PROJECT.md, REQUIREMENTS.md, ROADMAP.md and STATE.md, plus config.json and the phases/ and research/ folders, as the architecture document shows.
/gsd-new-project new project
/gsd-onboard existing codebase
/gsd-discuss-phase 3 gathers the decisions of phase 3
/gsd-plan-phase 3 research, plan and plan verification
/gsd-execute-phase 3 runs the plans in waves
/gsd-verify-work 3 verifies with you what was built
/gsd-ship opens the pull request and closes the phase
The names are those of the GSD Core command reference, with the hyphen and not the colon you see in older articles: GSD's commands have changed shape over time, which is why, in this series, every command must be re-read against the current documentation before you use it. The block is a schema to adapt, not run: the commands exist only inside Claude Code. The number 3 is the phase you are working on, and if you leave it out /gsd-plan-phase picks the first phase not yet planned.
Two things matter more than the commands. The first is the plan-checker, an agent that reads the plans produced by the planner before execution: the GSD Core architecture document places it in a verification loop with a maximum of three iterations. The second is wave execution: plans are ordered by dependency and the executors in the same wave touch non-overlapping parts of the code, so they can run in parallel. Article 09 and article 11 take them one at a time.
How I used them, and what I got out of it
What follows is a personal account, not a measurement: I did not time or count anything, and I do not want to pass an impression off as a result. I work on a large monorepo that has grown bigger than my working memory. Without a system, the bottleneck was the handover between one session and the next: after a break I had to rebuild the next decision from scratch. The jump came when I started saving decisions and lessons in memory files that the assistant rereads at the start of every session. Pay attention to where that mechanism lives: it is not GSD's but Claude Code's, which has an automatic memory with a MEMORY.md index and one file per topic, covered in article 13.
Two episodes convinced me of the method. The first is a build that ran out of memory during prerendering: treated as an isolated problem I would have fixed it locally and forgotten it; opened as a dedicated phase, with the systematic debugging skill guiding the investigation, it became a written lesson that the assistant finds again when it sees similar symptoms. The second is the translation of the localization files, which in the first batches lost the placeholders: I wrote the lessons learned in a file and every later batch starts by reading it. In both cases the value is not speed, it is that the knowledge stays in the repository instead of in the head of one session.
A third passage concerns the decisions that weigh. When I changed the way the site handles a feature, the decision ended up as a dated entry in the project file instead of in a pull request with a vague title: visible, dated, reversible. And in the launch of a series of public repositories the plan-checker made me separate what depended only on me from what depended on third parties, postponing the second part to a later phase. They are two small examples of what a plan check does better than a distracted reread.
When not to use them
A method that does not state its own limits is advertising. The rules that follow are empirical and personal: I derived them from experience, not from a measurement, and I treat them as starting points.
- Throwaway scripts. If you need to analyse a CSV just once, opening a phase, writing a plan and having it checked costs more than the work.
- Exploratory prototypes. When you do not yet know what you are building, structure slows you down: you need to try things, and the method pays off later, when the prototype can carry its first real user.
- Skills for rare behaviours. A skill has a maintenance cost (a description to tune, a check that it activates): if you need it twice a year, a prompt written on the spot costs less.
- Sub-agents for tiny tasks. Starting a sub-agent has a context cost; for a small change in a single file it is better to make it in the main conversation.
The common criterion is repetition: the tools pay off when the task, or the behaviour you want to encode, will come back. For everything that will not come back, bare Claude Code or the editor you already use is the right choice, and I do not make point-by-point comparisons with other tools because I have not measured their features one by one: comparing what you have not verified is the quickest way to write false things.
The map of the series
The series has two pages introducing the projects and eighteen in-depth articles, plus one article that brings the method together with a concrete case. The articles are divided by theme, and each stands on its own if you know the prerequisites listed at the opening.
- Skills: progressive disclosure, brainstorming, debugging, TDD, code review, dead code cleanup.
- Planning with GSD: horizontal and vertical roadmap, plan-checker, sub-agent orchestration, wave execution, document ingestion.
- Claude Code platform: memory, MCP servers, hooks, work environments, costs and worktrees.
- Integration: debugging with plan-checker and agent and a skill that invokes an agent that executes a plan, closed by the concrete build case.
If you start from zero, the recommended order is that of the list: skills first, because they are the smallest and most verifiable part, then planning, then the platform. The two introduction pages, Superpowers and Get Shit Done, are the shortest route if you first want to understand what this is about. The site also has the Superpowers method and GSD method pages, with downloadable materials.
Frequently asked questions
What are Superpowers and Get Shit Done?
Superpowers is a development methodology for coding assistants, made of skills that activate on their own (design, planning, tests before code, review, systematic debugging). Get Shit Done is a spec-driven development system that divides the work into phases, with plans verified before execution and saved in a .planning/ folder.
Can I use Superpowers without Claude Code?
Yes: the README lists installation for many other environments, including Codex, Cursor, Gemini CLI and GitHub Copilot CLI. The path described in this series, however, is the one for Claude Code, and the skill-loading mechanisms I describe are those of the Claude Code documentation.
Can I use GSD on a project that is already under way?
Yes. The GSD Core README provides the /gsd-onboard command for an existing codebase, and /gsd-ingest-docs builds or updates the .planning/ folder from documents already in the repository, such as ADRs and specifications. Read the current documentation before using them: the commands have changed over time.
How much does it cost to use this method?
I do not say: it depends on the plan, on the model chosen and on how much work you delegate to sub-agents, and model prices change. The official Claude Code costs page explains how to read your actual usage and how to reduce it; article 17 starts from there.
What you can do now
You can tell the two problems apart, behaviour and memory, and you know which of the two tools answers which. You know that Superpowers is a method made of fourteen skills in version 5.1.0, the one tried here, and that the descriptions weigh less than two thousand characters while the bodies are loaded only on request. You know that GSD has moved to a new repository and that its commands must be re-read against the current documentation. And you know when not to use them, which is half of the method.
Sources
- Superpowers, repository README - project definition, installation commands, basic seven-step flow and list of skills, accessed 2026-11-13
- GSD Core, README and documentation (commands, architecture, phase cycle) - five-step cycle, command names, the
.planning/folder, plan-checker verification loop with a maximum of three iterations, accessed 2026-11-13 - gsd-build/get-shit-done, original archived repository - project description and attribution to TÂCHES, pointer to the new repository, accessed 2026-11-13
- Claude Code: Skills - location of the
SKILL.mdfiles and role of the description, accessed 2026-11-13 - Claude Code: Memory - automatic memory with the
MEMORY.mdindex and one file per topic, accessed 2026-11-13 - Measurement in the repository:
python3 -I costo_skill.pyon the skills of the locally installed Superpowers 5.1.0 plugin, run twice with identical output, 2026-11-13
Commenti
Caricamento commenti...
Sign in to comment