AI Agents

Can a Few Lines of a Skill Really Change an AI?

·8 min read·한국어
ContentsThree answersSame situation, four scenesPlanningReviewDebuggingInvocationWhere I think they splitWhich one to pickSkills moving out of the textReferences

On November 7, gstack deleted its own debugging skill, /investigate. The reason is in the CHANGELOG, in numbers. In a preregistered eval, Opus 5.5 told to use /investigate passed 50.0% of trials on 18 real bug-fix tasks. With no skill it passed 47.2%. The 2.8-point difference was below the 10-point lift the eval could detect, and a passing fix cost about 43% more.

The result of gstack's /investigate eval. Two pass-rate bars at the top are nearly the same length: gray 'no skill' at 47.2% and teal 'with /investigate' at 50.0%. On the 'difference' axis below, a teal dot sits at +2.8 and its 95% CI runs from −5.8 to +11.4, across zero. An orange dashed line at +10 is labeled 'smallest lift this eval could detect: +10'. Below that: 'cost of a passing fix: about 43% more'. Source: 18 real bug-fix tasks × 20 trials, Opus 5.5, gstack CHANGELOG v1.98.0.0 (2026-11-07).

gstack's answer to the question in the title was that text alone doesn't change much. The week before the deletion shows how it got there. On November 2 it dropped the skill's five-phase procedure, because across 46 sessions the skill loaded every time and the model followed none of the steps. According to the November 6 entry, the skill text alone got the step 'no fix before a root cause' followed 0 of 46 times, and gstack added an opt-in hook that blocks source edits until a root cause is written down. The next day the skill itself was gone.

I don't read that as skills being useless. I read it as a sign that the work skills do is moving out of the text.

Skill bundles have answered this problem in different ways. So when you hand them the same bug, each one tells the agent to do something different. pstack sides with execution evidence and doesn't trust plans. I have gstack and superpowers installed myself, so I wanted to know where the bundles part ways.

Three answers

superpowers: stronger text. superpowers chose to write its instructions harder. Its debugging skill, systematic-debugging, opens with a law in capital letters.

## The Iron Law

NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST

Whether to call a skill isn't left to the model's judgment either. using-superpowers, read at the start of every conversation, says If you think there is even a 1% chance a skill might apply to what you are doing, you ABSOLUTELY MUST invoke the skill. and lists the excuses for skipping it in a table, to block them in advance.

gstack: roles, then measurement. gstack's README calls it a virtual engineering team. It splits roles such as CEO, eng manager, designer, QA lead and security officer into skills. As above, it has lately attached hooks to steps the text couldn't hold, and started measuring effects with evals.

pstack: less text, more structure and execution evidence. pstack has 24 principle skills, and one of them, encode-lessons-in-structure, takes on this problem directly. When you catch yourself writing the same instruction a second time, Encode the rule as a lint, metadata flag, runtime check, or script instead of more text. The bundle blocks the model from calling almost any of its skills on its own, and in review it keeps only findings a run has proven.

Two rows comparing who calls the skills. The top row, 'superpowers · the model calls skills', goes 'request arrives (fix this bug)' → 'at chat start, using-superpowers' → a teal-highlighted 'even a 1% chance, MUST invoke' → 'systematic-debugging', with the note 'the description is the trigger. the model reads it and picks on its own'. The bottom row, 'pstack · you call skills', goes an orange-highlighted 'you type /poteto-mode' → 'picks a playbook, bug fix' → 'only when a step calls for one' → 'how · why · architect …', with the note '57 of 58 SKILL.md files set disable-model-invocation: true'.

pstack isn't a standalone repository. It's the pstack/ folder inside cursor/plugins, Cursor's official plugin repository. The author is Lauren Tan, who goes by poteto.

There are 58 SKILL.md files: 34 general skills and 24 principle skills, one principle each. The user only needs to remember one of them. poteto-mode reads the request, picks one of 23 playbooks, and copies that playbook's steps verbatim to the top of the todo list. The other skills and principles get called when a step needs them.

