Save tokens
Claude Code and Codex

Every time you send a message, the whole conversation goes with it: your prompts, the agent's replies, and every line of tool output.

So the cost of a session compounds as it grows. Prompt caching cuts price but the tokens still fill the context window.

/compact to summarize the session.

Remember:

• Never paste whole files. Name the path and let the agent read the ranges it needs. The agent reads once; a pasted file gets reread every turn.

Prompt caching reduces your price bill.

The catch is timing. The cache lives for about five minutes, and the clock resets every time it is used. Reply within the window and you get the cheap rate.

• Work in bursts. Reply within the 5 minute window and that saves money. Replies within 5 mins of the last only pay a tenth of the price.
• A long break is a decision point. That is the natural moment to /compact or /clear.
• Short transcripts make cold starts cheap. The caveman skill shrinks the penalty when the cache does expire.

Some setups use a one-hour cache at a higher write price, and the same logic applies with a longer clock.

Caveman mode is a standing instruction that makes the agent's replies drastically shorter without losing technical content.

On ultra you can expect estimate~50% less tokens.

The first two blocks go in the instruction file your agent reads at the start of every session: CLAUDE.md for Claude Code, AGENTS.md for Codex.

## Context discipline

- One task per session. When the conversation drifts to an unrelated task,
  say so and suggest /clear or a fresh session.
- Suggest /compact at natural checkpoints (after a fix lands, before a new
  area), never mid-investigation.
- When you need a file, read targeted ranges yourself instead of asking for a
  paste; a pasted file is reread every turn.
- Keep this file a thin kernel. Topical detail lives in reference files you
  load on demand.
- Subagents are not a discount. A subagent rereads context fresh and pays a
  summarize-back tax; dispatch only for large, genuinely independent scopes.
- Prefer filtered command output over raw dumps (diffs, logs, test runs).

Install this as a skill for me: save the file below, starting at the --- line,
as .claude/skills/caveman/SKILL.md for Claude Code or
.agents/skills/caveman/SKILL.md for Codex. Create the folder if needed, then
load it for prose replies.

---
name: caveman
description: >
  Ultra-compressed reply style. Cuts reply prose sharply while keeping
  full technical accuracy. Load for all prose replies.
---

Respond terse like smart caveman. All technical substance stays; only filler goes.
Accuracy first, brevity second: compress wording, never meaning. If terse risks
a misread, spend the words.

Rules: drop articles (a/an/the), filler, pleasantries, hedging. Fragments OK.
Short synonyms. Technical terms exact. Code blocks unchanged. Error messages
quoted exact.

Intensity levels:
- lite: no filler or hedging, full sentences kept
- full: articles dropped, fragments allowed, short synonyms
- ultra: prose words abbreviated (DB/auth/config/req/res/fn/impl), arrows for
  causality (X -> Y). Code symbols, function names, API names, and error
  strings are never abbreviated.

Auto-clarity: switch to plain prose for security warnings, irreversible-action
confirmations, and multi-step sequences where fragment order could be misread.
Resume caveman after the clear part is done.

Boundaries: code, commits, PR text, and file contents are written normally.
Off switch: "stop caveman" / "normal mode".

Install this as a skill for me: save the file below, starting at the --- line,
as .claude/skills/handoff-audit/SKILL.md for Claude Code or
.agents/skills/handoff-audit/SKILL.md for Codex. Create the folder if needed.

---
name: handoff-audit
description: >
  Draft a self-contained prompt for a fresh session to independently
  verify the current change. The prompt is the only deliverable.
---

When the user hands off work for verification, write ONE fenced markdown block
they can paste into a new session that has zero shared context. Do not run the
audit here or spawn a subagent: independence is the whole point.

Scope is the work on this branch. Capture the repo URL, the branch, and the
commit SHAs (git log --oneline main..HEAD, git diff --stat main..HEAD) verbatim.

Build the prompt from:
- Claims: what changed, what must still hold (the invariants), and why each
  risky call was safe, so the auditor can try to falsify each one.
- Fidelity reference: for a move or refactor, the pre-change git handle
  (git show <base-sha>:path) so they diff old against new instead of
  trusting a summary.
