capybaraa

Capybaraa

The chillest senior dev in the swamp. Doesn't panic, doesn't over-build. Asks first, ships clean, leaves.

~20% less code than a bare agent, fully complete and 100% safe on the adversarial tier · plus the questions ponytail skips

You know the type. Unbothered, has seen every framework rise and fall and didn't migrate to any of them. You hand over a vague ticket and fifty lines of someone's first draft. He reads it, asks the two questions that actually matter, draws a little box-and-arrow on a napkin, and replaces the whole thing with the part you needed.

Capybaraa puts that habit inside Claude Code: ponytail's lean discipline plus a few things it skips. Ask the deciding question before building the wrong thing, pick the right data structure, write fewer comments, and sync the docs after a change. The ruleset stays tiny on purpose, a plugin that preaches lean while injecting a wall of rules every turn is the irony it avoids.

Before / after

The ticket: "add user settings persistence."

Claude can already ask good questions here, that's what plan mode is for. But in a plain run it tends to guess the spec and start building, and you find out it guessed wrong once it is written. In our benchmark, on a ticket like this the bare agent wrote ~300 lines of a settings panel nobody specified; capybaraa wrote zero and asked first.

The asking is Claude's; capybaraa's specific add is the ASCII sketch on the options. When it asks, it draws the choices so the tradeoff is obvious at a glance (unless the choice is shapeless and a sketch adds nothing), and it leans on asking the deciding questions even outside plan mode rather than guessing:

🦫 two questions before I touch code:

   ┌── settings ──┐
   │ theme        │   store where?   local / your API / both
   │ language     │   per-device, or synced to the account?
   └──────────────┘

   1. just these two fields now, or more coming?
   2. per-device, or synced?

   edge cases I'll handle: no-JS fallback, unknown saved value, first load.

Then it builds the smallest thing that fits your answers and stops. No invented spec, no files you didn't need, nothing left half-done. The rest is plain lean: reuse what's there, the right data structure, few comments, and a sync of the docs after.

That is the whole pitch: ask when it's ambiguous, build lean, leave it clean. The rest of this README is how it does that, and the numbers that show it.

Numbers

We measured it instead of asserting it. The agentic benchmark runs real headless Claude Code sessions (claude -p) in throwaway workspaces and puts capybaraa next to its honest peers: a bare agent (no plugin), caveman (a prose-compression skill), and ponytail (the pure-minimal plugin, loaded live). Same model, same task, same seed; the only change is the arm.

vs the bare baseline	lines of code	output tokens	cost	time	complete	safe
caveman	116%	100%	107%	100%	3/3	100%
ponytail	79%	97%	106%	102%	3/3	100%
capybaraa	77%	109%	113%	102%	3/3	100%

Read it straight, no spin:

1. capybaraa writes the least code, and stays complete and safe. At 77% of the bare agent's lines it is the leanest arm, a hair under ponytail (79%) and far under caveman (116%), while scoring fully complete (3/3) and 100% on the adversarial safety tier. The saving is real bloat removed, not a dropped feature: most of it is feat-palette, 84 lines against the bare agent's 138.