Save your AI tokens with this super (skill|prompt|style|etc.)!
TL;DR for the bots (humans, scroll on)
Do Token-Saving Skills and Prompts Cut LLM Costs? Chat Is 0.7% of the Tokens
Measured across 62 coding-agent sessions on a Go monolith, chat messages accounted for 0.7% of the 1.62 billion total tokens. The bill is dominated by cache re-reads of the baseline system prompt and tool schemas, tool results, and injected context, so the savings have to come from the harness rather than from shorter prompts.
I’ve seen lots of variations of the same idea: cut token usage by using a skill, prompt, output style, extension, hook, etc., and people star such repos, upvote the posts, even share them on LinkedIn, so they should work, right? RIGHT?!
Hi there,
The internet is lying to you, but let me be your savior and bring the scroll of truth.
“WHOAH! How is that even possible? There are so many options for the same thing, they sure should work, otherwise who are the people promoting them?”
Turns out, they don’t work, because all those “tricks” target literally the cheapest item on the bill: chat messages.
I’m pretty annoyed right now, because too many “cut-your-tokens” salesmen got to me today, so this post will just show you an example of actual usage during regular Go backend development work, using stats from actual agent sessions.

The answer: 0.7%
Usually I give you some clearly provocative take, joke around, and slowly explain the point, reaching the climax in the conclusion at the end of the blog post, but I see that in AI slop you start with the punchy line and give the answer first, so in a post where half of the content is tables of AI-generated stats, who am I to be a rebel?
The answer: 0.7% (11.3M of the 1.62 billion total tokens of the project described below) are chat messages, exactly what you can optimize with all those magical super duper tricks. “Tokens are not money?” - then gimme spare 1.62b tokens ;)
Satisfied? Then have a nice day!
The example
Currently I’m working on a big project: refactoring + bugfixing a Go monolith. At the moment of writing, the whole project is 62 agent sessions.
The sessions are divided into 4 categories:
- Discovery: 6 sessions, preparing a discovery doc, investigating the current state and potential improvements. Basically “hey, I have an idea: rewrite
subsystem scattered among the different parts of the monolith into a single place and make it nice”, and then you try to catch members of all other teams to figure out how to align the idea with them and not break anything, turning the results of all those discussions into a discovery doc (read: epic) and then manageable chunks (read: tasks). - Planning: 24 sessions. Basically agent’s plan mode on a single chunk of work.
- Implementation: 29 sessions. This is where code is generated, moved, and tool calls fire every second.
- Other: 3 sessions. Random stuff related to the project that doesn’t fit into “just planning” or “just implementing”.
And the stats of raw tokens for each category (cache writes in the second table):
| Category | IN | cache reads | OUT |
|---|---|---|---|
| discovery | 3k | 95.6M | 957k |
| planning | 8k | 562.2M | 4.7M |
| implementation | 11k | 894.2M | 5.9M |
| other | <1k | 1.8M | 22k |
| ALL | 22k | 1,553.7M | 11.6M |
Now, the most interesting part: stats by type:
| Category | Written once / cache write | Total (with cache re-reads) | Share |
|---|---|---|---|
| chat in (you) | 4k | 83k | <0.1% |
| chat out (agent) | 1.3M | 11.3M | 0.7% |
| thinking | 3.9M | 105.4M | 6.5% |
| tool calls out: args | 6.4M | 158.1M | 9.8% |
| tool calls in: results | 16.2M | 450.5M | 27.9% |
| baseline | 9.2M | 475.7M | 29.4% |
| injected | 12.3M | 363.3M | 22.5% |
| compaction | 1.3M | 52.6M | 3.3% |
| total | 50.7M | 1,617.0M | 100% |
- baseline: system prompt, tool schemas, AGENTS.md, and first prompt (read: harness)
- injected: extension outputs, RAG matches, harness reminders, etc. (read: harness)
- compaction: summary and re-attached files after the 74 compactions
- token numbers were extracted from the harness transcripts and provider’s responses
A bit unexpected, right? The “be concise” tricks literally optimize the cheapest part.
Note: the 0% chat in (you) may be different for you, because of the way I work with the agent in this project: each session type has its own skill (part of baseline), and all the decisions and instructions are in the tasks (agent reads them, so they are part of tool calls in: results), so my prompts were like /discovery <decisions-path>, /plan <TASK-ID> or /implement <plan-path>. Don’t mistake prompt length vs prompt content: in this project prompt content is in discovery docs and tasks.
Conclusion (the real one)
The stats above are pretty clear: there is no point in optimizing chat, but there is huuuge room for improvement in the approach and harness (baseline, injected, tool calls categories), because together they carry about 90% of the tokens.
How can you optimize them?
Session per task
Do you need to plan work? Start a session, do the planning, end the session. Implementation goes into the next one: saving on cache re-reads (bonus: it also keeps the “smart zone” (opens in new tab), see the overlooked bonus part for the details).
Compact mid-session
Cache re-reads are costly, so compacting mid-session cuts your bill by turning, say, 100k tokens that are re-read on each tool call into 10k (yes, they are still re-read, but now every go test costs you 10x less in cache re-reads).
For example, I plan work (during planning sessions) into phases, so each plan is divided into 2 or more self-contained blocks. After each phase I do compaction. That allows you to save tokens (does your agent really need the full content of some throwaway script it did at the start of the session in the context? Not really), and also keeps the context clear of non-relevant info.
Choose harness wisely
By choosing a proper harness and tweaking it to your needs, you can achieve a lot. Yes, in this project I do not use my regular (Oh My) Pi setup, because of the project owners’ requirements, but I chose OMP (opens in new tab)/Pi (opens in new tab) for my own setup exactly because of these stats.
For example, OMP’s read tool manages limit/offset automatically, so the agent asks for a range of a 100k-token file and gets that range, and it gives AST summaries from the code files, so the agent gets what really matters instead of 300 lines of outdated comments. Raw content comes back when the agent deliberately asks for it.
Even if you are locked into proprietary Codex/Claude Code/etc. and can’t do much with the harness itself, there are still options for improvement, like replacing the default huge system prompt with a short one (stop worrying about the tool schemas: they are delivered separately, so you could just name the tools briefly in the custom system prompt), or optimizing AGENTS.md files (btw, I have a Write AGENTS.md skill, how convenient!).
(Un-)related posts about AI
AI, SI, AGI, ASI, LLMs, and other buzzwords from the position of a backend engineer already tired of ‘Dear colleagues, we are AI-first now!’