Token Maxxing: Don't Let Your AI Tokens Expire Unused

You pay a flat monthly fee for Codex, Claude Code, or a Max plan. The tokens don't roll over. When a weekly reset is about to expire, whatever you didn't use just disappears — capacity you already paid for, gone. That's not a usage problem, it's a return-on-investment problem. You bought something and threw part of it away.

The fix isn't to burn tokens for the sake of it. It's to spend the leftover capacity on work that still exists next week: a bug list, tests you didn't have, docs written from the real code, a reusable skill. I put the seven prompts I actually run into a small open repo so you can copy-paste them.

First: you can barely see when they expire

Half the reason this capacity gets wasted is you can't tell when it's about to. Most tools don't show a clear expiry. For Codex there's an unofficial endpoint the community has been passing around — you ask Codex itself to query it:

curl -sS 'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits'

It's unofficial and needs your authenticated session, so treat it as a rough gauge, not a promise. The point is simply to know whether you've got hours or days before a reset drops, so you can decide what to run.

The one rule

Only spend leftover tokens on work that leaves a durable artifact — something committed, documented, or reusable after the reset. If a job produces nothing you keep, it's not token maxxing, it's just noise that happens to cost money you'd already spent.

The seven prompts

Prompt	What you get back
Parallel read-only repo audit	A ranked bug and risk report from specialist reviewers, each in its own context window
Fix one bounded bug category	A focused PR with a definition of done and a verification command
Test-debt pass	Missing tests written for critical paths, flaky tests isolated
Code archaeology	A module map plus evidence-backed cleanup candidates
Documentation pass	ADRs, runbooks, and user flows built from the real code, not templates
Mine sessions into a skill	The smallest reusable skill, subagent, or CLI from your own history
Repo maintenance sweep	Triaged issues and PRs plus the next high-value actions

The pattern across all seven: read-heavy, artifact-producing, safe to run while you do something else. The audit and the maintenance sweep use parallel read-only subagents — many reviewers each looking for one class of problem find far more than a single agent reading the whole repo. Full copy-paste versions and notes are in the repo.

Watch the caps while you spend

Big parallel jobs burn fast. On most plans there's a rolling five-hour cap that can stop a job mid-run, and a separate weekly cap on top. So write the plan first, then run — you don't want a six-subagent review or a legacy refactor dying halfway because you hit the five-hour wall. To stretch what you have, run subagents on a smaller model, turn off fast mode for background work, and cap the reviewers at around six.

Why this is an ROI habit, not a hack

If you're paying for a plan, your effective cost per token drops every time you use more of what you already bought. Letting a reset expire empty is the opposite — it quietly raises your real cost per unit of work. Ten minutes of copy-paste before a reset turns that dead capacity into a backlog you'd otherwise pay an engineer's time to clear. That's the whole idea behind token maxxing: stop leaving paid-for compute on the table.

Work with me