Agentic coding collapses the price of producing code. The naive reading is that software spend falls. The Jevons paradox says the opposite is possible: when the price of a good falls, the quantity demanded can rise by more than the price fell, and total spend goes up. The entire argument reduces to one empirical parameter — the price elasticity of demand for software — and it says nothing on its own about whether developers capture the new spend. Software has climbed this ladder for seventy years and has never once produced the “less software” outcome; the caveats are about when the ladder ends, not whether the rung exists. The synthesis (§4a): the input that did not get cheap is not running verification but gating the criteria — and Jevons raises demand for exactly the thing the oracle pages say cannot be terminally supplied.
Links: Economics, Arithmetic as a Purchase (the vault’s own sixty-year Jevons specimen — multiply got cheap and was consumed by orders of magnitude more), The Theory of the Firm (Coase — cheaper internal production moves the build/buy boundary inward), The Cyborg Model (which input didn’t get cheap), Oracles Are Objective Functions (no terminal oracle — the floor is adopted, not discovered; the add(a,b) argument lives there), The Contract Model vs. the Substrate Model (adopt / hold / retire — the verification layer as the un-automated component), Career Strategy (where the conclusion lands), Lemonade Stand Agents (what agents still can’t buy cheaply: unit-economic judgment), The Supply Omission (supply creates demand: the cross-sector half of §3(b)), Dad Saves America — Jevons, Say’s Law (citable source for the 1865 coal case)
Thesis page (portable). Sparked 2026-09-16 by a YouTube explainer Chris watched that made the argument by name — Jevons paradox — and with the coal case as its empirical anchor. The video itself is unsourced here (YouTube is blocked on the network the discussion happened on, so no title, URL, or transcript was captured; nothing below is attributed to it beyond “it made the Jevons argument with coal”). Chris’s own framing: “a nice mix of economics and AI agency, probably more obvious than anything.” The vault’s contribution is not the paradox — it is separating the three claims that ride on it and naming the one that actually matters.
William Stanley Jevons, The Coal Question (1865): Watt’s engine used far less coal per unit of work than Newcomen’s, and Britain’s coal consumption rose. Efficiency lowered the effective price of steam power; steam power became worth applying to things it had never been worth applying to; the new applications consumed more coal than the efficiency saved.
The arithmetic is just spend = P × Q. Let P fall by some fraction. Q responds according to the price elasticity of demand, ε:
| Regime | ε | What happens to Q | What happens to P × Q | ||
|---|---|---|---|---|---|
| Inelastic | < 1 | rises, but by less than P fell | falls — the naive prediction | ||
| Unit-elastic | = 1 | rises exactly as much as P fell | unchanged | ||
| Elastic | > 1 | rises by more than P fell | rises — Jevons |
| The energy-economics literature calls the general phenomenon the rebound effect and reserves backfire for the | ε | > 1 case where the rebound exceeds 100%. Jevons is backfire. So the argument “cheaper coding → more software spend” is exactly the claim ** | ε_software | > 1** — an empirical claim about a demand curve, not a theorem. Anyone making the argument owes a reason to believe demand for software is elastic; anyone rejecting it owes a reason to believe it is not. |
The industry has been running this experiment for seventy years and the result has come out the same way every time. Assembler → compilers → high-level languages → libraries and open source → cloud → frameworks. Each rung cut the cost per delivered feature by a large factor, and each time total software spend — and, for most of that history, total developer employment — grew. Agentic coding is the next rung on a ladder that has never yet delivered the “less software” outcome. That is a strong base rate, and it puts the burden on the pessimist.
The vault already holds the same curve for a different good. Arithmetic as a Purchase traces fast multiplication from a $325/month line item on the IBM 1401 to a free instruction, and the demand side of that page is Jevons unlabeled: multiply did not get saved, it got spent — on 3D, on spreadsheets, on everything that was never worth a multiply before.
Where the extra Q comes from is the long tail of software that was never worth writing. Internal tools. One-off automations. The spreadsheet that should have been an app. Reverse-engineering harnesses for thirty-year-old cartridges. Personal software with an audience of one. The threshold “is this worth a developer’s month?” excluded almost all conceivable software; lower the threshold by an order of magnitude and the volume below it is enormous. This vault is a local specimen. The decompiler tool banks, the beat-grid benchmark, the raw/ immutability hook, the derive-tools that regenerate tags/ — none of it would have been produced at 2023 prices. It exists because the price crossed a threshold, which is the Jevons mechanism observed from the inside.
The most recent high-profile invocation was aimed at AI compute, not coding: when DeepSeek R1 (January 2025) undercut the assumed price of inference, Satya Nadella’s public response was “Jevons paradox strikes again” — cheaper tokens would mean vastly more tokens consumed, not a smaller market. The same frame, one layer down the stack.
The argument as usually made bundles three claims. The paradox supports one.
(a) Total spend on software rises. This is what Jevons delivers, conditional on elasticity. It is the claim the video made, and it is the claim the seventy-year base rate supports.
(b) Spend on developers rises. Jevons says the good gets consumed more. Whether the humans who used to produce it capture the new spend depends on what share of the new cost structure is human labor vs. agent inference — a completely separate question. James Bessen’s two cases bracket it:
Both are consistent with P × Q rising. They diverge on the labor share, and they diverge over time. So “+spend” does not imply “+coders”; that inference needs its own argument about complementarity, and the conclusion “developer jobs are safe” is not something the elasticity argument can deliver by itself.
The other half of the ledger: cross-sector transmission. The ATM/loom comparison only counts the producers. Cheaper output also raises the real wage of everyone who buys it, and the spending that frees up becomes demand in other sectors. That is how productivity growth in one place turns into rising wages elsewhere (The Supply Omission: the reverse statement). So even the loom outcome is an aggregate gain: weavers lose, cloth buyers gain. That is also the honest source of the fear. Chris: “the gains do not always land on those being affected.” Whether developers capture the new spend is the distribution question, and the aggregate argument can’t settle it. (Specimen: Dad Saves America — farmer → cheap food → blacksmith’s real wage.)
(c) The regime is permanent. It is not. Elasticity is a phase, not a constant. Demand is elastic while a large stock of latent, unmet uses sits just below the price threshold; it turns inelastic as those uses are exhausted. The weaving case is the whole arc in one industry — Jevons regime, then saturation, then displacement. The live question for software is therefore not “is demand elastic?” but “how far from saturation is it?” — and the honest answer is that the long tail looks vast and nobody has sized it.
Software is a bundle: specification, generation, verification, integration, maintenance. Agentic coding collapsed the price of generation. The other components did not fall nearly as fast — and the vault’s own standing thesis is that verification in particular is the binding constraint (the two oracles, the substrate model, the kernel rule that verification independence means dropping to a lower artifact).
Two consequences follow:
“Verification” is too coarse. Running a check is automatable and is already cheap — an agent will execute a test suite, a bytecode diff, or a regen-guard all day. What did not get cheap is choosing the check and deciding when it is enough. The vault’s oracle pages hold the reason: no terminal oracle exists — an oracle that could certify an answer could also produce it (Oracles Are Objective Functions) — so every standard in use is adopted, not discovered, and the method is adopt, hold, retire (the substrate model). Chris’s pre-LLM form of the same point is the add(a, b) argument: the test domain is infinite or impractical for nearly every function, so “fully tested” is a fiction and every suite is a chosen good-enough. The human value-add is gating the criteria — where good-enough sits, for this artifact, and when a standard that used to discriminate has flattened (“all-pass is the signal”).
Put the two halves together and the page’s strongest claim appears. Jevons says induced software volume raises the demand for gating — each new artifact is both new software and a new thing the oracle chain must reach, which is why the burden of checking gets deeper as the tool bank grows, not shallower. The oracle pages say the supply of gating is bounded by human altitude — the grounding regress bottoms out at the person (the grounding regress), and headcount does not substitute for altitude. Rising demand against a supply that cannot scale is a price-rise prediction — Baumol, exactly, for the one component of the bundle that neither got cheap nor can be terminally solved. That is a stronger claim than either page makes alone, and it is the specific form of “the human holds the input that didn’t get cheap.”
This is where the page connects to Career Strategy. Whoever owns the verification and specification layer is holding the input that did not get cheap, in a market where the total volume of software is — if the elasticity claim holds — about to rise sharply. That is a considerably more specific and more defensible position than “developers will be fine.”
| Claim | What it needs to be true | What would falsify it |
|---|---|---|
| Spend rises | |ε| > 1 over the relevant range | measured software spend falling as agent adoption rises, controlling for the cycle |
| Developer employment rises | human labor is a strong complement to agent generation (ATM case, not loom case) | employment falling while spend rises — the loom outcome |
| The regime persists | the latent long tail is large relative to current output | saturation signatures: falling marginal value of new software, ε drifting toward 1 |
| The career conclusion (§4) | verification/specification stays hard to automate | agents acquiring reliable, independent verification — at which point the whole bundle is cheap and the argument reverts to pure elasticity |
economics · ai · agents · software-engineering · career