The Skill That Teaches You to Stop Guessing Which Skill to Use

The first time I encountered the using-superpowers skill, I assumed it was documentation.

A readme. An introduction. Something you skim once and ignore.

It isn't.

The Skill That Makes the Other Skills Work

obra/superpowers contains 14 specialist skills. There's one for debugging, one for writing plans, one for running parallel agents, one for finishing a branch properly. Each of them is highly specific. Each requires knowing, before you start, that this is the moment to reach for it.

That last part is the problem.

When you're moving fast — and the whole point of agent-assisted development is that you move fast — the temptation is to just start. You describe the task. The agent starts working. You either get what you wanted or you spend thirty minutes unwinding a confident wrong turn.

using-superpowers interrupts that pattern at the front. Not by asking you to read docs. By requiring a skill check before any response, including clarifying questions. Even a 1% chance a skill might apply means the skill gets invoked.

That constraint sounds bureaucratic until you understand what it's actually doing.

Orientation as a First-Class Act

Here's what I noticed after running this consistently: most of the wrong turns I've taken with AI agents didn't happen during execution. They happened in the first thirty seconds.

That's when the frame gets set. The approach gets chosen. The unstated assumptions get locked in. By the time you're three tool calls deep, the context has hardened into something that's difficult to walk back from without starting over.

using-superpowers is a forcing function for orientation. It asks: before anything else, does a specialist skill apply here? Is there already a proven protocol for this class of problem?

If there is, the agent doesn't get to rationalize past it. The skill gets loaded. The pattern gets followed.

This sounds like overhead. In practice, it eliminates a whole category of avoidable rework — the kind that comes from a capable agent solving the wrong version of the problem because nobody stopped to ask which problem this actually was.

The "Even Clarifying Questions" Rule

The instruction is specific: invoke relevant skills before any response, including clarifying questions.

That specificity matters.

Asking clarifying questions is itself a problem-framing act. The questions you choose to ask shape what kind of problem this becomes. If you're about to implement a feature and you should be running test-driven-development, asking "what should this function return?" before invoking the TDD skill means you've already set up a write-code-first workflow without realizing it.

using-superpowers prevents that. The question has to wait until after orientation.

The mindset shift is subtle but real: you move from answer first, check context if confused to orient first, then answer. That's not a small change. That's the difference between an agent that does what you said and one that does what you meant.

What This Builds Over Time

The longer I've worked with specialist skill kits, the more I think the meta-skills are underrated.

There's an obvious ceiling on how much the individual specialist skills matter if you reach for them inconsistently. The debugging skill doesn't help you if you only invoke it after you've already been thrashing for an hour. The worktree skill doesn't help you if you remember it existed after you've already committed experimental code to main.

using-superpowers is the habit that makes the other habits stick.

It trains a pattern of automatic orientation — not just with AI agents but, I've found, in how I approach problems myself. Before I start anything with meaningful stakes, I now ask: is there already a proven approach for this? Is this a category of problem with a known failure mode?

Most of the time, it is.

I now think of using-superpowers as: the skill that makes every other skill arrive on time instead of too late.

---

Part of the Superpowers series — 14 specialist skills from obra/superpowers.