← Back to library

18 Claude Code Token Hacks in 18 Minutes

Watch videoView transcript

Nate Herk | AI Automation18m 57sTranscript ✅Added May 6, 3:52 pm GMT+8

Actionable Insights

  1. Measure token burn before optimizing Use Anthropic’s token counting / count messages API for API workflows, and Claude Code usage/insight commands where available. Track: prompt tokens, output tokens, cache reads/writes, session length, and compaction events. Start by turning this into a small, reversible pilot: write down the exact input, expected output, owner, and success metric before changing the wider workflow. The useful detail from the analysis is: The video argues that Claude Code limits feel worse because long sessions repeatedly reload conversation history, instructions, command outputs, and project context. The proposed solution is token hygiene: shorter sessions, better scoping, smaller outputs, model routing, and explicit context management. Treat the first run as an evaluation, not a migration: capture before/after examples, note where the method saves time or improves quality, and keep the old path available until the new one passes repeated checks. Watch for the main failure mode here: overgeneralizing the creator’s demo beyond the evidence. If the video or comments only showed a narrow case, keep the rollout narrow and require fresh proof before broad adoption.

  2. Start every long task with a context budget Checklist: goal, files in scope, files out of scope, max command output, when to summarize, when to /clear, and which model handles planning vs execution. Expected benefit: fewer runaway sessions and less repeated old context. Start by turning this into a small, reversible pilot: write down the exact input, expected output, owner, and success metric before changing the wider workflow. The useful detail from the analysis is: The video argues that Claude Code limits feel worse because long sessions repeatedly reload conversation history, instructions, command outputs, and project context. The proposed solution is token hygiene: shorter sessions, better scoping, smaller outputs, model routing, and explicit context management. Treat the first run as an evaluation, not a migration: capture before/after examples, note where the method saves time or improves quality, and keep the old path available until the new one passes repeated checks. Watch for the main failure mode here: overgeneralizing the creator’s demo beyond the evidence. If the video or comments only showed a narrow case, keep the rollout narrow and require fresh proof before broad adoption.

  3. Use plan-then-execute model routing cautiously Commenters suggest using stronger models for planning and cheaper/faster models for execution. Good experiment: same task three ways — one model throughout, strong-plan/cheap-execute, cheap-plan/strong-review — compare correctness, cost, and rework. Start by turning this into a small, reversible pilot: write down the exact input, expected output, owner, and success metric before changing the wider workflow. The useful detail from the analysis is: - pushback / caveat: @Colormomey556 (90 likes) — 1 thing about plan mode I found is you can use /model opusplan and it gives you opus level reasoning for planning only then legs Haiku or Sonnet actually run the task, this helps me save tokens. The proposed solution is token hygiene: shorter sessions, better scoping, smaller outputs, model routing, and explicit context management. Treat the first run as an evaluation, not a migration: capture before/after examples, note where the method saves time or improves quality, and keep the old path available until the new one passes repeated checks. Watch for the main failure mode here: overgeneralizing the creator’s demo beyond the evidence. If the video or comments only showed a narrow case, keep the rollout narrow and require fresh proof before broad adoption.

  4. Make command output token-safe Prefer rg, git diff --stat, pytest -q, head/tail, JSON filters with jq, and log files. Never paste full build logs unless needed. Start by turning this into a small, reversible pilot: write down the exact input, expected output, owner, and success metric before changing the wider workflow. The useful detail from the analysis is: The video argues that Claude Code limits feel worse because long sessions repeatedly reload conversation history, instructions, command outputs, and project context. The proposed solution is token hygiene: shorter sessions, better scoping, smaller outputs, model routing, and explicit context management. Treat the first run as an evaluation, not a migration: capture before/after examples, note where the method saves time or improves quality, and keep the old path available until the new one passes repeated checks. Watch for the main failure mode here: overgeneralizing the creator’s demo beyond the evidence. If the video or comments only showed a narrow case, keep the rollout narrow and require fresh proof before broad adoption.

  5. Preserve critical context outside chat Write decisions into CLAUDE.md, ADRs, TODO files, or issue comments before clearing. Caution: clearing saves tokens but can erase assumptions if you do not externalize state. Start by turning this into a small, reversible pilot: write down the exact input, expected output, owner, and success metric before changing the wider workflow. The useful detail from the analysis is: The video argues that Claude Code limits feel worse because long sessions repeatedly reload conversation history, instructions, command outputs, and project context. The proposed solution is token hygiene: shorter sessions, better scoping, smaller outputs, model routing, and explicit context management. Treat the first run as an evaluation, not a migration: capture before/after examples, note where the method saves time or improves quality, and keep the old path available until the new one passes repeated checks. Watch for the main failure mode here: overgeneralizing the creator’s demo beyond the evidence. If the video or comments only showed a narrow case, keep the rollout narrow and require fresh proof before broad adoption.

