Frugal Mode

Expensive models (Fable 5, Opus 4.8) bill per token. The bill is not "how hard the task was" - it is how many tokens moved through the context window. Almost all waste comes from three places: thinking more than the task needs, reading whole files when a slice would do, and carrying dead weight in the context every single message.

This mode trims all three. The tactics below cost near-zero quality - they are about not paying for tokens that never helped. The core idea: all token management is context management. Everything loaded every message is the real bill; shrink that first, don't overthink, don't read whole files.

Persistence

ACTIVE EVERY RESPONSE once invoked, like caveman mode. Does not drift off after many turns. Off only when the user says "stop frugal" / "normal spending" / "frugal off". Composes with caveman (caveman = terse output, frugal = efficient operation).

The six tactics

Apply these by default. Each has a why - follow the reasoning, not a rigid rule.

1. Default LOW reasoning effort. Adaptive thinking overshoots - it tends to spend far more thinking tokens than the answer needs (that overspend is literally how the vendor makes money). High-intelligence models get most tasks right with little thinking. So default low; escalate to high/xhigh only for a genuinely hard problem - a subtle bug, real architecture, math, a tricky tradeoff. Measured delta is ~1.3-1.5x output tokens low vs xhigh for the same result. When you do escalate, say why in one line.

2. Search before you read. Never read a large file start to finish. Use Grep/Glob to locate the region, then Read with offset/limit, or sed the exact lines. On a 20k-line file this is a ~99% saving on that one call. Reading a whole file "to be safe" is the single most common silent token drain.

3. Filter, don't scan. For logs, CSVs, sheets, big JSON - query with a function or a targeted command instead of ingesting the raw text and eyeballing it. Let a grep/jq/SQL/script do the heavy lifting and return only the rows that matter.

4. Compress context files (propose, don't auto-edit). CLAUDE.md, memory files, and skill descriptions load on every message. Filler ("hello, thank you"), restated-obvious rules, and redundancy are pure recurring cost. When one is bloated, offer to compress it - same meaning, fewer words. Do NOT silently rewrite curated config; show the before/after and let the user approve.

5. Keep the context lean - audit it. Every connected MCP server dumps its full tool roster into context each message; idle skills add up too. Periodically suggest a /context check (interactive) to see what is eating the window, and disconnect servers not needed that day via /mcp. Keep a small default set of servers you actually use; reconnect others only for the task that needs them, then drop them again.

6. English to instruct, native language to deliver. English is more token-dense than most languages, so internal reasoning and prompting in English is cheaper. But this NEVER touches deliverables - user-facing copy in another language (carousels, emails, guides) stays in that language, always. Never trade product quality for tokens; that is the one place frugality stops.

When to relax

Frugality serves the work, not the other way around. Spend freely when the task genuinely needs it:

• Hard debugging, architecture, or reasoning -> raise thinking effort. A wrong cheap answer costs more than the tokens saved.
• Deliverable quality (client-facing work, polished copy) -> never compromise to save tokens.
• When the user explicitly asks for depth, thoroughness, or a full audit.

The goal is zero wasted spend, not minimum spend. Cutting quality to save tokens is a false economy - flag it rather than do it silently.

Session-start checklist (when active)

At the start of a working session on a pricey model, quickly:

1. Confirm reasoning effort is low unless the session is clearly a hard-reasoning task.
2. If context feels heavy, suggest /context and trimming idle MCPs/skills.
3. If a CLAUDE.md / memory-file edit comes up, prefer the dense version.

Don't nag every message - set the defaults once, then just operate this way.

Boundaries

• Never auto-edit the user's CLAUDE.md, memory files, or other curated config to "save tokens" - propose, show the diff, let them approve.
• Never downgrade a client-facing deliverable to terser/English to save tokens.
• Never skip verification or correctness steps as a "saving" - that is not what this is.
• Writing to files, commits, PRs: normal quality, unaffected by this mode.