The argument: as AI lowers the cost per feature, companies don't save money — they build far more features (Jevons paradox applied to software), producing ever-larger, more complex codebases. Then the video walks through how LLMs actually read code (tokens, embeddings, causal attention) to show why those same models struggle to maintain what they build: context windows are finite, attention is O(n²), long contexts suffer from 'lost in the middle,' sparse attention can skip critical links, and retrieval fails when coupling isn't expressed in code. The result is a self-reinforcing loop where the tool generating the complexity is the tool least able to comprehend it.
- Modeling a feature backlog as bars whose height is business value shows that as the price per feature drops from $6,000 to $1,000, the number of worth-building features jumps from 2 to 17 — feature demand is highly elastic, so total spend goes up, not down.
- Even in the least elastic scenario modeled (elasticity below one), the number of features built still increases; the direction of more code is not in dispute.
- This is Jevons paradox: just as more efficient steam engines increased total coal consumption after 1865, cheaper software development is expected to increase total software spend rather than reduce it.
- A brief primer on how models read code: tokens map to IDs, IDs map to high-dimensional embedding vectors, and causal attention mixes in meaning from all prior tokens across multiple layers, so two identical tokens end up with different vectors depending on context.
- The context window is a hard limit on comprehension — AI can verify that a change doesn't break modules inside the window, but cannot check anything outside it, and may infer wrong data shapes for functions it can't see.
- A subtle failure case: a loop that looks linear calls an out-of-window function that is itself linear, so the AI accidentally introduces quadratic behavior that only shows up at scale.
- Simply enlarging the window doesn't fix it: models exhibit 'lost in the middle,' ignoring detail buried mid-context, and attention cost is O(n²), so doubling the window roughly quadruples the work on every query.
- Sparse attention reduces comparisons but can miss a critical link even inside the window, and retrieval fails when two modules are coupled through a database rather than through a code reference — there's nothing to search for.
This is the economic core of the video — the counterintuitive claim that AI will raise, not lower, total software development spend.
Similar to how more efficient steam engines resulted in less coal to do the same thing in 1865, more efficient software development results in less money to build out the same things in 2026... but the reality is back then coal consumption increased substantially.
A concrete, realistic failure that shows why indexing the codebase doesn't solve coupling that lives outside the code.
Since the nightly report reads from the order DB directly, there's no reference to it anywhere in the code that the AI is looking at. This results in the nightly report not being updated and discounts being subtracted from the totals twice.
Even when the code is correct, even when it compiles, passes every test, does exactly what you asked for, there's still too much of it.
To the AI, that giant window isn't a grid of modules. It's one long line of tokens start to finish.
The sheer volume of new code creates systems so large and complex that the very tool used to build them — AI — is having a hard time comprehending and maintaining them due to its own limitations.