Core thesis

The video argues that Claude Code limits feel worse because long sessions repeatedly reload conversation history, instructions, command outputs, and project context. The proposed solution is token hygiene: shorter sessions, better scoping, smaller outputs, model routing, and explicit context management.

Creator’s main claims and verdicts

1. Long conversations compound token cost because old context is reread

Verdict: Agree, high confidence. Transformer chat APIs count the message context supplied for each turn; Anthropic’s token counting docs and prompt-caching docs support this. The transcript’s “rereading old chat history” explanation is directionally right.

Overclaimed: “exponentially growing” is loose wording. For a fixed added message size, cumulative billed input over repeated turns grows roughly quadratically, while per-turn context grows roughly linearly until compaction/caching/context limits change the curve.

2. Token hacks can 2x-5x practical Claude Code usage

Verdict: Mixed, medium confidence. Output trimming, clearing, summaries, prompt caching, and scoped tasks can create large savings, but the multiplier depends on workload, model, plan, cache behavior, and whether rework increases.

Practical takeaway: run a before/after token audit instead of trusting a universal multiplier.

3. Strong-model planning plus cheaper execution can save limits

Verdict: Plausible, medium confidence. This is a common workflow and the comments support it. But a weak executor can create mistakes that consume more tokens in repair.

4. Security/privacy hygiene is under-discussed

Verdict: Strong agree, high confidence. Comments asking about bank/identity/email/password safety are important. Token optimization should not encourage dumping secrets, logs, or private data into longer-lived context.

Best timestamped moments

  • 0:00 — sets up community complaints about hitting Claude Code limits. Evidence: “In the past week or so, so many people have been complaining about hitting their Claude code limit insanely fast. Claims like one prompt that is about 1% of the limit is now around 10%. You could go through X and find tons and tons of threads about this topic….”
  • 0:30 — promises tiered token-management hacks. Evidence: “different doing research, and I have 18 token management hacks for you guys that I’ve organized from tier one all the way up to tier three, so they get more advanced as we go. I’m very confident that by the end of this video, you will feel like your Claude cod…”
  • 1:00 — defines tokens and repeated context. Evidence: “engineer the way that you work in order to use less tokens. So a token is the smallest unit of text that an AI model reads and charges you for. It’s roughly one token is one word, but that’s not explicitly true, kind of just a good baseline. So every time that…”
  • 1:30 — claims most cost can be old chat history. Evidence: “moment for a lot of people. This means as you’re having a conversation with Claude, your cost is compounding, not just adding. It’s exponentially growing. Meaning message one might cost 500 tokens, message 30 costs 15,000 because it’s rereading everything befo…”
  • 2:00 — shows the compounding-cost graphic and mentions Claude.md reload. Evidence: “98.5% is crazy. So take a quick look at this graphic here. Along the x-axis, we have message number, and as it increases, you can see that we have our per message cost and our cumulative tokens increasing, but it’s not linear. It’s basically each message is re…”

