LLMs, Software, and the Jevons Paradox
The future of software development in the age of LLMs may seem uncertain, but history offers a useful lens: Jevons Paradox.
Jevons Paradox describes a counterintuitive effect where increased efficiency in using a resource leads to higher overall consumption. During the Industrial Revolution, more efficient steam engines made coal cheaper. Instead of reducing coal usage, this enabled more factories and engines, driving total coal consumption up.
The same pattern appears across industries:
-
Coal: Efficient steam engines reduced the cost of power, making industrialization viable at scale. Factories multiplied, and total coal consumption soared.
-
Cars: Better fuel efficiency lowered the cost per mile, which encouraged more driving, longer commutes, and more vehicles on the road.
-
Electricity: Efficient hardware reduced operating costs, enabling more devices, larger data centers, and always-on services.
In each case, efficiency expands demand.
What People Get Wrong About Software Development with LLMs
The most common mistake is assuming that faster code generation means less need for software engineers. In reality, LLMs reduce the cost of writing code, not the cost of owning software. As more systems are created, the work shifts toward architecture, integration, security, reliability, and long-term maintenance. The real constraint becomes judgment and accountability, not implementation speed.
The Same Dynamic Applies to Software
LLMs drastically reduce the cost of producing software. Code generation, scaffolding, debugging, and documentation are all faster and cheaper. But the most important effects show up downstream:
-
Developers don’t write less code. They build more systems, faster, with broader scope. Features once deemed “not worth it” now ship by default.
-
More people build production software. Non-technical builders ship internal tools and automations that move into production. Engineering work doesn’t disappear. It’s redistributed toward review, stabilization, and integration.
-
Small and short-lived software proliferates. One-off apps and niche tools become cheap to create, forming an ecosystem that must be monitored, maintained, and retired.
-
Maintenance and integration dominate. More systems mean more APIs, data flows, permissions, and failure modes. LLMs accelerate creation, but also accelerate complexity accumulation.
-
Engineering work shifts upward. Less time on boilerplate and syntax, more on architecture, security, and long-term consequences. Developers become stewards of systems rather than producers of lines of code.
-
Judgment becomes the bottleneck. The constraint shifts from typing speed to decision quality. Differentiator becomes ability to make correct, durable technical choices.
Net Effect
LLMs don’t reduce software work. They lower the threshold for creation, triggering an explosion in software volume and participation. As with Jevons Paradox, efficiency increases total output and with it, the need for experienced engineering judgment to manage growing complexity.
Great X posts on the subject
