Token Budgeter

---
name: token-budgeter
description: Run an AI session like an ad account — the 13 moves that stop token burn, in four stages from setup to model choice. Use when asked to reduce AI costs, manage tokens, stop hitting usage limits, make sessions last longer, fix a chat that got slow and expensive, decide when to compact or clear, or someone says 'I keep running out of tokens'. For which model to pick, see model-picker. For thinking depth, see effort-selector.
metadata:
  version: 1.0.0
---

# Token budgeter

The number that surprises everyone: message 1 costs ~500 tokens, message 30 costs
~15,500 — **31× more** — because the AI re-reads the whole conversation on every
turn. A 30-message session burns ~232K cumulative tokens, and most of it is
invisible: instruction file, connected tools, skills, and open files reload on
every single message.

The Digital Scholar frame: **run your AI like an ad account.** A good media buyer
wins not by spending the most, but by wasting the least. Four stages, 13 moves.

## Before you start

| Input | Why |
| --- | --- |
| What the session is for | One task per session is the biggest lever |
| Which tools/MCP servers are connected | One unused server can cost ~18,000 tokens per message |
| The instruction file's current length | It reloads on every message; under 200 lines is the bar |

## Step 1 — Set up a clean account (before you type)

1. **Disconnect unused tools.** Every connected MCP server loads its definitions on
   every message — one unused tool ≈ 18,000 tokens/message. A leak you cannot see.
2. **Keep the instruction file under 200 lines.** It is an index pointing to files
   by name, not the details themselves.
3. **See your starting weight**: `/context` (what fills the window — a fresh session
   already sits at ~51,000 tokens) and `/cost` (tokens and spend so far).
4. **Keep the usage dashboard open** — glance every 20–40 minutes, like Ads Manager
   during a live campaign.

## Step 2 — Write a tight brief (how you ask)

5. **All steps in one message.** Three separate messages cost ~3× one combined
   message. If the answer is slightly wrong, **edit and regenerate** rather than
   correcting in a follow-up — corrections stack into history forever; edits
   replace the bad exchange.
6. **Plan mode before any real task.** The single biggest waste is confident work
   down the wrong path. House line for the instruction file: *"Do not make any
   changes until you are 95% sure what to build. Ask me questions until you reach
   that confidence."*
7. **Paste only what it needs.** One section, not the whole document, when the
   problem lives in one place.
8. **Point at exact files** (`@filename`), never "go find it" — free exploration
   burns tokens.

## Step 3 — Watch the spend as it runs

9. **Fresh chat per task.** `/clear` when switching topics; dragging old history
   makes every new message more expensive. This habit stretches sessions the most.
10. **Compact at ~60%, not 95%.** Auto-compact fires near 95% — quality has already
    dropped by then. `/compact` yourself at ~60% with keep-instructions. After 3–4
    compacts, ask for a summary, `/clear`, paste the summary back.
11. **Watch it work; stop wrong paths early.** Loops and re-reads produce nothing —
    it is your money running.

## Step 4 — Put budget on the right engine

12. **Model is a cost decision** — balanced (Sonnet) for most work, cheap (Haiku)
    for repetitive volume, premium only when balanced was not enough. Details:
    **model-picker**.
13. **Instruction file = source of truth.** Save decisions, not conversations.
    Every stored decision is a paragraph you never type again.

## Output

```
# Session budget: <task>

Starting weight (/context): <n>K   Tools connected: <only what this job needs>
Instruction file: <n> lines (target <200)
Plan: one task; combined brief; compact at 60%; /clear on topic switch
Model/effort: <from model-picker / effort-selector>
Checkpoint: /cost at <time interval>
```

## When it breaks

| What you see | What it means | The fix |
| --- | --- | --- |
| Limits hit far too fast | Long sessions dragging history | /clear per task (move 9); combined briefs (move 5) |
| Fresh session already heavy | Tool and instruction overhead | Disconnect unused MCP servers; trim the file under 200 lines |
| Quality fades late in a session | Middle-of-context skimming; too many compacts | Summary → /clear → paste back (move 10) |
| Corrections keep making it worse | Follow-ups stack; history re-read | Edit the original message and regenerate |
| Big spend, nothing produced | Wrong path or a loop, unwatched | Watch long runs; stop early (move 11) |
| "I need a bigger plan" | Usually context hygiene, not capacity | Learn the 13 moves first; most beginners fix it without upgrading |
| Costs spike on one task type | Premium model doing cheap work | Re-split by model-picker; keep premium a small share |

Never respond to a limit by immediately upgrading the plan. The handbook's honest
answer: most beginners have a context-hygiene problem, not a capacity problem —
clean up first, upgrade only when real daily work still hits the cap.

## Rules

- **One task per session**, because history is re-read on every turn and unrelated
  history is pure tax.
- **Compact at ~60%, never wait for auto**, because 95% is past the point quality
  already dropped.
- **Edit-and-regenerate beats correcting**, because corrections are permanent
  history and edits are free replacements.
- **Disconnect what the job doesn't need**, because unused tools bill silently on
  every message.
- **Save decisions, not conversations**, because that is how the system gets
  sharper each week instead of repeating your money back at you.

## Related skills

- **model-picker** — which engine gets the budget (move 12, in depth).
- **effort-selector** — the thinking-depth lever, separate from the model.
- **claude-md-writer** — the under-200-line instruction file (moves 2 and 13).
- **agent-folder-scaffold** — the clean-account setup for a whole agent.