Comment-derived insights

  • 159 likes @Concate_Nation: When I hit my limit, I feel I earned my forced break.
  • 90 likes @Colormomey556: 1 thing about plan mode I found is you can use /model opusplan and it gives you opus level reasoning for planning only then legs Haiku or Sonnet actually run the task, this helps me save tokens. I never hit my limits (and I use cowork and Claude AI, and I only
  • 32 likes @nateherk: good topic, security hygiene for running an AI agency is something I don’t see covered enough. noted.
  • 31 likes @fn564t: Could you do a video on how to protect your information while setting up and running a Claude AI agency? (bank/identity/emails/passwords/etc)
  • 23 likes @nateherk: that’s a solid tip, using Opus just for the planning phase is smart since that’s where the heavy thinking happens. appreciate you sharing that with everyone.
  • 20 likes @nateherk: honestly that’s the healthiest way to look at it, respect.
  • 16 likes @srahe54: That was a fantastic video! Thank you!
  • 14 likes @0xTheConsultant: There is going to be a point where local models will be “good enough” for most coders.
  • 6 likes @pauldavy1450: “only” im hoping these tips help with the basic plans. another reason why im pushing for local over cloud. time to finish a task isnt an issue for me but costinantly hitting blocks due to token limits is.
  • 6 likes @Colormomey556: @PSpaan yes, anytime you’re inside of Claude code just type /model opusplan and it will set opus as plan model only and sonnet or haiku for everything else

The top comments add two signals not central in the transcript excerpt: users treat forced limits as breaks, and there is appetite for security hygiene around AI agency workflows. The practical add-on is to pair token reduction with data minimization: shorter context is cheaper and usually safer.

Screen-level insights

  • 0:00 — youtube-extract/49V-5Ock8LU/frames/000_000000.jpg: visible key frame extracted for this workflow step; nearby transcript says “In the past week or so, so many people have been complaining about hitting their Claude code limit insanely fast. Claims like one prompt that is about 1% of the limit is now around…”. Use this as screen evidence, not just narration: verify the UI/tool named at that point and whether the demo actually shows execution or only a slide/product page.
  • 0:30 — youtube-extract/49V-5Ock8LU/frames/001_000030.jpg: visible key frame extracted for this workflow step; nearby transcript says “different doing research, and I have 18 token management hacks for you guys that I’ve organized from tier one all the way up to tier three, so they get more advanced as we go. I’m …”. Use this as screen evidence, not just narration: verify the UI/tool named at that point and whether the demo actually shows execution or only a slide/product page.
  • 2:00 — youtube-extract/49V-5Ock8LU/frames/002_000120.jpg: visible key frame extracted for this workflow step; nearby transcript says “98.5% is crazy. So take a quick look at this graphic here. Along the x-axis, we have message number, and as it increases, you can see that we have our per message cost and our cumu…”. Use this as screen evidence, not just narration: verify the UI/tool named at that point and whether the demo actually shows execution or only a slide/product page.
  • 3:01 — youtube-extract/49V-5Ock8LU/frames/003_000181.jpg: visible key frame extracted for this workflow step; nearby transcript says “how Claude code works and how tokens work, let’s move into the hacks. We’re going to start here with tier one hacks. These are the ones that are going to be super easy to implement…”. Use this as screen evidence, not just narration: verify the UI/tool named at that point and whether the demo actually shows execution or only a slide/product page.
  • 3:32 — youtube-extract/49V-5Ock8LU/frames/004_000212.jpg: visible key frame extracted for this workflow step; nearby transcript says “pretty obvious based on what we just talked about, so that’s why this was number one. Okay, number two is to disconnect MCP servers. Every single connected MCP server loads all of …”. Use this as screen evidence, not just narration: verify the UI/tool named at that point and whether the demo actually shows execution or only a slide/product page.
  • 5:02 — youtube-extract/49V-5Ock8LU/frames/005_000302.jpg: visible key frame extracted for this workflow step; nearby transcript says “But this is definitely something that you should be aware of. Okay, number four is to use plan mode before any real task. This lets Claude map out the approach, ask you the right q…”. Use this as screen evidence, not just narration: verify the UI/tool named at that point and whether the demo actually shows execution or only a slide/product page.
  • 6:03 — youtube-extract/49V-5Ock8LU/frames/006_000363.jpg: visible key frame extracted for this workflow step; nearby transcript says “{slash} context, this is what it will look like. It’ll basically give you a screenshot of how many tokens you’re at, what is the cap, and it will estimate based on the different ca…”. Use this as screen evidence, not just narration: verify the UI/tool named at that point and whether the demo actually shows execution or only a slide/product page.
  • 7:05 — youtube-extract/49V-5Ock8LU/frames/008_000425.jpg: visible key frame extracted for this workflow step; nearby transcript says “like my five-hour session. This is basically just indicating that I’m 5% of the way or 52K out of 1,000K. So all you have to do is in Claude code in the terminal, do {slash} status…”. Use this as screen evidence, not just narration: verify the UI/tool named at that point and whether the demo actually shows execution or only a slide/product page.
  • 7:36 — youtube-extract/49V-5Ock8LU/frames/009_000456.jpg: visible key frame extracted for this workflow step; nearby transcript says “basically check in on it every 30 minutes and send you like a text or a Slack message to say, “Hey, by the way, you’re getting near your usage.” All right, so number eight, we have…”. Use this as screen evidence, not just narration: verify the UI/tool named at that point and whether the demo actually shows execution or only a slide/product page.
  • 8:06 — youtube-extract/49V-5Ock8LU/frames/010_000486.jpg: visible key frame extracted for this workflow step; nearby transcript says “reads, but you also need to be precise about what you feed it. And number nine, our last tier one hack, is to actually watch Claude code work. Don’t just fire off a prompt and walk…”. Use this as screen evidence, not just narration: verify the UI/tool named at that point and whether the demo actually shows execution or only a slide/product page.

The visual step matters because token claims often rely on charts/settings rather than visible code execution. Frames around the opening and cost graphic should be treated as explanatory visuals, not measured proof. Any specific percentage/multiplier needs external measurement or local telemetry.

Token-hygiene checklist

  • Define task boundary and files before starting.
  • Use search/diff/stat commands before full file reads.
  • Summarize and clear after each milestone.
  • Keep durable decisions in repo docs, not only chat.
  • Route planning/execution/review deliberately and measure rework.
  • Redact secrets and personal data before pasting logs.
  • Track before/after tokens for at least 10 comparable tasks.

Sources / evidence checked

Verification notes

Four verification roles were applied before publishing: source/evidence audit, transcript/comment/frame fidelity audit, hallucination/overclaim audit, and Actionable Insights audit. Corrections made: replaced “exponential” with a more accurate token-growth explanation; treated 2x-5x as workload-dependent; added direct Anthropic token-counting and prompt-caching sources; added privacy/security cautions from comments; made the top section measurable and workflow-ready. Residual uncertainty: Claude Code plan/session limits and command names can change by plan/version, so exact savings require local usage telemetry.

  • Actionable Insights audit: expanded to the newer detailed format with fuller implementation notes, evaluation checks, and cautions where the existing evidence supports elaboration.

Comment insights

  • Top audience signal: @Concate_Nation (159 likes) said: “When I hit my limit, I feel I earned my forced break.”. This is the highest-salience community reaction and should be weighted as audience evidence, not proof.
  • pushback / caveat: @Colormomey556 (90 likes) — 1 thing about plan mode I found is you can use /model opusplan and it gives you opus level reasoning for planning only then legs Haiku or Sonnet actually run the task, this helps me save tokens. I never hit my limits (and I use cowork and Claude AI, and I only have the $100 max plan).
  • pushback / caveat: @nateherk (32 likes) — good topic, security hygiene for running an AI agency is something I don’t see covered enough. noted.
  • practitioner addition: @fn564t (31 likes) — Could you do a video on how to protect your information while setting up and running a Claude AI agency? (bank/identity/emails/passwords/etc)
  • practitioner addition: @nateherk (23 likes) — that’s a solid tip, using Opus just for the planning phase is smart since that’s where the heavy thinking happens. appreciate you sharing that with everyone.
  • practitioner addition: @nateherk (20 likes) — honestly that’s the healthiest way to look at it, respect.
  • Synthesis: Treat the comments as an adoption-risk check: if commenters ask for proof, cost controls, setup details, or safety boundaries, the workflow should include those checks before production use.

Deep research

  • Research scope: This pass cross-checks the creator’s claims in “18 Claude Code Token Hacks in 18 Minutes” against the extraction transcript, available linked/tool names in the analysis, and general public documentation/search evidence already cited elsewhere in this page where present.
  • Supporting evidence: The transcript provides direct evidence for what the creator demonstrated or recommended; source links in Actionable Insights identify the projects/docs/tools that should be inspected before adoption.
  • Contradicting/limiting evidence: Video demos and tool lists rarely prove production reliability. The missing evidence to look for is reproducible install steps, current official docs, security model, pricing/limits, recent maintenance, and before/after metrics on real tasks.
  • Verification method: Before using this in production, rerun the workflow on a small representative repo/task, save logs and outputs, compare against a non-agent baseline, and require human review for any external write/deploy/payment action.