Back to blog

Ponytail on GitHub: Make AI Coding Agents Write Less Code

Ponytail is a GitHub skill that makes Claude Code, Codex, OpenCode and about 20 other agents pick the laziest adequate fix. Install, modes, benchmarks, limits.

Nov 1, 2026AINovaTools Team
Ponytail on GitHub: Make AI Coding Agents Write Less Code

Ask a coding agent for a date picker and there's a fair chance you get a new dependency, a 335-line component and tests to match. Ponytail is a GitHub project built to stop exactly that. It's a skill that makes your agent "think like the laziest senior dev in the room": reuse what exists, lean on the platform, write the minimum — and never cut corners on security or validation.

The repo, DietrichGebert/ponytail, is MIT-licensed and has passed 180K stars since it appeared in June 2026. The surprising part is how little is in it. The core is one prompt — a SKILL.md, plus a compact AGENTS.md — with adapters for about 20 agent tools, from Claude Code and Codex to OpenCode, Kimi Code and Gemini CLI. The README's header line sums up the attitude: "He says nothing. He writes one line. It works."

Below: installation per tool, the ladder and modes, what it won't skip, what the benchmarks do and don't prove, and when to switch it off.

The problem: coding agents over-build

Agents are rewarded for "it works," not for "it's small." So they default to more: a new dependency for a few lines of logic, an abstraction "for later," a hand-rolled version of something the browser already does. Each addition looks reasonable alone. Together they're the codebase you dread opening in six months — and you paid tokens for every line.

The README's example is the whole pitch. Asked for a date picker, an agent without Ponytail installs a library or builds a calendar by hand: 335 lines. With Ponytail 5, it finds the project's existing Input component and the browser's native date input and combines them: 10 lines.

Nobody has ever been paged at 3 a.m. by the 325 lines that were never written.

What Ponytail actually is

One prompt, packaged many ways. skills/ponytail/SKILL.md holds the full rule set; AGENTS.md is the compact, always-on version. The rest of the repo is plumbing — plugin manifests, hooks, adapters — that delivers the same text to different agents.

Two consequences. Support is uneven by design: hosts with command support (Claude Code, Codex, OpenCode, Gemini CLI, Devin CLI and others) get slash commands, while rules-file-only tools (Cursor rules, Windsurf, Cline, Copilot Chat) get the always-on ruleset without them. And you can read the entire thing before trusting it. If skills are new to you, our guide on how to use Claude Skills explains how a SKILL.md gets loaded.

Nothing needs configuring. For a different default level there's an optional ~/.config/ponytail/config.json or a PONYTAIL_DEFAULT_MODE environment variable.

One safety note from the README: install only from DietrichGebert/ponytail on GitHub or @dietrichgebert/ponytail on npm. Ponytail never ships .exe or .dll files; any copy that does isn't the author's. A repo this popular attracts impostors.

How to install Ponytail in your agent

In Claude Code, run these as two separate prompts:

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

Other tools, per the repo's INSTALL.md:

AgentInstall
Codexcodex plugin marketplace add DietrichGebert/ponytail, then codex plugin add ponytail@ponytail; trust the two hooks in /hooks
OpenCodeopencode plugin add @dietrichgebert/ponytail
Kimi Code/plugins install https://github.com/DietrichGebert/ponytail, then /reload
Gemini CLIgemini extensions install https://github.com/DietrichGebert/ponytail
Copilot CLIcopilot plugin marketplace add DietrichGebert/ponytail, then copilot plugin install ponytail@ponytail
Cursor, Windsurf, ClineCopy the ruleset into .cursor/rules/, .windsurf/rules/ or .clinerules/
Anything elseCopy AGENTS.md into your repo root

Start a fresh session afterwards (a new thread, in Codex) so the agent actually loads it.

The ladder: how Ponytail picks the laziest fix

The ladder runs after the agent understands the problem, not instead of it: it reads the code the change touches and traces the real flow first. Then it climbs, stopping at the first rung that works:

  1. Does this need to exist at all?
  2. Is it already in this codebase? Use it the way the surrounding code does.
  3. Is it in the standard library or the platform? Use that, unless the project has its own.
  4. Is there an installed dependency for it? Use it — never add a dependency for a few lines.
  5. Can it be one line a reader gets at a glance? Write one line.
  6. Otherwise, write the minimum working code.

The date picker stops at rungs two and three. Our bet is that rung two is where most of the savings hide: agents are oddly bad at noticing that the helper they're about to write already exists three folders over.

Shortcuts get labelled, not hidden. When the agent takes one with a known limit, it leaves a shortcut: comment naming the limit and when to upgrade — say, an in-memory rate limiter that should move to Redis once you run more than one instance. /ponytail-debt later harvests those comments into a ledger, "so 'later' doesn't become 'never'."

Modes: lite, full, ultra, off

Switch with /ponytail lite, /ponytail full, /ponytail ultra or /ponytail off. Plain /ponytail turns it on at your default level, or reports the current one.

ModeBehavior
liteBuilds what you asked, mentions the smaller option in one line, lets you choose
full (default)The full ladder and rule set
ultraAlso pushes back, before building, on any part of the request the need doesn't justify
offBack to the agent's normal behavior

