Paste This Into Claude, Never Hit a Token Limit Again

Summary (Technological concepts + practical token-saving tactics)

The video explains a multi-level system to avoid hitting Claude’s token/rate limits by reducing wasted context, changing prompt/workflow behavior, and using the right tooling/models.

---

Level 1 — “Master prompt” token audit + cleanup

• Use a provided “master prompt” to run a Claude-side audit of a fresh session and your current setup.
• The audit:
  • Lists what’s preloaded (system tools, MCP servers, Claude.md, connected tools/skills).
  • Reads session logs and checks Claude.md files in scope (project + parent folders).
  • Flags large files (e.g., over 5K lines) and identifies totals over 10K to review/remove.
  • Runs 3 phases: audit → fix/apply → provide habits to keep usage lower.

Reported impact from the creator:

• Found ~95.4% waste in their setup.
• Found ~97.8% of token usage coming from 3 leftover/open sessions, suggesting stale context can dominate consumption.

Manual cleanup tip:

• In Claude connections/plugins, go to Connectors and disconnect any unused connectors (example: “Canva”).

Additional review angle:

• Package the workflow as a client-facing “bonus” (an audit skill) so others can reduce token usage too.

---

Level 2 — Behavior changes (reducing token burners during chat)

The video lists “hacks” designed to prevent Claude from repeatedly reprocessing the entire conversation:

1. Use /clear between jobs

   • Prevents Claude from rereading the entire prior conversation context.

2. Use one model per session

   • Don’t switch models mid-chat.
   • Model switching forces Claude to reprocess history, increasing token burn.

3. Batch questions

   • Instead of sending many incremental messages, ask questions in a batched/streaming way (example mentions a “continuous mode”/dictation-style approach).
   • This reduces how often Claude must reread the full chat each turn.

4. Edit instead of “correct by adding”

   • If you make a mistake (e.g., “tallest man” but you meant “tallest woman”), use the pencil/edit capability to replace the text.
   • This avoids adding the incorrect content plus the correction to the conversation.

5. Prefer text over PDFs/images when repeatedly referenced

   • Pre-process into plain text when possible to avoid repeated extraction/processing costs.

General rule reiterated:

• Don’t change the model selector or “effort level” mid conversation.

---

Level 3 — Fix “verbosity” to reduce clarification and shorten conversations

• Addresses the verbosity problem: overly long outputs lead to more follow-up questions, longer context, and more token usage.
• Uses a communication style referred to as C100:
  • “Like you’re 5” (simple, short sentences, minimal superfluous language).

Skill approach:

• Turn the C100 style into a Claude skill so Claude responds concisely and is easy to understand.

Rationale:

• Clearer answers → fewer clarifying questions → shorter chats → fewer tokens spent (including “human token cost,” i.e., time/mental overhead).

---

Level 4 — Routing to the right model/task + code-base token efficiency

A) Model routing / “use the right model for the job”

Uses a mental mapping:

• Haiku = grunt work
• Sonnet = builder / general tasks
• Opus = main session driver
• Fable = highest-quality decisions (recommended especially for big decisions)
• Mentions ChatGPT subscription routing, and using Codex for certain verification tasks.

Key example:

• Codex as a checker
  • Claude may miss issues; Codex CLI can double-check work.
  • The video emphasizes verification to prevent expensive rebuilds (e.g., “check it with Codex”).

B) Use a codebase mapping tool to reduce re-reading code

• For GitHub repos/codebases, the video recommends a tool called GraphiPy.
• Goal:
  • Build a relationship “map” of the repo so Claude can query logically instead of scanning line-by-line.
• Claimed result:
  • Significantly reduces token cost when finding information in large codebases.

Suggested use cases:

• Learning a new codebase
• Asking questions about structure/relationships
• Understanding and querying repos efficiently

---

Level 5 — “Design in Claude” token budgeting + codifying outputs

Focus: don’t just chat—reduce cost when iterating on design tasks.

Tactics:

1. Save preferred design styles as skills

   • Prevents repeated exploration that burns tokens.

2. Screenshot budgeting

   • Every screenshot costs tokens (example claim: ~5,000 tokens).
   • Prefer describing visuals with text and only include essential screenshots.

3. Get it right on the first prompt

   • Repeated iterations compound cost (“performance slants down over time”).

4. Codify once

   • Convert the winning output into a reusable template/spec (~“2 kilobyte specs” mentioned) to reuse with less cost.

5. Use “sub agent critics” via a design loop skill

   • Slightly more tokens, but higher quality output.
   • Then codify the result for reuse.

---

Sponsor/tool integration mentioned

• GenSpark is presented as an “all-in-one” environment that can use multiple model types (image/video generation, etc.).
• Example capabilities:
  • Generate images (prompt-driven)
  • Create “AI sheets” (tables/dashboards like income/ROI/expenses)
  • Generate slides/pitch decks from meeting transcripts
  • Export into Microsoft PowerPoint
  • Modes like creative vs professional

(This is separate from the Claude token system, but used as a workflow/tooling example in the video.)

---

Main speaker/source

• Jack (introduced near the end: “if you are new here, I’m Jack. I built a small elastic startup…”).