Waste Tokens, Save Time — When Brute Force Is the Rational Choice

This piece was sparked by The AI Industrial Revolution with Naval Ravikant, where one of the builders at the table offered a deceptively simple rule: “just waste tokens, save time.” Don’t optimize the inputs or the outputs, he argued — optimize your own time and the final result, because “they’re still way cheaper than a human.”

It sounds like permission to be sloppy. It’s actually a precise economic claim, and it’s worth taking apart, because it’s right in a narrower way than the slogan suggests.

The arithmetic that makes “waste” rational #

Start with the prices. The cost of a fixed unit of model capability has been falling at a rate that has no analog in labor markets. Epoch AI’s analysis of frontier models found the price to reach a given capability level dropping at a median of roughly 50x per year, accelerating to around 200x per year for the period after January 2024 (Epoch AI). Your token budget buys dramatically more thinking every quarter.

Now the other side of the ledger. A fully loaded US software developer runs about $160,000–$170,000 a year, or roughly $80–$150 an hour once you include overhead (Decode). Against that, the API cost of even a token-hungry task is measured in cents to a few dollars. When a tool that costs dollars can save an hour that costs a hundred, thrift on the cheap input is a category error. That asymmetry — not any claim about model brilliance — is what makes “waste tokens” the disciplined choice rather than the lazy one.

Why throwing more compute actually works #

The slogan would be hollow if extra tokens didn’t buy better outcomes. They do, and there’s a mechanism. “Large Language Monkeys” showed that coverage — the fraction of problems solved by any sample — scales log-linearly as you draw more samples, across four orders of magnitude. On SWE-bench Lite, DeepSeek-Coder-V2 climbed from 15.9% with one sample to 56% with 250 samples, beating the 43% single-attempt state of the art (arXiv 2407.21787). A cheaper model given many tries beat a more expensive model given one.

This isn’t new physics. Self-consistency — sampling many reasoning paths and taking the majority answer — improved GSM8K accuracy by +17.9% over greedy decoding back in 2022 (arXiv 2203.11171). The modern version is just doing it at industrial scale, across agents, in parallel.

The cleanest production datapoint comes from Anthropic’s multi-agent research system, which spins up several subagents at once. It outperformed a single top-tier agent by 90.2% on internal evaluations — while spending about 15x the tokens of a normal chat. Tellingly, raw token expenditure alone explained roughly 80% of the performance variance (Anthropic). That is “waste tokens, get results” stated almost literally.

The condition the slogan hides: cheap verification #

Here is where the rule needs a sharp edge. Repeated sampling pays off reliably only when you can cheaply check which sample is right. DeepMind’s AlphaCode is the archetype: it generated millions of candidate programs per problem, used the problem’s own test cases to filter out roughly 99%, submitted only ten, and reached about median-human rank in real Codeforces contests (DeepMind). Brute force plus a free verifier substituted for a smarter single shot.

Take the verifier away and the curve bends. Without an automatic check, majority-voting and reward-model selection plateau beyond a few hundred samples (arXiv 2407.21787). So the honest formulation of the rule is: waste tokens freely where verification is cheap — tests, types, compilers, evals — and spend deliberately where it isn’t.

Where “waste tokens” quietly costs you #

A company blog that only quoted the upside would be selling something. The strongest rebuttal is METR’s 2025 randomized trial: experienced open-source developers were 19% slower with early-2025 AI tools, even though they predicted a 24% speedup and believed afterward they’d been 20% faster (METR). The tax was real and invisible to the people paying it — which is the dangerous kind.

There’s a quality tax too. GitClear’s analysis of 211 million lines found copy-pasted code overtook refactored code for the first time in 2024 (GitClear), and the 2025 DORA report links AI adoption to reduced delivery stability when teams lack strong testing and version control (DORA). And the economics that look trivial for one task flip at fleet scale: Anthropic is explicit that multi-agent spend is not worth it for most low-value or chat-style work (Anthropic). Per-query energy is tiny — roughly 0.3 Wh (Epoch AI) — but it compounds across millions of calls.

The rule, restated for builders #

“Waste tokens, save time” is correct, with the fine print made explicit:

• Price your own hour honestly. If a few dollars of inference has any real chance of saving a $100 hour, spend it without flinching.
• Parallelize where you can verify. Many tries plus a cheap, sound check (tests, types, a held-out eval) is the highest-leverage pattern in the toolkit.
• Don’t confuse motion with progress. Measure against the final output, not token counts — and watch for the METR trap, where it feels faster while it isn’t.
• Treat scale and tech debt as real line items. The 15x multiplier and the duplication tax are the bill that comes due when brute force becomes a habit instead of a tactic.

The deeper point is that token frugality is optimizing the wrong variable. The scarce, expensive, non-renewable input is your attention. Spend the cheap thing to protect the dear one — and put a verifier between the two so the savings are real.