The bottom of the ladder: suggest and record

The gentlest mechanism is to change the order of preference before the agent starts typing.

Ponytail works that way. Before every change one question is asked: can this not be written at all, is it already in the codebase, in the standard library, in the platform itself, in an installed dependency. The agent stops at the first rung that holds. There is no prohibition here - there is a strong bias against new generation, inserted before the moment the decision is made.

The next rung is moving state out of the model and onto disk. pipeline.md suggests nothing: it maintains a file. Sixteen stages, six of them marked with a lock that forbids release until they are closed, and closing an item requires writing down exactly how it was verified. A model can forget what it checked; a file cannot.

The difference between these two rungs is fundamental. A bias holds only while the agent walks it. Recorded state holds regardless of whether the agent remembers it: a skip becomes visible, because the file is left with a hole in it.

The middle: answer in advance and move the rule out of the text

The third rung is anticipating exactly how the rule will be broken and closing that phrasing ahead of time.

That is how agent-skills is built. Almost every procedure - twenty-two of the twenty-four - carries a table of typical excuses with prepared rebuttals. The classic one is "I will add tests afterwards". Repeating "write tests" for the hundredth time is useless against it: the model already agrees tests are needed, it is merely deferring them. Only an answer to the excuse itself works.

The technique is precise because it targets the mechanism. A model rarely breaks a rule outright - it finds an explanation under which the rule seems not to apply. A pre-closed phrasing takes that explanation away.

The fourth rung is moving the rule out of the text into a place where it does not need to be obeyed. ECC not only hands out skills but installs hooks: part of the constraints is enforced by the runtime's machinery rather than the model's goodwill. An instruction can be ignored; a hook cannot, because it is not read but fired.

The top: forbid, and then make it unnecessary

The fifth rung is a direct ban on evasion, phrased without diplomacy.

Superpowers keeps a separate meta-skill that activates at the start of any conversation and says literally: if there is even a one percent chance a procedure applies, you absolutely must invoke it, you do not have a choice, and you cannot rationalize your way out of this. The last phrase is the interesting one. It is written not against the violation but against the explanation with which violations are usually justified.

The sixth rung differs from all the others in kind. GSD Core does not forbid skipping steps - it arranges the work so there is nothing to skip. The main session does nothing itself; it spawns subagents and updates state. Each subagent gets a clean window, exactly its own task, and terminates. It cannot ignore five earlier agreements because it does not see them: they live in files, and only what its task needs enters its context.

These are different philosophies, and the difference shows up in the price. The first five projects raise the odds that the agent does the right thing. The sixth reduces the number of situations in which the agent has a choice at all.

Stars do not measure quality here

The numbers in the table above are worth re-reading.

Two hundred and seventy-two thousand stars for Superpowers and eight thousand for GSD Core - while GSD Core is the larger engineering artefact: an npm package, an installer for sixteen runtimes, eighty-one architecture decision records, roughly eight hundred test files. Another sixty-five thousand sit on its archived predecessor, and those are the ones a search turns up.

At the other end, eleven stars for pipeline.md, which solves its problem completely and transfers to any project by copying a file.

Popularity in this field measures visibility, timing and the author's name. It does not measure fitness for your particular work at all, and choosing by it is the worst method available.

One of the six measures its effect

Exactly one project publishes benchmarks with a described methodology, and it is the smallest of them.

Ponytail ran twelve tasks against a live open-source repository, with the same agent with and without the procedure, and published the result: on average 54% less code added, roughly 20% cheaper, roughly 27% faster. It measured separately that the protective checks survive, whereas simply asking for shorter code drops one of them.

Then comes the valuable part. An early version of the benchmark reported 80-94%, the tracker pointed out a flaw in the method, the project agreed, recounted, published the new numbers as the primary ones and kept the old ones with a note. And it named, separately, the model on which installing it makes the work more expensive.

The other five publish no measurements at all. That is not an accusation - measuring this is hard and expensive. But it does mean their benefit is taken on faith, and that is worth remembering while reading any description.

How much of this is software and how much is convention

It is easy to conclude that this whole field is folders of markdown. Counting across fresh clones says otherwise.