How to stop overpaying for Claude Code with Graft, Ponytail, and Caveman

If you lean on Claude Code every day, you have probably noticed two things: it is incredibly useful, and it can chew through tokens and plan limits at an alarming rate. Many power users end up nudged toward Anthropic’s higher tiers, not because they need a smarter model, but because their agent burns through context over and over again.

The good news is that you can push your existing Claude Code plan a lot further using three free tools: Graft, Ponytail, and Caveman. Together, they shrink what Claude reads, what it writes, and how much it talks—without any meaningful drop in code quality.

Why Claude Code burns through so many tokens

Claude, like other large language models, reads and writes in tokens—small chunks of text that roughly map to three-quarters of a word. Both metered billing and flat plans ultimately depend on how many tokens your sessions consume.

The core problem with Claude Code is how its agent loop is designed. Every step in a coding task resends the entire conversation history to the model. When you ask it to fix a bug, it might:

• Search the project
• Open several files
• Follow imports into more files
• Run tests
• Apply edits
• Explain the fix

Each of those actions is a separate request that includes everything that came before it. By the last step, Claude is rereading every tool result and every file snippet from the entire session. Prompt caching can make rereads cheaper, but not free—especially if you are paying per token through the API.

On metered plans, that means a higher bill. On flat plans like Claude Pro or Max, the cost shows up as hitting your 5-hour and weekly usage caps long before the month is over. Anthropic’s official suggestion for people who keep hitting the $100 Max tier limits is to upgrade to the $200 tier—but you can often avoid that by cutting waste instead.

There are three main places to trim:

• What Claude has to read to navigate your repo
• How much code it decides to write
• How many words it uses to explain itself

That is exactly where Graft, Ponytail, and Caveman step in.

Graft: stop Claude from re-exploring your repo every time

Problem it solves: Claude starts every task “blind” and repeatedly explores your repository from scratch, rereading the same files over and over again.

Each time Claude Code kicks off a task, it behaves like a new junior hire who has never seen your codebase. It greps for keywords, opens files, chases imports, and builds a mental map from scratch. Because the conversation history is resent on every turn, all those file contents become permanent passengers in the context window, bloating every subsequent request.

How Graft works

Graft fixes this by creating a persistent map of your repository. Instead of letting Claude re-discover your codebase for each task, Graft:

• Scans your project once
• Builds a graph of files, modules, and relationships
• Stores plain-English notes on what each part does and how they connect

When you ask a question, Graft hands Claude only the relevant slice of that map. The agent can jump straight to the right files instead of rummaging through the entire project every time.

Setup and requirements

Graft is a local tool and is straightforward to install:

1. Install the package via npm.
2. Run graft init in your project root.

The code graph itself runs entirely on your machine and does not require network access or an API key. If you want deeper, natural-language summaries of files, you can optionally connect it to a model provider of your choice.

What the tests show

In its own benchmark, Graft’s creators tested the same Claude Sonnet 5 agent with and without Graft across 162 runs on two projects. They reported:

• ~42% fewer tokens per task
• ~32% lower cost per task
• ~60% faster completion time
• ~93% accuracy in both conditions (no real quality trade-off)

They also evaluated Graft on SWE-bench Verified, a benchmark of real-world bug fixes. On 50 tasks:

• Claude Code alone fixed 27 bugs
• Claude Code + Graft fixed 33 bugs
• On tasks both solved, Graft cut tokens by ~23% and cost by ~19%

These results come from the tool’s creators rather than an independent lab, so treat the exact numbers as directional rather than absolute. Still, the pattern is clear: giving Claude a persistent map of your repo dramatically reduces the tokens wasted on navigation and rereads.

If you are using Claude Code heavily on large projects—especially if you are building complex automations like in end-to-end Claude Code agent workflows—Graft is usually the best place to start.

Ponytail: stop Claude from over-engineering your features