The README pitches ultra as the mode "for when the codebase has wronged you personally." In practice: lite when you're new to a codebase and want to stay in charge, full for daily work, ultra for tickets that arrive with a wishlist attached.

What Ponytail refuses to skip

"Lazy, not negligent" is the line that makes this more than a meme. Some things are never on the chopping block:

  • Validation at trust boundaries
  • Error handling that prevents data loss
  • Security and accessibility
  • Anything you explicitly asked for

New logic with a branch, a loop, a parser, money or security in it gets one small test or an assert-based self-check; trivial changes need none. And every reply ends with a line or two on what was skipped or left unchecked, plus any risk you should know about. That closing note is the most useful habit Ponytail teaches: you always know what you didn't get.

The other commands

  • /ponytail band — a status band above the prompt: cost per task and per turn, tokens, agent time, code reuse, and whether tests passed after the last change. Claude Code only, version 2.1.290 or later; /ponytail band import adds past sessions.
  • /ponytail-review — reviews a diff like the on-call senior dev: bugs, security, load, untested risky code, slow paths and what to cut. Point it at uncommitted or staged changes, a branch or a PR link.
  • /ponytail-audit — the same checks across the whole repo, ranked by importance.
  • /ponytail-debt — the shortcut ledger.
  • /ponytail-gain — the benchmark scoreboard.
  • /ponytail-help — the command reference.

In Codex, skills take a dollar prefix instead, as in $ponytail:ponytail-review.

The benchmark numbers, with caveats

The "Ponytail 5" benchmark ran 39 tasks — including a real FastAPI + React repo — five times each in Claude Code on Opus 5.5, with and without the skill:

MetricWith Ponytail 5
Code written−53%
Time−41%
Cost−26%
Tokens−45%
Risky logic shipped with a test98% (68% without)
Injected bugs caught by tests66% (46% without)
Security task runs passed30 of 30
Blind comparison vs Ponytail 4Won 110 to 67

The security set spans six task families: SQL injection, path traversal, forged tokens, rate limiting, malformed CSV rows and caching.

Now the caveats. These are the author's numbers, on the author's task set, with one model in one harness. The results file is in the repo, but we haven't seen an independent replication. Less code isn't automatically better, either: if rung two reuses a component that's subtly wrong for the job, you inherit the bug at a 10-line discount. Run /ponytail band on your own repo for a week before quoting percentages to your team.

The model changes the math too. On a cheap model such as DeepSeek 4.1 Flash, a 45% token cut saves pennies; the 53% less code you have to review is the part that still pays.

When not to use Ponytail

  • Spec-exact work. A protocol implementation, a payment integration done to the letter, a design-system component that must match the mockup. "Laziest adequate" can drift toward "close enough." Use lite, or off.
  • Greenfield foundations. When the abstraction is the deliverable — a library's public API, a plugin system — a ladder biased against new abstractions fights the job.
  • Messy codebases. Rung two says reuse what's there the way the surrounding code does. If what's there is bad, Ponytail will faithfully spread it.
  • Learning. If you want the agent to teach you how something works, a one-line answer teaches less.

Where it shines is the opposite: prototype sprawl, mature codebases with good components, and reviewing AI-written pull requests.

If a plugin ecosystem feels like a lot for an anti-overengineering tool — the irony hasn't gone unnoticed — ponytail-lite is a single AGENTS.md "without the plugin madness." Another community repo, karpathy-ponytail-skills, merges Karpathy's LLM coding guidelines with Ponytail's ladder.

Ponytail belongs to the same genre as Clean Your TV: a GitHub hit that is mostly a well-written prompt. Still choosing which agent to put it in? See our comparison of AI coding tools like Cursor.

FAQ

What is Ponytail on GitHub?

An MIT-licensed skill for AI coding agents, published as DietrichGebert/ponytail. It makes the agent choose the simplest adequate solution — reuse, platform features, minimal code — while keeping validation, security, accessibility and tests for risky logic. It's free; you only pay for your agent's model usage.

Which agents does Ponytail work with?

About 20. Claude Code, Codex, OpenCode, Kimi Code, Gemini CLI, Copilot CLI, Devin CLI and others install it as a plugin or extension. Cursor, Windsurf, Cline and Copilot Chat load it as a rules file without slash commands, and anything that reads AGENTS.md can use the compact version.

Will Ponytail skip tests or security to save tokens?

No, and that's deliberate. Trust-boundary validation, data-loss handling, security and accessibility are never cut, and risky logic gets a small test or self-check. Whatever it does skip is listed at the end of each reply.

Are the Ponytail benchmark numbers trustworthy?

Treat them as the author's best case, not a guarantee. They're self-reported, from one model on 39 of the author's tasks. The band and gain commands let you measure the effect on your own code instead.

What's the difference between Ponytail and ponytail-lite?

Ponytail is the full package: plugin, hooks, modes and commands. ponytail-lite is a community cleanup of the AGENTS.md alone — one file, no mode switching, no commands. Start with lite if all you want is the ladder.

Tools mentioned in this article