- Checks, each with an explicit pass/fail: no dangling consumers of moved or
  deleted symbols (grep -rw; warn about substring and pointer-comment false
  positives), deleted code was really dead, kept code is still wired, every
  reference site was updated, syntax balances.
- Constraints: what this environment cannot verify (installs, type-checks, a
  dev server) and the real signal that does (CI, deploy log, test suite).
- Output contract: PASS/FAIL per check with file:line evidence, re-verify each
  FAIL before reporting it, fix only real breaks, commit only touched files.

Open with an adversarial role ("skeptical auditor; assume the change is wrong
until your own grep and read prove otherwise") and a grounding line ("ground
every verdict in files you open yourself; do not trust this prompt's summary").
Wrap each part in its own tag: <audit_target>, <claims>,
<fidelity_reference>, <checks>, <constraints>,
<output_contract>.

Once the basics are habit, the next savings come from routing work to the right place. These matter most on big projects and long working days.

Audit before you optimize

Look at where the tokens actually go before changing habits. In Claude Code, /context shows what is filling the window right now: system prompt, connected tools, instruction files, and conversation. Disable connected tools/MCP you rarely use.

Keep your instruction file thin

Your CLAUDE.md or AGENTS.md is reloaded into context every single session, so every line in it is a recurring cost. Keep it as a wiki, and move detailed context into subfiles that are referenced only when the agent needs it.

For memory, using AI Firmware will have the model use its recall command. This points at short wiki-style notes and lets a session pull in only the note it needs. This keeps the always-on CLAUDE.md optimized and lean.

AI-Firmware is my project template built around a short rule-only kernel, a .claude/reference/ index for more detail, auto memory with /recall save, and an AGENTS.md mirror so the same setup works in Codex. Use or clone as a starting point.

Prune connectors and tools you are not using

Tools: every MCP server you connect wastes tokens immediately, used or not. Disconnect servers the current project does not use.

/context will show you exactly what each one costs.

Trim your skills, and drop the ones you never use

Skills: models read a skill's description to decide whether it applies. That context is loaded every session whether or not the skill ever runs. Remove the ones a project does not use and shorten descriptions.

Skill descriptions: keep the trigger words that decide when the skill should fire and cut the rest. Skills on GitHub tend to ship with setup notes, examples, and options that may not apply to your repo, so cutting irrelevant = fewer tokens & better output.

Compress the skill wording the same way caveman mode compresses replies.

When a skill's body is very large, split it into an instruction file: just a rule that points at subfiles that have all the detail, loaded only when needed.

Match the model to the task

Efficiency: Avoid xhigh unless it's needed. Avoid max. Mechanical bulk work should be a cheaper model at reduced thinking.

The default (high) is the sweet spot for most work. Save xhigh for the hardest coding and long agentic tasks.

What a subagent really costs

A subagent starts with fresh context, rereads files your session already read, then spends more tokens reporting what it found back to you.

But the main transcript stays clean. Dispatch subagents for big projects.

Workflows, for jobs that outgrow one context

Claude Code /workflows with Opus on medium thinking is great, for jobs that outgrow one context.

Subagents have fresh context and can bring different perspectives and angles that a single worker may miss.

Move repeatable work into scripts

For deterministic work, have the agent write a script once. Only writing costs tokens; every later run is free & more reliable.

For example I've run python scripts for hours that collect data, and then at the very end the model reviews.

Filter command output before the agent reads it

Shell output is the biggest silent cost: a large diff or test run can dump thousands of lines the agent never needed. Filtering removed measured79.5% of output tokens across 95,821 commands (snapshot 2026-07-20). Per-command numbers and how it works are on the measurements page.

The tool behind those numbers is RTK, an open-source proxy that condenses command output before the agent reads it.

• Stop Hitting Your Token Limit (CoreWise Academy): the same problem worked from the budget side. Audit your usage, cut consumption, downshift models for routine work, and weigh the riskier tactics honestly. Covers caveman mode and output filtering too.
• Claude Code best practices (Anthropic): the vendor's own guidance on context management, instruction files, and workflow.
• RTK on GitHub: the open-source output filter behind the measured figures on this site.