caveman vs ponytail vs Chisle: why I'd pick Chisle for Claude Code

If you've looked at cutting Claude Code's token use, you've probably found caveman and ponytail. Both are good. caveman makes Claude talk less. ponytail makes it build less.

I started Chisle as a mashup of the two, and both are credited in the README. Here's why I think it's now the better pick.

1. It gives the shortest answers

Same model, same prompts, only the ruleset changes. Answer length as a percentage of the model with no ruleset (lower is leaner):

	caveman	ponytail	Chisle
Claude Code, 26 prompts	65%	58%	56%
Pi, 6 tasks	56%	49%	37%

Here's one prompt from that set: "Implement an order state machine covering created, paid, shipped, delivered, cancelled and refunded."

• no ruleset: 1,342 tokens, 125 lines, two classes, a custom exception and docstrings
• caveman: 1,140
• ponytail: 842
• Chisle: 450

Chisle's answer is one dict of legal transitions and one method that checks it:

class OrderStateMachine:
    TRANSITIONS = {
        'created': {'paid', 'cancelled'},
        'paid': {'shipped', 'refunded'},
        'shipped': {'delivered', 'cancelled'},
        'delivered': {'refunded'},
        'cancelled': set(),
        'refunded': set(),
    }
    def transition(self, new_state):
        if new_state not in self.TRANSITIONS[self.state]:
            raise ValueError(...)
        self.state = new_state

Same behaviour. A third of the tokens.

2. It doesn't make Claude dumber

The fair worry with any of these tools is that tokens are where the model thinks, so fewer tokens means worse answers. I tested that without an LLM judge:

• 312 maths and coding problems, graded by exact match and hidden unit tests: no ruleset 155/156, Chisle 156/156
• 120 agent runs on real repos, graded by hidden tests: 49/60 vs 48/60

Statistically there's no difference (p = 1.000 on both). Shorter answers, same results.

3. It goes after the part of the bill the others don't touch

This is the big one. When I measured 171 of my own Claude Code sessions, Claude's replies weren't where the tokens were. Tool output was 67.5% of the context: build logs, test runs, giant grep results. And it doesn't get billed once. It rides along with every later request in the session.

caveman and ponytail only shape what Claude writes. Chisle also has a hook that trims big tool output before Claude reads it:

• strips color codes and collapses repeated lines
• keeps the start and end of long output, plus any error lines from the middle
• replaces exact repeats with a one-line note

It never touches Read, Edit or Write, because edits need the exact bytes. On the output it does touch, it cuts about 46%. With npx chisle mcp wrap the same thing works for MCP servers in Cursor, Windsurf, Cline, Kiro, Gemini CLI and others.

There are also a few rules about reading: grep for the symbol first, read only the slice you need, and don't re-open a file that's already in context.

4. It's one install for every agent you use

npx chisle

It finds and sets up Claude Code, Cursor, Windsurf, Cline, Kiro, Codex, Gemini, Copilot, Copilot CLI, OpenCode, Antigravity, Hermes and Pi. Zero dependencies, MIT, and npx chisle --uninstall puts everything back.

5. You can check every number

Every raw transcript behind these tables is committed in benchmarks/results, including the runs where Chisle loses. The main one: on Pi, ponytail's total bill came in slightly lower (59% vs 61%), because the bill also counts hidden reasoning. I'd rather show you that than have you find it.

JayPokale / Chisle

Cut your AI coding agent's token bill on three axes: terse prose, YAGNI-first code, and tool-output compression. Claude Code, Pi, Cursor, Codex, Gemini + 4 more. Zero deps, published benchmarks including the runs it loses.

Chisle

Fewer tokens than caveman and ponytail. No accuracy lost.

Your AI talks less, builds less, reads less, and says more. Like a senior dev who bills by the syllable.

The only tool in this class that publishes the runs where it lost. Here's why.

Built for Claude Code: answers about half as long, shorter than caveman and ponytail · 13 agents · zero dependencies · one command

Chisle is a Claude Code plugin that makes Claude cheaper to run without making it dumber. It cuts what Claude writes: no filler, no hedging, no speculative abstractions, just the smallest code that works. It also cuts what Claude reads: a PostToolUse hook trims oversized tool output by ~46% before it re-enters the context window, where it would be re-billed on every later request. In agent-loop tests Claude with Chisle passes the same tasks as Claude without it. One npx chisle installs…

View on GitHub

If you try it next to caveman or ponytail on your own work, I'd like to hear how it compares.

Comments

[Skillselion]

Agent is in SAFE_TOOLS, and the header of hooks/chisle-compress-output.js names subagent reports as a target, but in Claude Code they never get trimmed. The hooks docs say a foreground Agent call's tool_response carries the report in content as an array of text blocks. rebuildResponse only rewrites a plain string or a string-valued stdout/output/content/text/result, so for that array it returns null and the hook prints nothing. A 400-line, 28K-char Agent payload run through the file confirms it: processPayload shrinks it to about 7K, rebuildResponse returns null, and the same text as a Bash payload comes back rebuilt.

That may be the better outcome, since a review subagent's findings ("missing null check on Y") would not match the salvage regex anyway. Was the skip intended, and did any of the 120 runs delegate to subagents?

[Matthew]

i run ponytail rn and section 3 matches what i found. one audit of my codex sessions showed whole-file Get-Content reads alone dumped 208 MB of output. does the chisle hook catch big file reads like that or mostly build and test logs