For Claude Code · Windows · WSL · Linux · macOS
Claude Code re-sends your CLAUDE.md on every single turn — and it follows @imports.
That is your context floor: the tokens you pay before any work happens, on turn 1 and on turn 57. Most people have never measured it. The audit is free and takes sixty seconds.
the status line, every turn
Opus 5 | ctx 377k/1M (38%) 300k+ · /clear or /compact | 5h 6% | 7d 59%
└ 38% of the window looks fine. Anthropic's own panel flags 150k.
Step one
Find out your own number
Two scripts, MIT-licensed, public on GitHub. They read files and print. They write nothing, send nothing, and ask for no email address. Run them before you decide whether any of this is worth paying for.
what the context audit prints
=== Per-turn fixed context overhead === Estimated at 4 characters per token. Paid again on EVERY turn. @imports followed. ~/.claude/CLAUDE.md 2106 B ~ 526 tok light ↳ @~/.claude/claude-lessons-learned.md 56859 B ~ 14214 tok heavy Fixed overhead per turn: ~14740 tokens over 50 turns that alone is ~737000 tokens ACTION: this is worth trimming. Every 1,000 tokens you cut here saves 1,000 tokens on every turn of every session.
Output from the machine this was built on, 12 September 2026, Claude Code 2.1.269. Your number will be different — that is the point of running it.
The finding
A 2 KB file that cost 14,740 tokens a turn
The audit called that CLAUDE.md light — 2 KB, about 526 tokens. Line 9 was an @ import pulling in a 57 KB lessons file. Claude Code follows imports. The first version of the check did not, so it reported green.
One machine, one configuration, measured — not a typical result and not a promise. Over a 50-turn session that floor is roughly 737,000 tokens. About 685,000 of them no longer have to be re-sent, because 14,740 a turn became 1,036. Every thousand tokens cut here is cut from every turn of every future session, which makes it the only change in the runbook that pays back permanently.
Why it compounds
You are not paying for your question. You are paying for the thread.
Every turn re-sends the whole accumulated conversation. It shows up as cache reads — cheaper per token, which is exactly why the number gets large without anyone noticing. Here is one real session, measured from its own transcript.
Nothing careless happened. Three unrelated workstreams ended up in one thread that was going well, so it never ended. The context floor is the part of that you can fix once and never pay again.
What the installer changes
Three keys. Named, with reasons.
| Key | Value | Why |
|---|---|---|
| model | opus | /model in a session never persists. Without a pin you drift back to whatever was last written to any of eight precedence layers. |
| statusLine | {type,command} | Model, context and subscription meters on every turn at zero token cost. Written as a bare string it installs cleanly and does nothing. |
| autoCompactEnabled | true | Summarize a long thread instead of re-sending it verbatim. |
And four it deliberately does not set
| Key | Why it is left alone |
|---|---|
| effortLevel | Pins reasoning depth on every session. Thinking was 34,016 of 15,594,557 tokens — 0.2%. Lowering answer quality across the board to save a rounding error is a bad trade. Use --effort per task. |
| autoCompactWindow | Units unverified — a fraction or a token count, depending on the source. Not written until that is settled against the binary. |
| disableBundledSkills | Only helps if you do not use them. Turning off something you rely on costs more time than the tokens are worth. |
| autoMemoryEnabled | Same reasoning. |
Permissions, plugins, hooks and MCP servers are never touched. Every run writes a timestamped backup and prints the one-line rollback command.
What you watch
Three monitors, zero tokens
Claude Code pushes a status object to a script of your choosing on every turn. Reading it costs nothing, and you never have to ask Claude how much context it is using — which never worked anyway.
Context, in tokens
Absolute, not percentage
A million-token window makes 377k read as a reassuring 38%. That is a warning system telling you everything is fine at exactly the moment it stops being fine.
Model, asserted
Shouts on mismatch
Shows the model actually serving the session and alarms when it is not the one you pinned. A stale model key in any repo silently beats your picker.
Rate limits
5-hour and 7-day meters
Your subscription windows, live in the terminal, from rate_limits in the same payload. The number that tells you whether Thursday is going to be a problem.
| Context | Band | What the status line says |
|---|---|---|
| under 150k | ok | nothing — carry on |
| 150k – 299k | watch | past 150k · each turn costs more |
| 300k – 499k | act | 300k+ · /clear or /compact |
| 500k and up | act | 500k+ · /clear now |
Thresholds are absolute because Anthropic's usage panel flags >150k context as the expensive zone — 15% of the window. Percentage bands show green there.
Before you buy
Three things this does not do
On Pro and Max it does not lower a bill. Those are flat-rate subscriptions — there is no per-token bill to shrink. What removing fixed overhead buys you is more turns inside the same 5-hour and 7-day windows, and fewer sessions that hit a wall mid-task. A dollar figure is only honest for API, Console, Bedrock and Vertex users, who are billed per request.
Anthropic already ships part of this. Claude Code has /usage, /status, /context and the Usage and Stats panels. What is added is per-turn fixed overhead separated from session totals, CLAUDE.md sized through its imports, and warnings in absolute tokens while you work rather than in a panel you remember to open.
It cannot configure a browser session. ~/.claude/settings.json governs Claude Code on one machine. It cannot reach claude.ai. The 5-hour and 7-day meters it reports are the same plan windows claude.ai shows you, because it is one shared pool — what the terminal adds is seeing them without leaving the terminal. Under managed enterprise policy the model pin is overridden too. The context and status-line halves still apply.
Fair questions
What people ask before buying
| Question | Answer |
|---|---|
| I could write this myself. | You could. Establishing the finding took a full session of reading the binary, and six claims in the first write-up turned out to be wrong. You are buying the corrections and the maintenance, not the bash. |
| Will it break my setup? | It backs up, merges, re-reads what it wrote, renders a real status line to prove it took, prints the diff and prints the rollback command. Run it with -AuditOnly first and it changes nothing at all. |
| Is it safe to run a one-liner against my machine? | Every script is readable plaintext. Releases are checksummed, and the audit half is public on GitHub under MIT — read it before you run it. |
| Does this violate Anthropic's terms? | It writes documented settings in your own config file, which is what that file is for. No affiliation with Anthropic is claimed or implied. |
| I'm on Max. I don't pay per token. | Correct. You pay in rate-limit windows instead, and the same overhead removal buys you more turns before you hit one. |
Pricing
Buy it once.
Before you buy, read the End User Licence Agreement (v1.0), effective 13 September 2026. It is the agreement you accept at checkout. The free audit scripts are MIT-licensed and are not covered by it. Plain description, prices and licence in one place: pigenai.com/context-floor.
There is no server and nothing to host, so there is no subscription — a subscription for a local script set is one the buyer resents by month two. The one thing that genuinely recurs is keeping the scripts correct as Claude Code ships new versions — the status-line payload schema has already changed once between releases — and twelve months of those corrections are included.
The Audit
Free
MIT on GitHub
- Model audit across all eight precedence layers, every repo included
- Context audit that follows
@importsrecursively - Prints your own number. No email, no telemetry
Solo · one developer
$39 $29
founding price · ends 29 October 2026
- One-command installer — Windows, WSL, Linux, macOS
- The status line with all three monitors
- The full runbook and the paste prompt
- Unlimited personal machines · 12 months of updates
- Optional update channel after year one: $19/year. Your copy keeps working either way
- 14-day refund, no questions
Team · 10 seats
$249
one time · 10 named developers
- Everything in Solo, for ten named developers
- Seats reassigned when someone leaves; contractors covered while engaged
- Model audit exits non-zero on drift — works as a weekly cron or a CI step
- 12 months of updates · optional update channel after year one: $99/year
- 30-day refund
Install
Audit first. Change nothing until you have read it.
Both audits were proved by deliberately breaking them — a repo pinned to the wrong model, a CLAUDE.md importing a large file — and confirming they fail rather than pass quietly. The status line was tested at every threshold boundary, in bash and in PowerShell, on two machines.
Look before you touch anything
Run with
-AuditOnly. It reports every model pin in all eight precedence layers and your fixed per-turn overhead with imports followed, and writes nothing.Run it for real
It detects Windows and WSL, backs up
settings.json, asks, merges exactly three keys, re-reads what it wrote and renders a real status line to prove it took.Paste one prompt
The one job a script cannot do, because it needs judgment about your rules: which lines a session must know before its first action, and which it can look up on demand. That is where 14,740 became 1,036.
Send one message, then look again
The 5-hour and 7-day meters do not appear in a brand-new session — the payload carries no rate-limit data until the session has made a request. A fresh window shows no meters and looks broken. It isn't.
Who made it
Lindsay Hiebert — Founder and CEO, PIGENAI LLC
30+ years across AT&T, Cisco and Intel, CISSP, and a working portfolio of production applications built with Claude Code every day. Context Floor came out of measuring a real session that exhausted a usage window in an afternoon, then checking every claim in the write-up against the binary and finding six of them wrong.
All six corrections are published in the kit's errata. A configuration tool that publishes its own errata is the kind you can trust with your configuration.
The full measurement, and all six corrections, are written up here: A 2 KB file that cost 14,740 tokens on every turn.