Problem it solves: Claude often overbuilds. It happily constructs entire components and abstractions when a simple native element or existing utility would do.

Ponytail focuses on the code Claude writes. Its philosophy is to make your agent think like the laziest senior developer in the room: do the least work necessary that still meets requirements and keeps security, validation, and accessibility intact.

How Ponytail changes Claude’s behavior

Before writing any new code, Ponytail forces Claude to climb a short decision ladder:

1. Does this feature need to exist at all?
2. Is it already implemented somewhere in the project?
3. Does the browser or platform already provide this behavior?
4. Only if all of the above fail: write the smallest amount of custom code that works.

Non-negotiables like security checks, validation logic, and accessibility are never optimized away. Ponytail only trims unnecessary complexity and custom UI when a simpler, native option exists.

In one benchmark example, Claude Code on its own built a custom date picker averaging 404 lines of code. With Ponytail active, it simply used the browser’s native <input type="date"> and finished in 23 lines.

How to enable Ponytail in Claude Code

Ponytail integrates directly into Claude Code as a plugin:

1. Run a command to register its marketplace inside Claude Code (as a chat message).
2. Run a second command to install the Ponytail plugin.

Setting it up as a proper plugin is important. Independent testers at JetBrains found that if you just drop Ponytail in as a loose skill file, Claude never actually uses it in practice. As a registered plugin, it reliably hooks into the agent’s decision-making.

Benchmarks and trade-offs

Ponytail’s creators tested 12 real feature tasks on a web app using Claude Haiku 4.5. They reported:

• 54% less code generated
• 22% fewer tokens
• 20% lower cost
• All security checks still passed in separate safety tests

JetBrains then ran an independent test on 80 real tasks with Claude Sonnet 5 and found more modest but still meaningful gains:

• 15% less code
• 11% less time
• 10.3% lower cost
• No detectable drop in quality

They called Ponytail the first tool in their series that clearly saved real money. On larger feature builds, code volume dropped by up to 31%; on tasks where Claude already wrote very little, there was almost no change.

There is one real trade-off: results can look plainer. A side-by-side comparison by World of AI found that Ponytail’s versions worked correctly but used native browser controls and default dialogs instead of polished custom widgets. If you want a highly customized UI, you will need to explicitly ask for it.

For many everyday tasks—especially internal tools, admin panels, and early prototypes—those simpler implementations are a win. You get less code to maintain, lower token usage, and a smaller bill.

Caveman: cut the polite fluff from Claude’s replies

Problem it solves: Claude often wraps answers in friendly, verbose explanations. That conversational padding costs tokens without adding much value for experienced developers.

Caveman is a lightweight instruction layer that tells Claude to drop the corporate pleasantries and answer as tersely as possible—like a grumpy engineer paying for their own tokens.

How Caveman works

Instead of changing the code Claude writes, Caveman only targets conversational text. For example, a normal answer to “Why does this React component keep re-rendering?” might include a friendly greeting, a multi-step explanation, and a recap.

With Caveman turned on, the answer becomes something like:

“New object ref each render. Move object creation outside component or use useMemo.”

In the project’s own example, the token count for that answer dropped from 69 tokens to 19. Crucially, Caveman does not touch:

• Code snippets
• Shell commands
• File paths
• Compiler or test output

It only strips the small talk and redundant phrasing around them.

Setup and usage modes

You can enable Caveman with a simple install command or via a Claude Code plugin. Once it is loaded, you get a few intensity levels:

• /caveman light – concise, business-casual answers
• /caveman ultra – extremely short, almost grunt-like replies

When you want normal answers again, you can simply type something like “stop caveman” to disable it.

Realistic savings in coding sessions

Caveman’s headline claim is up to 65% fewer tokens—but that mostly applies to general chat. Real coding sessions are different: most of the tokens come from code edits and tool calls, which Caveman deliberately leaves unchanged.

JetBrains ran an independent test across 86 real coding tasks with Caveman forced on for every reply. They measured:

