Every time a new productivity technology arrives, the same prediction appears: “Now we will need fewer people doing this work.” And every time, Jevons Paradox shows up and makes that prediction look shallow.

Jevons Paradox says that when efficiency improves, total consumption often increases instead of decreases. Cheaper coal use did not reduce coal demand in Jevons’ time; it expanded it. The same dynamic now applies to software.

AI agents make code generation, refactoring, and prototype iteration dramatically cheaper. The naive conclusion is that programmers become less important. The actual result is the opposite: software demand explodes. More ideas become viable. More experiments get run. More edge-case products get built. More integrations get attempted. More systems need stewardship.

That is why some programmers will struggle—not because agents replace programming, but because they change what good programming looks like.

The old model rewards typing throughput

In the old model, a strong programmer could win by:

• remembering frameworks,
• writing lots of syntax quickly,
• manually stitching things together,
• being the bottleneck that turns specs into code.

In an agent-rich model, those advantages are commoditized. An agent can produce huge amounts of plausible code in minutes. Raw output volume is no longer scarce.

If a programmer’s identity is tied to “I write more code than others,” agents feel like a threat.

The new model rewards judgment under abundance

With agents, the scarce skill shifts from production to selection:

• Which output is worth keeping?
• Which architecture survives real-world change?
• Which security risks are hiding in generated convenience?
• Which prompt and constraints produce maintainable behavior?
• What should not be built at all?

The hard part is no longer starting; it is deciding. No longer drafting; curating. No longer coding alone; orchestrating systems of human + agents.

Jevons means more software, not less responsibility

As agent leverage increases, teams will attempt more features per quarter, more customer-specific variations, more cross-system automation, and more rapid iteration in production-like environments.

That creates a paradoxical load increase on developers who cannot operate at orchestration level. Someone still has to own correctness, reliability, rollback paths, observability, data boundaries, and long-term code health.

If you expect agents to reduce complexity, you will be disappointed. Agents reduce friction to create complexity. That is not the same thing.

Who thrives

Programmers who thrive with agents do three things well:

1. Constrain — define crisp boundaries and acceptance criteria.
2. Critique — aggressively review output quality and assumptions.
3. Compound — build reusable workflows, not one-off prompts.

If you treat agents like autocomplete on steroids, you stay tactical. If you treat them like junior operators requiring management, you level up.

Closing

Jevons Paradox does not predict the death of programmers. It predicts an explosion in software ambition. In that world, programmers who cling to pure implementation identity will struggle. Programmers who evolve into orchestrators of quality, intent, and systems will become more valuable than ever.

So the real question is not whether programmers can code with agents. It is whether they can think in the new economics of software abundance.