Skip to content
← All Posts

AI will increase the demand for software engineers

No one knows the future. And I don’t know if I believe this 100%—but it’s worth saying out loud amid all the AI hype.

There’s a solid economic argument for why “better tools” often increase total usage of the thing they make cheaper. It’s commonly discussed as Jevons’ paradox (or, more generally, the “rebound effect”).

Jevons’ paradox in one sentence

When a technology makes a resource more efficient to use, the effective cost of that resource drops—so people and organizations often use more of it, sometimes enough to offset the efficiency gains.

Jevons originally pointed this at coal: making coal-powered industry more efficient didn’t reduce coal use; it helped expand coal-driven production. Modern energy-economics work reframes this as rebound effects that can be small or large, but are real enough to matter.

What’s the “resource” in software engineering?

It’s not code. It’s not compute.

The constrained resource is human effort required to turn intent into working, maintainable software:

  • translating fuzzy requirements into concrete behavior
  • implementing and integrating
  • iterating and experimenting
  • writing glue code and tests
  • debugging and operating

AI reduces the marginal cost of a big chunk of that work—especially drafting and iteration.

Why the Jevons structure fits AI + software

Jevons-style “backfire” tends to show up when three things are true:

  1. There’s a binding cost (time/effort to build software)
  2. Efficiency reduces marginal cost (AI makes “one more feature / one more experiment” cheaper)
  3. Demand is elastic (when it gets cheaper, you build a lot more)

Software demand is extremely elastic because:

  • distribution is nearly free
  • feature expectations expand with possibility
  • automation unlocks tasks that were previously “not worth building”
  • new capability creates new products, not just cheaper old ones

So the “time saved” doesn’t vanish—it gets reinvested into scope expansion.

Early signals: AI raises throughput, not “completion”

We already have enough signal to believe AI coding assistants can boost developer speed on certain tasks.

The important part isn’t the exact percentage. It’s what organizations do with the extra throughput:

  • ship more features
  • explore more options
  • spin up more internal tools and integrations
  • build more products per team

That’s the rebound.

“So engineers become unnecessary?” Not quite

Even if AI makes output cheaper, software complexity and responsibility still compound:

  • architecture choices accumulate
  • debugging and operations don’t scale linearly with code generation
  • security and correctness still need accountability
  • product decisions and tradeoffs still require judgment

In practice, the bottleneck shifts: from typing → to judgment, constraints, and stewardship of complexity.

A grounded prediction

A Jevons-style view doesn’t claim:

  • every company will hire more engineers
  • every engineer will be safe
  • the market won’t change (it will)

It claims something narrower:

If AI lowers the marginal cost of building software, and demand remains highly elastic, total software creation expands—so the need for engineering talent shifts upward and outward (more domains, more products), not to zero.

Even official projections (not AI-specific) still expect strong growth in software developer roles over the next decade.

I’m not certain this is how it plays out. But “AI replaces engineers” assumes demand for software is basically fixed.

Historically, when a powerful tool makes building cheaper, the world doesn’t stop building. It builds more.

References

← All Posts