Why Perfect Software Would Bankrupt the Tech Industry

November 23, 2025

🧨 The Programmer’s Full-Employment Edict:

 

By Jesse Brin — Brinovation, Inc.

Software is a strange beast.

Unlike every other product humans manufacture, it doesn’t rot, rust, deform, fade, or wear out. A function you wrote in 1987 —

 
function Add(a, b) { return a + b; }

— will work perfectly in 2087, provided the universe behaves itself.

And yet somehow, despite this remarkable longevity, the software industry is one of the most unstable, churn-heavy, perpetually breaking ecosystems on the planet.

Why?

Pull up a chair. We need to talk about something I’ve joked about for years with colleagues — but which turns out not to be a joke at all.

I call it:

⭐ The Programmer’s Full-Employment Edict

“If software can’t fail naturally, the environment must be updated until it breaks.”

Let me explain.

🧬 1. Software Does Not Decay… but the Ecosystem Does

Software has no half-life.

  • Bearings wear out.

  • Wood splits.

  • Metal oxidizes.

  • Flesh ages.

  • Lubricants degrade.

But code?

It just sits there. Perfect. Eternal. Indifferent to time.

The only reason your once-beautiful application stops working is because the environment around it — OS, browsers, APIs, libraries, frameworks, cloud services, package managers — changes out from under it.

Your user doesn’t care.
Your app hasn’t changed.
And yet it’s “incompatible.”

Welcome to Dependency Drift, and its nastier cousin Version Hostaging.

🧨 2. The Perfect App Would Destroy the Software Industry

Let’s imagine, for a moment, the mythical “Perfect App.”

It:

  • Solves the pain it was built to solve — completely.

  • Requires no training because its UI is intuitive.

  • Has no bugs.

  • Needs no patches.

  • Never misbehaves.

  • Runs identically in 20 years.

A beautiful idea, yes?

A business catastrophe, absolutely.

Because if such a thing existed…

  • There would be no 2.0.

  • No migration projects.

  • No upgrade/renewal revenue.

  • No consulting ecosystem.

  • No support staff.

  • No certification courses.

  • No new frameworks.

  • No conferences.

  • No DevOps.

  • No cloud lock-in.

  • No venture capital.

The industry would gently collapse, like a soufflĂŠ made without enthusiasm.

The Perfect App is economically incompatible with the current software ecosystem.

🏗️ 3. So the Industry Must Manufacture “Wear and Tear”

Since software doesn’t age on its own, the industry must simulate aging through structured, perpetual churn:

  • APIs get deprecated.

  • Frameworks reinvent themselves.

  • Operating systems drop support.

  • JavaScript introduces new flavors weekly.

  • Vendor libraries promise backward compatibility and deliver heartbreak.

  • Security advisories create urgency.

  • Cloud providers change billing, endpoints, protocols.

  • Browsers “modernize” their engines.

  • Toolchains mutate into new toolchains.

This is not conspiracy — it’s economics.

Industry survival depends on never letting software stay finished.

🧩 4. Users Want Stability. Vendors Want Movement.

This fundamental tension drives everything in modern tech.

Users want:

  • Familiarity

  • Predictability

  • A tool that works every day

Vendors want:

  • Recurring revenue

  • Churn

  • Upgrade cycles

  • Subscription entrenchment

  • Lock-in

Because in software, revenue doesn’t come from perfection.

It comes from the process of reaching it, asymptotically, forever.

The result is what I’ve dubbed the Programmer’s Full-Employment Edict:

To prevent market collapse, software must be kept in a perpetual state of becoming — never being.

🎭 5. And This Is Why You’re Still Refactoring Working Code

If you’ve ever told a non-technical person:

“Yes, the app works fine, but we have to update it because something it depends on changed…”

…and watched their eyes glaze into existential despair, congratulations.
You’ve experienced the Edict firsthand.

Your code didn’t break.
The world moved underneath it.
And your team gets to fix it.

Thus, the software economy stays warm and fed.

🧠 6. So Should We Rage Against This? Or Accept It?

A bit of both.

The churn is real, sometimes justified, often not.
Security progress is real.
Innovation is real.
But so is unnecessary reinvention.

And so is the reality that if software could be perfect and permanent, the industry as we know it would vanish.

So the next time you’re stuck rewriting perfectly functional code due to a "framework upgrade" or an "API sunset" or an "incompatible browser change," just remember:

You’re not fixing a bug.
You’re participating in the foundational economic ritual of modern computing.

You are, in a very real sense, upholding the:

⭐ Programmer’s Full-Employment Edict

“Software must be endlessly updated so the people who write software never become obsolete.”

And honestly?

Given how many industries automate their workers out of existence…
it’s almost poetic that this one engineered a mechanism to guarantee its own survival.

What about the impact of AI?

Stay tuned. I'll have much more on that subject in a later post.