The Caveman Prompting Myth
I’ve seen this before.
Developers—smart ones, too—get excited about a new trick. "Talk like a caveman," they say. Shorten your prompts. Cut the fluff. Save tokens. Save money. It’s elegant. It feels like hacking the system.
And for a while, it works.
I ran the same test on my own machine last month. Ten tasks. Caveman prompts. Token usage dropped 30%. I told my team we were onto something. We were cutting our Claude Code bill by a third.
Then we scaled.
We hit 86 tasks. The savings? 8.5%.
That’s not a win. That’s a mirage.
JetBrains didn’t just test this. They exposed it.
And here’s the thing: nobody’s lying. The Caveman technique does reduce output tokens. But the real cost? It’s not in the chat. It’s in the reading. The reasoning. The code generation.
You’re not saving on words. You’re saving on whitespace.
The AI isn’t chatting with you. It’s reading your entire monorepo, stitching together a dependency graph, invoking a linter, then generating a migration script that touches six files. That’s where the tokens go. Not in "Generate code" or "Fix this." It’s in the context.
And you can’t Caveman that away.
I’ve seen teams try. They strip every preface. They demand bullet points. They treat the AI like a terminal. And then they wonder why their CI/CD pipeline still costs $2,000 a month.
The AI doesn’t care if you say "Fix the auth flow" or "Please fix the auth flow, thanks." It’s still reading 12,000 lines of TypeScript, 300 JSON configs, and a Dockerfile that’s been patched seven times.
The Caveman prompt is a placebo. It makes you feel like you’re in control.
But the system? It’s already running at full throttle.
SkillsBench: The Only Real Test
So how do you know if a prompting trick actually works?
You don’t guess.
You benchmark.
That’s where SkillsBench comes in.
It’s not a marketing tool. It’s not a blog post. It’s an open-source framework that evaluates how well AI agents use skills—modular, reusable chunks of code and logic—to complete real-world tasks.
JetBrains didn’t just throw a few prompts at Claude Code. They used SkillsBench to run paired, reproducible tests across 86 software engineering tasks.
Each task required skill composition: reading files, invoking tools, generating code, validating output.
And they compared the exact same agent, with the exact same context, with and without Caveman prompts.
The result? No degradation in quality. No slowdown in execution time.
And an 8.5% drop in output tokens.
That’s it.
Now, let me be clear: 8.5% isn’t nothing. If you’re running 10 million tokens a day, that’s $850. Maybe $1,200.
But if you’re running 50 million? That’s $4,250. Still less than the cost of one engineer’s lunch.
And you know what’s more expensive?
The time you waste chasing false optimizations.
The meetings where someone says, "Why are we still paying this much?" And the team spends a week rewriting every prompt.
The developer who stops asking for clarity because they think the AI "should just know."
That’s the real cost.
The Real Culprit: Workload Anomalies
Here’s the kicker.
One task in the benchmark—dependency audit—spiked the cost for both Caveman and baseline runs.
Why?
Because it crossed Claude Code’s long-context pricing tier.
That’s not a prompt issue.
That’s a workload issue.
The AI was reading 15,000 lines of package.json files, resolving transitive dependencies, and generating a security report.
That’s heavy lifting.
And it happened in both versions.
So if you’re seeing cost spikes, don’t blame your prompts.
Look at your tasks.
Which ones are pulling in massive context?
Which ones are invoking external tools?
Which ones are generating code that spans multiple files?
Those are your cost centers.
Not your conversational padding.
What Actually Works
So what should you do?
Stop optimizing prompts.
Start optimizing workflows.
If you’re using AI agents to generate code, ask:
- Are you feeding it the right context?
- Are you using file filters?
- Are you limiting the scope of each generation?
- Are you caching responses?
- Are you batching similar tasks?
Those are the levers that move the needle.
Drona Reddy’s Markdown prompting? Cool technique. But it’s still just a prompt.
It doesn’t change the fact that the AI still has to read your entire codebase.
The real innovation isn’t in how you speak to the AI.
It’s in how you structure its environment.
And that’s where the next wave of AI developer tools is going.
Not in prompt engineering.
In agent orchestration.
The 2026 Reality
We’re in 2026.
AI coding assistants aren’t fancy autocomplete anymore.
They’re agents.
And agents don’t chat.
They act.
They read.
They write.
They invoke.
They fail.
They retry.
They call APIs.
They manage state.
And yes—they consume tokens.
But the tokens they’re burning aren’t the ones you’re trimming.
They’re the ones you’re ignoring.
So if you’re still chasing Caveman prompts?
You’re not saving money.
You’re just distracting yourself.
The real savings aren’t in your prompts.
They’re in your architecture.
And if you’re not building that?
You’re not saving anything at all.
This article was written by Liam Fletcher, a former compiler engineer who still believes the best way to optimize code is to write less of it. He’s currently building a tool that auto-generates agent workflows from commit history. You can find him on X as @liam_fletcher.
