Ponytail: the lazy senior dev inside your agent

You ask an unconstrained agent for a date picker. It installs a library, writes a wrapper component, adds a stylesheet, and opens a discussion about timezones. Ponytail is the skill that makes it write this instead:

<!-- ponytail: browser has one -->
<input type="date">

It puts a specific person inside your agent: the senior dev with the long ponytail who's been at the company longer than the version control, who looks at your fifty lines, says nothing, and replaces them with one.

The ladder

Before writing code, the agent stops at the first rung that holds:

1. Does this need to exist?   -> no: skip it (YAGNI)
2. Stdlib does it?            -> use it
3. Native platform feature?   -> use it      (CSS over JS, DB constraint over app code)
4. Installed dependency?      -> use it      (never add one for a few lines)
5. One line?                  -> one line
6. Only then: the minimum that works

The point isn't to write less for its own sake. It's that the best code is the code never written — every speculative abstraction, every dependency, every "we might need this later" is something a future human decodes at 3am. Ponytail is YAGNI with a hook that injects it on every turn.

The first lazy solution that works is the right one. Climb the ladder only when the rung below provably can't hold the weight.

Why this is a cost lever, not just a style

Less code is fewer output tokens, and output is the expensive side. The project's benchmark — median of 10 runs across Haiku, Sonnet, and Opus — puts numbers on it:

• 80–94% less code than an unconstrained agent
• 47–77% cheaper
• 3–6× faster

…on every model tested. That's not a rounding error; it's the same magnitude as a compression proxy, achieved by simply not generating the bloat in the first place. The cheapest token, again, is the one you never produce.

It's lazy, not negligent

The critical distinction, and the reason it's safe to leave on: ponytail never simplifies away input validation at trust boundaries, error handling that prevents data loss, security, or accessibility. Those are explicitly off the chopping block. And every shortcut it takes is marked in the code with a ponytail: comment naming its upgrade path — so a deliberate simplification reads as intent, not ignorance:

# ponytail: global lock, per-account locks if throughput matters

You always know what was simplified and how to undo it when a real requirement shows up.

Levels and use

/plugin marketplace add DietrichGebert/ponytail
/plugin install ponytail@ponytail

It injects the ruleset every turn at lite / full / ultra, and adds /ponytail-review — which scans your diff for what to delete: reinvented stdlib, needless dependencies, speculative abstractions, dead flexibility. Active every session until you say "normal mode." It ships rules files for Cursor, Windsurf, Cline, Copilot, and Aider too.

Where it fits

Ponytail is the code-output lever, the natural pair to Caveman's prose: lazy code plus terse words is the full output-side cut. And it's not only cheaper — it's a genuinely better default. Most production incidents trace back to complexity someone added that nobody needed; an agent that defaults to the minimum is an agent that ships fewer 3am pages.

In the cost stack it's the cleanest win of all, because it improves the codebase while it saves money. The capstone stacks it with everything else.