pstack's structure from top to bottom. At the top left, an orange box 'you type it /poteto-mode' points to an orange box 'poteto-mode · the one entry point (reads the index of 24 principles, matches the task to a playbook)'. Below it, the box 'one of 23 playbooks' says 'its steps are copied verbatim to the top of the todo list' and holds the chips bug fix, feature, prototype, refactoring, perf, shipping, babysit and eval, plus '+15 more'. At the bottom, '34 general skills (called when a step needs them)' holds how, why, architect, interrogate, arena, swarm, tdd, unslop, reflect and teach, and '24 principle skills (one principle per skill)' holds fix-root-causes, prove-it-works, laziness-protocol and never-block-on-the-human. A note underneath reads 'subagents spawn as poteto-agent and read the same SKILL.md first'.

57 of the 58 carry disable-model-invocation: true in their front matter. The model can't call them from their descriptions. They run only when a person types them or when poteto-mode calls them for a step. The one exception is setup-pstack, which helps you pick models.

Same situation, four scenes

The four scenes below compare the four bundles whose instructions differ most clearly: pstack, gstack, superpowers and mattpocock/skills.

A grid of four scenes by four bundles. Columns are pstack (highlighted in orange), gstack, superpowers and mattpocock; rows are Plan, Review, Debug and Invoke. Plan: pstack 'no separate plan skill, forks: run a prototype, plans only on request'; gstack 'role-based plan reviews: office-hours, CEO; eng via autoplan'; superpowers 'approved design doc → plan → build, no code before it'; mattpocock 'grill-me, a relentless interview on the plan'. Review: pstack 'models try to break it, unproven findings dropped, no fixes'; gstack 'specialist subagents + adversarial pass, then fixes them'; superpowers 'a reviewer per task, never gets the session history'; mattpocock 'standards and spec, two parallel subagents'. Debug: pstack 'repro → binary search, every shipped line has runtime evidence'; gstack '/investigate cut after an eval showed no gain, 11-07'; superpowers 'Iron Law, no fixes before a root cause'; mattpocock 'feedback loop first, a signal that goes red on this bug'. Invoke: pstack '57 of 58 block model invocation, you type /poteto-mode'; gstack 'router skill + Use-when descriptions + opt-in routing hook'; superpowers 'even a 1% chance means you MUST invoke, checked every chat'; mattpocock '24 of 39 block model invocation, the rest model-picked'.

Planning

This is where they differ most. superpowers has a person approve before any code. The brainstorming skill lists the steps you must take, in order, before implementing.

1. Lay out the approaches in a message of their own, and have your
   human partner pick one (see Lay out the approaches).
2. Write the design doc, short or full (see Size the Work).
3. Get their approval of that doc.
4. Invoke the superpowers:writing-plans skill.

pstack has no separate planning skill. The README says that if you do want a plan, /poteto-mode covers it, but it's not a default. Instead, poteto-mode makes the agent classify a fork before asking the person about it.

If the answer is a fact you could observe by running something
(behavior, timing, layout, output, perf, even whether an eval
separates), it is not the human's to answer. Sketch it via the
Prototype playbook (`playbooks/prototype.md`) and let the result decide.

Both bundles start from 'don't guess'. superpowers replaces guessing with a person's sign-off, and pstack replaces it with a run.

gstack hands planning to roles: office-hours asks YC-style forcing questions, and plan-ceo-review takes the CEO's view. mattpocock/skills' grill-me has a one-line description: A relentless interview to sharpen a plan or design.

Review

pstack's interrogate sets several models against a change as adversaries. The brief each adversary gets shows the bundle's character best.

Break this change. Prove each finding with a run against the real code,
such as a failing test, a repro script, or command output that shows the
wrong behavior. [...] Leave out anything you did not run. That covers
style, naming, structure, and risks that need a future change to matter.
No findings is a valid result.

