How I Run Claude Code 8+ Hours a Day Without Hitting Token Limits

I live in Claude Code. On any given day I'm jumping between a Laravel SaaS, a Next.js marketing site, a Kotlin Multiplatform app, a couple of Plesk servers, and whatever client work is on fire. Eight hours a day, sometimes more. Multiple projects. Long sessions.

And I almost never hit a context limit or a usage limit.

People assume that's because I'm on the Max Pro plan. The plan helps — I'm not pretending it doesn't — but I know plenty of folks on the same plan running into walls inside two hours. The plan isn't the lever. Habits are the lever.

Most of the context Claude Code burns through in a long session is exhaust, not work. Files re-read in full when 30 lines were enough. Plans written out in prose that get re-included in every subsequent turn. Bash output dumped raw when a tail -50 would have done the job. The model is happily executing every instruction — but most of those instructions are wasting your runway.

Below are the seven habits I run by default. Together they let me work a lot longer per session, on bigger codebases, without hitting the wall. I packaged them up as a Claude Code skill so you can drop it into your own setup in about thirty seconds. Grab it on GitHub — it's free, MIT-licensed, and lives in my open skills repo.

1. Read with offset and limit, never gulp the whole file

The Read tool defaults to roughly 2,000 lines. Most files don't need that. Most tasks touch ten to fifty lines.

My rule of thumb:

• Under 100 lines: read it whole.
• 100–500 lines: grep -n for the symbol first, then read just that window with offset and limit.
• Over 500 lines: never read whole. Locate first, then read a window.

And re-reading a file you just edited is almost always wrong. The Edit tool errors loudly if a change doesn't apply — silence means it worked. The re-read is paranoia tax.

2. Delegate research to subagents

This one alone is worth the price of admission. Anything that takes three or more file reads to answer should be a subagent — Explore for read-only lookups, general-purpose for multi-step research.

The subagent burns its own context, then hands you back a paragraph. You stay clean. I use this constantly for questions like "where is X defined and what calls it?" or "is there an existing helper for Y?" Instead of pulling fifteen files into my main thread, I get a tight summary.

Critical follow-on rule: trust the subagent's report. Don't redo the same searches yourself afterward. That defeats the entire point.

3. Pipe long output — never let raw bash dumps land in context

Default to filtering at the source.

• Builds and tests: ... | tail -50
• Discovery (find, ls -R, grep -r): ... | head -50
• Long logs: ... | tail -200 or grep first
• JSON payloads: pipe through jq '.field' instead of pretty-printing the whole thing

The full output isn't useful if it scrolls past the actual signal. A 2,000-line build log dumped raw will follow you for the rest of the session. A tail -50 tells you the same thing for one-fortieth the cost.

4. Use TodoWrite (or your equivalent) — don't hold plans as prose

If you write "OK, I'll do A, then B, then C" in a message, that plan gets re-sent to the model on every subsequent turn. Forever. The same plan tracked in TodoWrite lives in a single compact structure that updates in place.

My rule: if I'd write a numbered list of steps in chat, I write it to TodoWrite instead and reference it by status. One source of truth, way cheaper.

5. Drop checkpoint summaries every 3–4 tool rounds

One sentence: "Found the bug in auth.go:142 — guard clause inverted. Fixing next."

This anchors the conversation when context inevitably compresses. It also means a future session — or a future you — can pick up cold without re-deriving state. It's the cheapest insurance policy in the entire workflow.

This is not narration of intent. It's a stake in the ground for what's known now.

6. Never echo file contents back to the user

If Claude just read a file, it shouldn't restate it back. The user can already see it. Skip "Here's what's in the file:" and go straight to "The bug is on line 42 — x is shadowed."

Same rule for grep results, git log, find output. Don't recap. Act.

This one is a setting in how you brief Claude — it doesn't fix itself by default. The skill below packages it as an explicit rule.

7. Use the skill system itself

This is the meta-habit and probably the most underused feature in Claude Code.

Skills load only their description into context — usually around thirty tokens. The body of the skill, plus any reference docs, only loads when the skill is actually invoked. So a 200-line skill costs you almost nothing until it fires, then loads exactly when relevant.

This means you can have dozens of specialized skills available — UX review, security audit, deployment runbooks, project-specific conventions — without any of them costing you upfront context. Claude reads the descriptions, picks the right one when the task matches, and only then loads the details.

If you're not using skills, you're effectively paying upfront context for things you might need instead of paying on-demand for the thing you actually need.

The mindset shift

Every tool call has three costs: the call itself, the output it returns, and the context it occupies for the rest of the session. A 400-line file you didn't need to read follows you for the next fifty turns. A subagent's one-paragraph summary follows you for fifty turns. Same context cost, vastly different signal density.

The work is the diff and the decisions. Everything else is overhead.

Once you frame it that way, every interaction with Claude becomes a question of what's the cheapest way to get the signal I actually need? Whole-file reads start to feel obviously wasteful. Multi-paragraph end-of-turn summaries feel obviously wasteful. Re-reading after every edit feels obviously wasteful.

And the long sessions stop hitting walls.

Drop this into your own setup

I packaged these seven habits as a Claude Code skill called token-discipline. It lives in my open skills repo on GitHub:

github.com/Kevinchamplin/claude-skills

Install in about thirty seconds:

git clone https://github.com/Kevinchamplin/claude-skills.git ~/claude-skills && mkdir -p ~/.claude/skills && cp -r ~/claude-skills/token-discipline ~/.claude/skills/

Restart your Claude Code session and the skill becomes available. It triggers automatically on long sessions and context-pressure cues, but you can also invoke it explicitly when you feel the runway shortening.

The repo has two other skills (frontend-design and ux-designer) that I use just as often, and PRs are welcome. If something here saves you a few hours a week — that's the point.

I run this stack daily, across more projects than I can count, and the limits stopped being the bottleneck a long time ago. They can stop being yours too.