Ponytail

What It Is (confidence: medium)

Ponytail (DietrichGebert/ponytail, 93k stars at capture) is an anti-overbuild skill that makes AI coding agents “think like the laziest senior dev in the room.” Before writing code it forces the agent up a fixed ladder: skip what doesn’t need to exist (YAGNI) → reuse what’s already in the codebase → use stdlib → native platform feature → installed dependency → one line → only then the minimum safe implementation. It runs after the agent understands the problem (reads the touched code, traces the real flow) — “lazy about the solution, never about reading.”

Benchmark Numbers (confidence: medium)

Measured on real headless Claude Code sessions editing fastapi/full-stack-fastapi-template, twelve feature tickets, n=4, Haiku 4.5, scored on the git diff:

Metric	ponytail	caveman	”YAGNI + one-liners” prompt
LOC	−54%	−20%	−33%
tokens	−22%	+7%	−14%
cost	−20%	+3%	−21%
time	−27%	+2%	−30%
safe	100%	100%	95%

• ponytail is the only arm that cuts every metric and stays 100% safe; the “write one-liners” prompt drops a safety guard. Earlier single-shot numbers (80–94% less code) were corrected after issue #126 showed the bare-model baseline padded answers with prose — the agentic −54% mean is the defensible figure.
• The cut is biggest where a real over-build trap exists (date picker 404→23 lines, color picker 287→23, by reaching for native <input>), near zero on already-minimal code.
• Explicitly not a golfing rule: validation, error handling, security, and accessibility are never on the chopping block. A terse reasoning model that spends thinking tokens deliberating the ladder can go the other way (observed on GPT-5.5).

Independent Measurement (JetBrains, 2026-08-03) (confidence: high)

Part 3 of JetBrains’ “token saver” series — the same paired SkillsBench A/B harness used for caveman (Part 1, advertised −65%, measured −8.5%) and rtk-rust-token-killer (Part 2, advertised −60–90%, measured +7.6%). 80 paired tasks, claude-sonnet-5 at medium reasoning, verifier-scored 0–1, ruleset injected via ponytail’s own hooks/ponytail-instructions.js (v4.8.4, commit 16f2980). Measured medians: −15% code, −10.3% cost, −11% time — roughly a quarter to a half of the advertised −54%/−22%/−27%, but the first statistically solid cost saving in the series (cost p=0.004, cheaper on 46/80 tasks). No quality difference detected (65 identical, 9 worse, 6 better — a null result, not a clean bill of health; SkillsBench verifiers only grade task completion, not security/validation/accessibility, so the “100% safety” claim is not tested here).

Installation method decides whether you get anything at all. Installed as a plain SKILL.md in a skills folder, ponytail self-activated zero times across ten sessions — every number in the run comes from the plugin’s SessionStart hook injecting the ruleset. Copying the skill file alone “will very likely measure nothing.”

The cut concentrates where there was room to over-build. Code fell −31% on large baseline builds and ~0 on already-lean tasks. SkillsBench skews to data/analysis/repair work with few front-end over-build traps, making it a conservative test of the code claim — the article “does not refute their −54%” on the vendor’s own task set.

Adoption audited, not assumed: 100% of treatment trials confirmed the ruleset reached the model; 0% of baselines. Small samples lie both ways — the 10-task smoke run said ponytail cut 3% code and raised cost +9.6%, the full 80-task paired run said the opposite.

Implications: independent third-party measurement validates the direction of the savings while cutting the headline to roughly a third, and isolates the binding constraint: ponytail is only effective as an injected plugin, not as a passively-installed skill. The cost saving survives a benchmark the vendor did not choose, on a stronger model, with verifier-scored quality — the strongest independent result in the whole JetBrains series.

Mechanics (confidence: medium)

• Levels: lite/full/ultra/off (default full); per-session via PONYTAIL_DEFAULT_MODE env var or ~/.config/ponytail/config.json.
• Commands: /ponytail (set level), /ponytail-review (delete-list for current diff), /ponytail-audit (whole repo), /ponytail-debt (harvest deferred ponytail: shortcuts into a ledger), /ponytail-gain (benchmark scoreboard), /ponytail-help.
• Subagent injection: ruleset injected into subagents spawned via the Agent tool; scope with PONYTAIL_SUBAGENT_MATCHER regex on agent_type (unanchored, case-insensitive).
• Portability: ships plugin/skill paths for 20+ agents — Claude Code (/plugin marketplace add), Codex, Copilot CLI, OpenCode (opencode.json plugin), Gemini/Antigravity, Qoder, Hermes, Devin, OpenClaw, Cursor/Windsurf/Cline/Kiro via copied rules files, plus a plain AGENTS.md instruction-only fallback. Claude Code/Codex plugins need node on PATH for the two lifecycle hooks (skills still work without it; always-on activation just stays quiet).
• Complements the caveman skill (JuliusBrussee, benchmark control arm): caveman shrinks what the agent says; ponytail shrinks what it builds. Different halves, no overlap.

Implications: ponytail is a behavioral skill — it constrains the implementation path rather than the output format or token budget. That positions it in the skill ecosystem as the “quality/simplicity guardrail” counterpart to token-reduction tools: where headroom/rtk-rust-token-killer compress what reaches the model, ponytail prevents the model from writing code that needn’t exist in the first place. Its honest benchmark correction (single-shot 80–94% → agentic −54%) is a model of self-correction for a field of inflated claims, and it sharpens the token-reduction-is-not-cost-reduction lesson — safety and necessity, not terse output, are the lever.

Open Questions

• 93k stars are implausibly high for a skill created in the same window as this vault’s own capture tooling; star count should be treated as suspect until verified against the repo’s history.
• “100% safety score” measures the benchmark’s defined safety checks only; a complexity review is explicitly “not a security audit.”
• Whether the ladder’s benefit generalizes beyond coding agents (web/data agents have no “native platform” analog) is untested.
• Whether the −54% headline survives a workload dense in front-end over-build traps (SkillsBench under-represents them; the −31% on large builds hints the gap is workload-shaped, not marketing-shaped).

Related

caveman — series Part 1 control arm; measured −8.5% vs advertised −65% crush — agentic coding CLI family member; also consumes the Agent Skills standard skill-authoring-best-practices — ponytail’s multi-agent portability is a concrete instance of that authoring guidance skills-directory-gate — ponytail ships as a skill directory (skills/) plus always-on ruleset headroom — output shaping as an alternative anti-bloat lever token-usage-reduction — the token-cost side that ponytail attacks at the source token-reduction-is-not-cost-reduction — why “fewest tokens” is the wrong goal; ponytail agrees explicitly

Sources

• raw/external/ponytailskill-com-718d054e.md
• raw/external/github-com-ponytail-d8b2056c.md
• raw/external/blog-jetbrains-com-ponytail-skill-claude-tested-b56c8490.md