Any finding not shown by a run is dropped, style and structure included. The surviving findings are rerun to confirm, and nothing gets fixed (Report the findings. Do not apply fixes.).

gstack's review dispatches specialist subagents, runs an adversarial pass, and then in its Fix-First Review step fixes what it found, asking the user only about the findings that need a call. Both are adversarial reviews, but pstack reports only what's proven, and gstack goes on to fix.

Debugging

pstack's bug-fix playbook puts its core in one paragraph.

Be scientific. Every shipped line traces to runtime evidence.
Belt-and-suspenders that "might help" is a hypothesis, not a fix.
It does not ship. When evidence refutes a hypothesis, revert what
it motivated. The smallest change the evidence justifies ships,
nothing more.

The agent reproduces the bug itself, forms hypotheses, and rules them out one at a time with runtime evidence, taking the split that cuts the most remaining space first.

superpowers asks for the same thing through the Iron Law above. mattpocock/skills' diagnosing-bugs takes the position that once you have a signal that fails on this bug, you will find the cause. And gstack deleted its skill for this scene. Per the CHANGELOG, bug reports now get fixed directly: one read-only check of the cause, and if that isn't enough, a focused test that fails on the bug before any edit, then the fix.

Invocation

The flow diagram above is this scene. superpowers calls a skill on a 1% chance, and pstack blocks automatic invocation for nearly every skill. mattpocock/skills sits in between: 24 of 39 set disable-model-invocation: true, and the model can pick the rest. gstack routes requests to the right skill with a router skill and, if you turn it on, an opt-in routing hook.

gstack's CHANGELOG has a measurement for this scene too. The November 3 entry says that, untold, Opus 5.5 never opened /investigate in 252 trials. So gstack rewrote each skill description to open with a 'Use when …' sentence. Bundles that want the model to call skills on its own keep refining description text. pstack sidestepped the problem by having a person call them.

Where I think they split

I'd say the differences across the four scenes come down to one question: what do you hold the agent with? superpowers holds it with stronger text, gstack with roles, measurement and hooks, and pstack with execution results and structure.

gstack's record shows at least one thing. In that measurement, writing 'find the root cause first' in a SKILL.md didn't change what Opus 5.5 did. That's the same kind of sentence as superpowers' Iron Law. gstack's eval measured gstack's skill, of course, so it doesn't tell us superpowers would get the same result. Still, it seems clear that whether a sentence changes behavior is something you have to measure.

pstack looks to me like a bundle that answered this question differently from the start. Instead of asking for compliance in text, it checks compliance with a run. A review finding stays only with a run behind it, a bug fix ships only with runtime evidence, and a repeated instruction becomes a lint. The principle skills are one short rule each, so the model has less text to read in the first place. As far as I could find, though, pstack hasn't published an eval showing its approach works better either.

Which one to pick

What follows is my reading of the sources.

  • superpowers, if you want a person to set direction. Getting a design doc approved before implementation is the default flow. In exchange, skills step in often and on their own.
  • gstack, if you want role-based review through to deploy in one bundle. It has skills for review, QA, security and shipping, and lately it measures each skill to decide whether it stays. Setup needs Bun, and its SKILL.md files run long.
  • mattpocock/skills, if you want to pick only the skills you need. These are small skills that don't take the process from you.
  • pstack, if you want results checked by a run. It's built to keep only verified work even when many agents run at once. In exchange, it doesn't ask a person to confirm plans by default, and it assumes you'll mix several models. If adopting all of it feels like a lot, you can try a single skill such as /interrogate.

Skills moving out of the text

Can a few lines of a skill change an AI? As far as I could find, the most direct published measurement so far is gstack's /investigate eval, and its answer was that those lines didn't. gstack moved toward hooks and evals, pstack toward human invocation and execution evidence. Nobody has yet measured which works better under the same conditions.

References

pstack

gstack

superpowers

Other skill bundles

X

Hacker News

GeekNews

Cover photo: Jan Antonin Kolar on Unsplash.