Video summary

Paste This Into Claude, Never Hit a Token Limit Again

Main summary

Key takeaways

Technology

Technological concepts: why token limits happen

  • Tokens = amount of text the AI must process.
  • Model used affects compute per token (better/frontier models typically cost more compute per token).
  • Compute budget = the total compute allowance tied to your subscription/account (e.g., Claude Pro/Max).

  • Key relationship:

    compute budget used = tokens consumed × model used

  • Important clarification: hitting limits is about total compute tied to your account, not only the number of tokens you personally “think” you used.

“Quick wins” (Part 1): reduce token consumption

1) Audit token usage in Claude Code

Use /usage in Claude Code to see:

  • token totals
  • “what’s using your limits” (where token spend is going)

Common findings mentioned:

  • large portions of usage from high-context (>150K context) activity
  • large portions from “sub agent heavy usage” (sub-agents are addressed later)

2) Fix contextual habits (reduce context growth over time)

Main ideas:

  • Context balloons as conversations progress; tokens rise quickly.

Habits listed:

  1. When switching tasks: run /clear or start a new chat
  2. Prefer working in longer focused blocks rather than pausing and resuming after long delays (waiting can reduce caching benefits)
  3. Adjust “effort” (higher effort = more compute):
    • via the bottom-right effort setting on Claude desktop (low/medium/high)
  4. When context is ~60% full: run /compact to compress history
  5. If using Claude Code in terminal: /status line to view context on-screen

3) Contextual cleanup: lower “preloaded” context before every session

  • Start a fresh chat and use /context to see what Claude preloads.
  • Goal: reduce the baseline context so each new conversation doesn’t start “already expensive.”

Cleanup prompt (described conceptually) includes:

  1. Review unused MCPs and delete them (manual: /MCP lists them)
  2. Clean up unused/too-long skills (remove unused skills or shorten descriptions)
  3. Revise claude.md:
    • It is reread for the entire conversation.
    • Guidance attributed to Anthropic docs: keep claude.md under ~200 lines (longer means “token tax” every message).

Extra caution:

  • one user example claimed they were at ~58.8K context before typing.

4) Reduce output tokens (shorter answers)

  • Use be concise guidance added to claude.md.
  • Or install the “Caveman” plugin to force shorter/casual responses (shown as before/after).

“System upgrades” (Part 2): make the setup 60–90% more efficient

Upgrade 1: Compress inputs before Claude sees them

  • Problem: sending full files wastes tokens (Claude rereads/uses more than needed).
  • Suggested architecture:
    • offload preprocessing to hooks/skills
    • citing Anthropic docs: “Offload processes to hooks and skills.”

Tool: RTK (open-source) to deterministically compress/clean text before sending to Claude.

  • Example claim: 15,000 → ~1,800 tokens (about 92% savings in the speaker’s tests across 13 commands).
  • RTK removes repeated text/boilerplate/format noise and compresses content.

Setup described:

  • paste the repo and run a command like “set up RTK on my project” so it runs automatically.

Upgrade 2: Use sub-agents + reduced models (“minimum viable model”)

  • Core idea: if a task could have been solved a year ago, it likely doesn’t need frontier models.
  • Practical method:
    • define Claude skills that specify:
      • a cheaper model for the skill
      • optionally fork context to reduce shared history
  • Analogy given: “junior staff” for grunt work; partners for complex judgment (lawyer analogy).
  • Optimization dimension provided:
    • optimize skills by context needs and model choice
    • predefine model inside skills so future runs use it automatically

Upgrade 3: Move repeatable steps to script-driven skills

  • Replace “AI doing everything” with automation:
    • Scripts run deterministically with 0 tokens and no hallucinations.
    • Use AI mainly for judgment, while scripts handle repeatable operations.
  • A prompt is referenced to:
    • enhance skills to use scripts
    • flag project skills missing script automation

“Nuclear enhancements” (Part 3): aggressive cost reductions (4 items, in order)

1) Route token-heavy execution to Codex

  • Claim: Codex (OpenAI) can burn ~4× fewer tokens on some tasks than Claude.
  • Reason given:
    • Claude is described as “thorough” (rereads/verifies/thinks)
    • Codex is “surgical” (edit-in/edit-out)

Implementation idea:

  • use a Claude Code plugin for Codex
  • route token-heavy actions to Codex
  • update claude.md so Claude knows what to offload

2) Use images instead of text

  • Claim: Claude processes images at a different rate than text.
  • Approach:
    • convert large text into images and send those instead
  • Example estimate: 60–70% token reduction (attributed to a tool/source in the summary).
  • Trade-offs noted:
    • may not read text perfectly
    • possible future changes/patches by Anthropic (non-zero risk)

3) Swap the “engine” / harness to other model providers

  • Claim: Claude Code’s harness and model can be swapped via environment variables.
  • Example providers mentioned:
    • ZAI GLM plan
    • DeepSeek plan

Trade-offs discussed:

  • privacy concerns (DeepSeek described as Chinese model)
  • potentially slightly worse quality

Prompts are referenced to:

  • generate an implementation plan
  • keep up with changing provider offers

4) Run your own model locally

Pros described:

  • effectively limitless tokens (hardware cost only)
  • data stays local
  • full control over the AI stack (own the infrastructure)

Cons described:

  • top-tier open-source models need expensive hardware (speaker suggests >$10,000 for real capability)
  • frontier models like “Fable” (as named in subtitles) aren’t typically downloadable for local use
  • operational overhead: server farm management (also joked about EMF concerns)

Recommendation:

  • experiment, but don’t go “all in” right now.

Sponsor / product feature mentioned (deck creation)

Bolt Slides

  • Sponsor: Bolt Slides (bolt.new → “slide deck”)
  • Features highlighted:
    • generates a styled, responsive web-app slide deck quickly
    • can embed interactive/live elements (charts, clickable diagrams)
    • slides view natively on projector/phone/tablet without “open on desktop” issues
    • faster iteration by visualizing earlier

Integration:

  • can connect to Claude Code to generate a deck from terminal.

“Speed run” checklist (what to do today)

Quick wins

  1. Use /clear when switching tasks; work in focused blocks; adjust effort; use /compact around 60% context; use /status in terminal.
  2. Run cleanup:
    • remove unused MCPs
    • remove/shorten unused skills
    • restructure claude.md into a directory/don’t keep it huge; keep it under ~200 lines.
  3. Reduce output:
    • enforce concise responses in claude.md
    • optionally use Caveman plugin.

System upgrades

  1. Install RTK to compress outputs before Claude reads them (claimed major token savings).
  2. Optimize skills to use minimum viable models rather than always frontier models.
  3. Convert repeatable work into script-driven actions in skills.

Nuclear enhancements

  1. Route token-heavy execution to Codex via a plugin.
  2. Convert text to images for large inputs.
  3. Swap model provider via Claude Code harness/engine changes.
  4. Optionally run models locally (experiment-level guidance).

Main speakers/sources

  • Main speaker: the YouTube creator (speaker not explicitly named in subtitles).
  • Sources referenced:
    • Anthropic docs (quoted guidance about hooks/skills and claude.md length)
    • RTK (open-source text compression tool)
    • PX pipe (referenced for image-vs-text token behavior claims)
    • Bolt Slides (sponsor/product)

Original video