Skip to main content

01 - Claude Code Workflow: Superpowers + Get Shit Done - the practical guide

Superpowers decides how Claude Code works, Get Shit Done decides what gets done and in which order: how I use the two projects together, and when not to.

What do you think about this article?

01 - Claude Code Workflow: Superpowers + Get Shit Done - the practical guide
Claude Code WorkflowPhoto:Jakub ZerdzickiPexels

At a Glance

Superpowers decides how Claude Code works, Get Shit Done decides what gets done and in which order: how I use the two projects together, and when not to.

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.

  1. brainstorming: before building anything, it asks questions to understand what you really want and then restates it so you can correct it.
  2. 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.
  3. writing-plans: it breaks the work into small tasks, each with exact file paths and verification steps.
  4. 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.
  5. test-driven-development: it enforces the red-green-refactor cycle during implementation.
  6. requesting-code-review: between one task and the next, it reviews the work against the plan and reports problems by severity.
  7. 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.

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.

Start with Superpowers Or with Get Shit Done

Sources

Try These Tools

Free developer tools related to this topic.

Commenti

Caricamento commenti...

Sign in to comment

New articles and tools on Telegram too

The Telegram channel flags the site's new articles and tools.

Did you like this article?

Explore other content on the blog or discover my projects