Monospace · CraftNº 005 · Playbook Edition

The Case for
Writing Less Code

Ponytail is an anti-overengineering skill that teaches coding agents to reach for the standard library before the framework — and its corrected benchmark counts diff lines, not promises.

DIFF DISCIPLINE

DietrichGebert/ponytail · MIT · MarkdownBenched — 62 tests, 10 adapters, June 2026

The Premise02

A behavior patch, not a tool — it changes what the agent reaches for first.

Before it writes anything, the agent has to stop at the first rung of a six-step ladder that already solves the problem: skip the work, use the standard library, use the platform, reuse a dependency, write one line, or write the minimum. What lifts it above a YAGNI slogan is the carve-out — five things are never simplified away.

35kstars, mostly Markdown

~6,500lines total

10agent families

0declared dependencies

One skill file · a fallback · two hook scriptsThe Case for Writing Less Code

The Machine03

The whole product is a decision ladder.

0 · Don't build itis the feature even needed? skip the work entirely

▼

1 · Standard libraryreach for what the language already ships

▼

2 · Platform nativeuse the framework's built-in feature

▼

3 · Existing dependencyreuse a library the project already has

▼

4 · One linesolve it in a single line if code is unavoidable

▼

5 · Minimum codelast resort: the least code that works

▼

Never simplified awayvalidation · data loss · security · accessibility · named requirements

Three intensity modes turn the pressure up or downThe Case for Writing Less Code

The Bench04 · Why the plays are believable

What we ran — and the A/B we refused to fake.

On our bench: the repo's 62 unit tests, the eight ladder rules across all ten adapters, and the safety scorers against three planted flaws. What we did not run is a live model A/B — no model credentials on the bench, and we didn't fake one. The headline reduction numbers are the repo's own corrected benchmark, tiered DEMONSTRATED for exactly that reason.

62/62unit tests, our bench

10adapters, one rulebook

3/3planted flaws caught

0live A/B runs — no creds

0 deps~6,500 lines total

The reduction numbers are the repo's benchmark — tiered accordinglyThe Case for Writing Less Code

Play 01Demonstrated An Afternoon

Put every diff on a diet.

The scenario → the move

Your agents solve small problems with large code — a framework where a function would do, a dependency where the platform already ships the answer. Install the skill, hand the agent ordinary tickets, and let the ladder argue for the standard library first.

git clone DietrichGebert/ponytail
# drop the skill in, then read the git diff

The receipt

The repo's corrected agentic benchmark — real Claude Code sessions against twelve tickets, scored by added lines in git diff, not by prose — cut code 54%, cost 20%, and time 27% at a 100% safety rate.

Boundary — turn it off when the task genuinely is architecture.

Scored by lines added, not by the model's own claimsThe Case for Writing Less Code

Play 02Verified An Afternoon

Run one ruleset across ten agents.

The scenario → the move

A team spread across Claude Code, Codex, Cursor, and Copilot drifts into ten different coding temperaments. Install the ladder once; thin adapters carry the same eight rules to every agent family, so your review bar stops depending on which tool wrote the diff.

skills/ponytail/
adapters/  # claude · codex · cursor · copilot · gemini …

The receipt

The ladder's eight rules validated identical across every adapter, and all 62 of the repo's unit tests passed on our bench — one rulebook, ten front doors.

Boundary — the rules are identical, but the effect still rides on each model's instruction-following.

Claude, Codex, and Cursor read one temperament from one fileThe Case for Writing Less Code

Play 03Demonstrated An Afternoon

Keep the guardrail, skip the slogan.

The scenario → the move

A one-line "YAGNI" system prompt looks like a free substitute for the whole skill. It isn't. What you're actually installing is the ladder's explicit carve-outs — validation, data loss, security, accessibility — the rules that refuse to simplify the wrong thing away.

system: "YAGNI. keep it simple."
# ← respectable numbers, no safety carve-outs

The receipt

In the repo's own control run, the bare YAGNI one-liner got respectable reduction numbers — and then quietly dropped a path-traversal guard. The full skill kept it.

Boundary — the one-liner isn't useless; it's just missing the carve-outs that matter.

The slogan is the wrapper; the carve-outs are the productThe Case for Writing Less Code

Play 04Verified A Weekend

Grade your own diffs for bloat.

The scenario → the move

You suspect a codebase is carrying agent-written weight but have no number to point at. Reuse the benchmark's harness and safety scorers as a bloat audit against your own tickets — turn a hunch into a figure you can act on.

benchmark/  # harness + diff-line scorers
./score.sh your-tickets/

The receipt

The benchmark's safety scorers correctly classified good and bad reference implementations across path traversal, SQL injection, and HMAC verification on our bench — the graders can tell a real guard from a missing one.

Boundary — the graders execute generated code; run them only in throwaway environments.

"Our agents overbuild" becomes an audit you can runThe Case for Writing Less Code

The Fine Print09

Quiet scan. Two caveats worth naming.

Clean scan: no critical issues in what ships, no real credentials anywhere; with zero dependencies there's nothing for npm audit to catch.
It writes no code and reads none: a behavior patch, not an analyzer — it changes what the agent reaches for first.
Needs a strong model: the effect rides on instruction-following; on small local models it disappears into noise.
No universal savings: OpenAI reasoning models can cost more, not less — measure before you promise.
Two operational caveats: the missing lockfile hurts reproducibility, and the benchmark's graders run the code they grade — throwaway environments only.

Full report: security scan in the study archiveThe Case for Writing Less Code

The Ledger10 · The forwardable summary

Four plays, priced by evidence.

Play	Tier	Effort	Receipt
01 Put every diff on a diet	Demonstrated	AN AFTERNOON	repo benchmark: −54% code, −20% cost, −27% time, 100% safe
02 Run one ruleset across ten agents	Verified	AN AFTERNOON	8 rules identical ×10 adapters · 62/62 tests pass
03 Keep the guardrail, skip the slogan	Demonstrated	AN AFTERNOON	control YAGNI dropped a path-traversal guard; skill kept it
04 Grade your own diffs for bloat	Verified	A WEEKEND	scorers flag path-traversal / SQLi / HMAC, good vs bad

Tiers: Verified — we ran it · Demonstrated — its own benchmark ranThe Case for Writing Less Code

The Kicker11

Best for halving the code your agents write.

If you run one play tonight, put your next ticket on a diet — install the skill, hand the agent an ordinary backend task, and read the diff. The ladder makes its case for the standard library before you've written a line, and the guardrails stay up while it does.

git clone https://github.com/DietrichGebert/ponytail
# drop the skill into your agent, then diff your next ticket

MONOSPACE · monospacemag.comField-tested reviews of trending repositories

The Case forWriting Less Code

A behavior patch, not a tool — it changes what the agent reaches for first.

The whole product is a decision ladder.

What we ran — and the A/B we refused to fake.

Put every diff on a diet.

Run one ruleset across ten agents.

Keep the guardrail, skip the slogan.

Grade your own diffs for bloat.

Quiet scan. Two caveats worth naming.

Four plays, priced by evidence.

Best for halving the code your agents write.

The Case for
Writing Less Code