• 8.5% reduction in output tokens
• No detectable quality loss

Caveman’s own documentation now acknowledges this: large cuts in pure conversation, single-digit cuts in agentic coding workflows.

There is also a useful nuance from a June 2026 research paper called Cavewoman. The researchers found that forcing the model to be brief can cut costs—but compressing your own prompts can backfire. When users wrote very short, compressed instructions, models often responded with longer, more detailed answers, which consumed more tokens overall.

The takeaway: let Caveman shorten Claude’s replies, but keep your own prompts clear and natural. Do not try to “save tokens” by writing cryptic one-liners.

How the three tools stack together

Each tool attacks a different slice of your Claude Code bill:

• Graft trims what Claude reads (repository exploration and context history).
• Ponytail trims what Claude writes (over-engineered code and unnecessary components).
• Caveman trims what Claude says (conversational fluff in replies).

Because they operate on different parts of the workflow, their benefits stack. Nobody has yet published a benchmark with all three enabled at once, but you can approximate the combined impact using the existing tests.

Using the more optimistic numbers:

• Graft’s creators reported ~32% cost reduction per task.
• JetBrains measured ~10.3% cost reduction for Ponytail.

If both held together, a typical task might cost around 39% less. Using Graft’s more conservative 19% cost drop from SWE-bench instead, the combined saving with Ponytail lands closer to 27%—with Caveman’s single-digit reductions on top.

On a metered API key, that could translate to a bill that is roughly a third lower at the end of the month. On flat plans like Pro or Max, where the price is fixed but your time and weekly caps are not, using a third fewer tokens per task means your 5-hour and weekly quotas stretch to cover significantly more work.

If you are building bigger systems or even full AI-powered businesses with Claude—like the workflows described in Claude Code plus Base 44 agency setups—that extra headroom can be the difference between staying on your current tier and being forced up to Anthropic’s next price bracket.

Which tool to start with

If you want to try these tools without overhauling your whole setup, a sensible order is:

1. Start with Graft (for large projects)
If you are working in big repos, most of your tokens are probably going into rereading files and conversation history. Graft directly addresses that and often delivers the largest immediate gain.

2. Add Ponytail (for feature work)
Once navigation is under control, Ponytail helps keep new work lean. It is especially useful if you notice Claude inventing custom UI components, abstractions, or utility layers you never asked for.

3. Use Caveman when you want terse answers
Caveman is easy to toggle and does not affect code quality, so it is a good optional add-on. Use it when you are deep in the flow and want direct, minimal replies, then turn it off when you need more explanation.

Measuring the impact on your own usage

Every codebase and workflow is different, so the best way to know what these tools do for you is to measure. Claude Code includes built-in usage screens where you can see token consumption over time.

To evaluate the impact:

1. Run a typical batch of tasks without any tools enabled and note total tokens and time.
2. Enable Graft and repeat similar tasks.
3. Add Ponytail and run another comparable batch.
4. Finally, toggle Caveman on and off to see how much it helps on your style of work.

Track how often you hit your 5-hour and weekly limits before and after. If you can accomplish the same amount of work using 25–40% fewer tokens, you may be able to stay on a lower Anthropic tier while getting more done.

Stretching your Claude Code plan further

Anthropic has little incentive to reduce your token usage for you. The default agent behavior is convenient but expensive: constant re-exploration of your repo, overbuilt components, and long-winded explanations all push you toward higher tiers.

By layering Graft, Ponytail, and Caveman on top of Claude Code, you effectively fix three design problems yourself:

• You stop Claude from repeatedly rediscovering your codebase.
• You prevent it from building cathedrals when you only asked for a shed.
• You trim the unnecessary essays around otherwise straightforward fixes.

The result is the same plan, the same model, and the same quality of code—but with noticeably more work squeezed into every 5-hour window and weekly quota. For many developers, that is enough to avoid upgrading to the next tier entirely.