Human Tokens: The cost of attention
I want the engineer's attention on the bill. It's the most valuable thing in the building, and the scarce thing in software delivery. Teams trim the token spend because it arrives itemized to the penny, then spend engineer hours freely because those hours never show up on the invoice.
The cheap line gets a budget. The expensive one runs uncapped.
The Slack test
If I take a prompt meant for an agent and paste it verbatim into a Slack DM to a coworker, the problem gets pretty obvious. "hey build the billing thing." No repo, no acceptance criteria, no deadline.
I'd get a confused emoji, a meeting invite, or, from someone new and eager, three days of the wrong thing built confidently. The model does that third thing immediately, and an hour later somebody posts that Claude sucks at billing.
The failures behind "Claude is bad at X" are usually ones I'd recognize on sight if a manager caused them:
- No context. A contractor on day one, with no repo access and no domain knowledge. If I say "build the billing feature" and walk away, I haven't given them what they need.
- No acceptance criteria. "Make it good" fails with people too. The person asks a question first, so the hole in the request goes unnoticed.
- No feedback loop. People one-shot an agent and make the first draft the verdict. I wouldn't call an engineer's first draft their ceiling.
But a person spends four seconds asking "which billing, subscriptions or invoices?" and prevents the wrong build entirely. The agent spends real tokens building the wrong thing, then somebody has to catch it. That's frustrating, and it's a real gap in the tooling.
So the fix belongs in the harness: a clarify-first gate that blocks the run until the question is answered. An instruction the model can skim past doesn't do that job. I'm talking about where the failures come from, not who deserves the blame. Most of the "Claude is bad at X" complaints I see come attached to prompts that would have failed a human too.
A person quietly patches a vague spec with their context and their questions. The cost stays hidden. An agent fills the holes with guesses, and the distance between what I said and what I meant comes back itemized. For the first time, there's a line-item statement for the communication itself. (What a thing to get billed for.)
The bottleneck moved
So I price the humans the way the API prices the model. A fully loaded senior engineer runs about $150k of salary times 1.4 of overhead, call it $210k a year, call it $100 an hour. A token is roughly 0.75 words.
| Throughput | Cost per 1M tokens | |
|---|---|---|
| Human reading (input) | ~250 wpm ≈ 20k tokens/hr | ~$5,000 |
| Human typing at sustained maximum (output) | ~50 wpm ≈ 4k tokens/hr | ~$25,000 |
| Claude Opus 5 (current API pricing) | thousands of tokens/min | $5 in / $25 out |
Both human rows are ceilings. Nobody reads for eight straight hours and nobody types 50 words a minute all day, so the real numbers are worse. Even at that sustained working maximum, a human generates tokens about 1,000 times more expensively than the model does. Human Tokens runs the arithmetic on your own numbers.
Most of a good engineering day goes into reading, deciding, and arguing. None of that shows up as words typed. (Why no "realistic daily output" row? See the claims I'm not making, below.)
So the question is:
If generation got a thousand times cheaper, why hasn't engineering output gone up a thousand times?
The multiplier is per token, not per outcome. Generation got cheaper. Verification, judgment, and coordination didn't, they're the things holding up the work now.
I'm arguing for protecting engineer attention, not for needing fewer engineers.
What the $50 feature actually cost
At those rates $50 buys around 2 million output tokens. I keep hearing that a feature "cost $50 in tokens," with the outrage of a surprise utility bill.
$50 is only the line that got printed. Writing the spec, reading the diff, sending it back, reading it again all belong on the same bill. Two hours of that is $200.
And the thrown-away runs count. It's easy to remember the accepted run and forget the two killed at minute three, but those spent spec time and tokens too. So call the feature $250. Against two loaded engineer-days at $1,600, that's a good trade. Roughly a 6x trade. The 30x version compares tokens to salary and quietly makes supervision free.
I can defend the smaller number when somebody pushes on it.
The prompt is human tokens too
The spec goes on the human side of the bill. A careful 500-word prompt is half an hour of loaded engineer time, about $50 of the priciest tokens a team buys. Frequently more than the agent's entire bill for the task it produces.
Cost per outcome = (human tokens × ~$25,000/M) + (agent tokens × $25/M)
(The human coefficient is the typing ceiling. Careful composition runs about triple, which is how that 500-word prompt gets to $50.)
The first term is a thousand times pricier. So every optimization worth doing comes back to the same thing: fewer marginal human tokens per outcome. There are two ways to spend a human token.
- Consumed. A one-off prompt. Pay the full spec cost on every run, forever.
- Capitalized. A skill, a CLAUDE.md, a checklist, a script. Write it once at the human rate, then agents can re-read it indefinitely at $5 per million, about a tenth of that when cached. Divide the human cost by the number of uses and the human cost per outcome trends toward zero.
Writing things down usually gets argued as a matter of taste. I want it on the books. The written context turns an operating cost into a capital asset: pay for the expensive judgment once, replay it mechanically.
But the usual onboarding comparison rigs the bill in the agent's favor. So here's the fair one. A human acquires context once over months and uses it free for years. An agent re-buys it every session. Caching cheapens the re-reads inside a session, and across sessions the context gets bought again at full price. Per unit of context, the human wins.
Written context earns its keep somewhere else. A person's onboarding lives in their head and leaves when they do. A skill can be read, diffed, corrected, and handed to every agent at once. One is amortized per human. The other is amortized per fleet.
What I'm not claiming
- No human output-per-day figure. Knowledge-work value isn't authored tokens. Any number I picked would deserve the objection it got.
- No claim that an agent "read" your codebase the way you read a book. Long-context degradation is real. It can locate and use information across a corpus nobody could skim in the time available. That's a different claim, and it's enough.
- The clarifying-question gap is real. It's a defect in current tooling, not proof that users are the problem.
Spend it where it pays
Right now most teams give every PR a reviewer and roughly the same attention, whether the diff renames a CSS class or alters a payment path. Same expensive token, spent flat. Once I put a price on that attention, I want to know where it actually pays.
That's the question in Agents review everything, humans review red. Different budget, same money.