The author argues empirically that modern Claude Code and Cursor agents routinely consume 200k–1M tokens per task, making 2023-era advice to compress system prompts to 800 tokens obsolete. Per-token costs have dropped fast enough that a full agent run costs under fifty cents, so optimization for token count no longer makes economic sense.
The article reframes tokenmaxxing as controlling what lands in context rather than minimizing it, identifying context rot (stale tool returns consuming budget) as a core failure mode. The real bottleneck is the model's ability to stay coherent past ~50k tokens of mixed-provenance context, not the dollar cost of those tokens.
Commenters posted evidence that production system prompts have ballooned to 14,000 tokens of structured instructions, examples, and tool schemas. One noted Anthropic's own published Claude Code system prompt runs roughly 10k tokens before any user input, demonstrating that even the model vendors have abandoned aggressive minification.
A piece on 12gramsofcarbon.com titled 'Tokenmaxxing is dead, long live Tokenmaxxing' hit 124 points on Hacker News this week with an argument that landed harder than expected: the entire prompt-engineering folk wisdom from 2023 — compress, deduplicate, strip whitespace, fit the system prompt in 800 tokens — is now actively counterproductive when you're building agents.
The author's central observation is empirical, not theoretical. A modern Claude Code or Cursor agent solving a non-trivial bug routinely chews through 200k–1M tokens across a single conversation. Tool calls return diffs, file contents, test output, stack traces, and search results. The token budget per task has risen roughly two orders of magnitude in 18 months, while per-token pricing has dropped fast enough that the *dollar* cost of a complete agent run is often under fifty cents. The constraint is no longer cost-per-token; it's the model's ability to stay coherent past ~50k tokens of mixed-provenance context.
The HN comment section turned into a graveyard of obsolete advice. One commenter posted a 2023 tweet recommending 'aggressive system prompt minification' next to their current production system prompt — 14,000 tokens of structured instructions, examples, and tool schemas. Another noted that Anthropic's own published Claude Code system prompt runs roughly 10k tokens before any user message lands.
The interesting move in the article isn't 'tokenmaxxing is dead.' That's been obvious to anyone running agents in production for six months. The interesting move is what comes next: the new tokenmaxxing isn't about minimizing tokens — it's about controlling provenance, recency, and relevance of every token that lands in context.
Concretely, this manifests as three failure modes the article identifies:
Context rot. Tool returns from 30 turns ago still consuming budget even though the agent moved on. The classic example: agent reads a 4,000-line file at turn 3, summarizes it, then continues for 40 more turns with that file still in context. The summary is what's load-bearing; the raw file is dead weight that's quietly degrading attention. Sub-agent architectures and context-window pruning (drop tool calls after N turns, keep only summaries) are the practitioner answer here, and Anthropic's own write-ups on Claude Code's sub-agent loop confirm this is now table-stakes engineering, not optimization.
Scratchpad pollution. Reasoning-trace models (o1, Claude with extended thinking, R1-style) generate token volumes their predecessors didn't. If you naively dump those traces back into context for the next turn, you've poisoned your own well. The piece points out that the highest-performing agent harnesses now strip thinking blocks aggressively between turns and keep only the final actions — exactly the opposite of the 'more context = better' instinct from the GPT-3.5 era.
Tool-return ballast. A `grep` returning 8,000 lines, a `git log` dumping 200 commits, an API response with 50KB of irrelevant fields. The single highest-leverage change most agent codebases can make is wrapping every tool with a return-shape filter that drops anything not load-bearing for the next decision. Cursor's engineering team has been increasingly public about this; their tool-return budgets are tight by default and the agent has to explicitly request expansion.
There's a deeper point underneath all of this. The 2023 mental model was that the LLM was a function: input tokens in, output tokens out, optimize the input. The 2026 mental model is that the agent is a stateful system whose context window is shared memory between dozens of operations. You don't optimize a stateful system the same way you optimize a function — you instrument it, you garbage-collect it, you treat the context window like RAM that you're explicitly responsible for managing.
If you're shipping agentic features, three concrete shifts pay off in the next sprint:
Replace token counters with task-success-per-token metrics. Your dashboard probably shows average tokens per response. That number is meaningless for agent workloads. What you actually want is tokens-per-resolved-task, ideally bucketed by task complexity. If a senior engineer's grep-fix-test loop in Cursor consistently runs 180k tokens and resolves on first try, that's a healthier metric than a 30k-token loop that requires three retries.
Audit your tool returns the way you'd audit a hot SQL query. Every tool the agent can call needs a return-shape contract. A `read_file` that returns the whole file is fine for small files and disastrous for large ones — pagination, line-range arguments, and 'return summary if over N lines' guardrails belong in the tool layer, not in the agent's prompt.
Build context-pruning into your harness, not your prompt. Telling the model 'forget earlier turns' in the system prompt is unreliable. Actually deleting earlier turns from the API request is deterministic. The harnesses that perform best in production maintain explicit state about what's in context and what's been compressed to summary, and they do this in code, not in natural language instructions to the model.
The meta-point of the piece — and the reason it resonated on HN — is that the agentic shift has invalidated a generation of LLM folk wisdom faster than most teams have updated their internal docs. If your onboarding still references 'token efficiency' as a north-star metric, or if your prompt-engineering guide was last edited before sub-agents existed, you're shipping yesterday's optimization. The next 12 months belong to teams that treat the context window as a managed resource and the agent as a stateful program — not to teams still squeezing whitespace out of system prompts.
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.