Why software & software developers are not dead

Every week someone tells me software is dead. Agents can write the code now, so why would anyone pay for software, and why would anyone pay a developer to write it?

I don’t buy it. Kun Chen recently wrote a four-part series on X called software is taking off that takes this argument apart piece by piece. Kamran Ahmed’s essay To Slop or Not to Slop adds the piece the series leaves out: who owns the code after it is written. I’ve collected the main ideas from both below, with links, and added my own view after fifteen years of shipping software.

1. Cheaper software means more software

In the 1800s, engineers made steam engines far more efficient, so each one burned less coal. You would expect coal use to fall. It rose. William Stanley Jevons saw why: cheaper engines were worth running in many more places, so total demand went up. This is the Jevons paradox.

Software is about to go through the same thing. When the cost to build software drops, the price of each product drops with it. Think of a pro design suite as a cheap one-off purchase, or a whole app store for the price of one subscription. But the total amount of software grows, because far more people and businesses can now afford it, and far more people can take part in building it.

As Kun puts it: “software is nowhere near ‘dead’. it’s just about to take off.”

2. Easy tools don’t kill the professionals

We have seen this story before:

• Microwaves let anyone make a meal in minutes. Restaurants kept growing.
• Home espresso machines took off. So did coffee shops, at the same time.
• Phone cameras put a camera in every pocket. Professional photographer jobs stayed stable.
• YouTube, and later TikTok, let anyone make and share video. TV and film are still a huge industry.

People go to restaurants to be looked after and to celebrate. They hire a photographer because a wedding is special. Making something easy for everyone does not replace the professional version. It mostly creates new things that did not exist before.

Look at the apps you use most. Would you vibe code a replacement for any of them? Probably not.

3. Software is not just code

The “software is dead” argument quietly assumes that software = code. If that were true, any agent that can write the code could replace the product. But most valuable software is much more than its code:

• A network. You can clone X or Uber in a weekend. Nobody you care about will be on it.
• Infrastructure. An agent might write a search engine. It can’t build the data centres to run one.
• A business model. Someone had to work out who pays, for what, and how much, without killing growth.
• Compliance. Companies don’t buy big SaaS products for beautiful code. They buy them so someone else carries the legal and regulatory risk.
• Deals. Want to clone a music streaming service? Start with the licensing negotiations.

Some software really is just a small pile of code. Those were always the easiest products to copy, AI or not. They were never what defined the industry.

4. The developer was never the code

This is the part people really mean when they say “software is dead”: are developers done?

Kun tells a story about his mother, an accountant. Her work went from abacus to calculator to keyboard to phone calls, and she retired as the director of an accounting team. If you think accounting means “pushing an abacus”, it died decades ago. If you think it means “helping a business make the right financial decisions”, it will never stop being relevant.

Software engineering is the same:

• If your job is “I write the code other people tell me to write”, that job is already gone.
• If your job is “I write very good code”, it has a little more time, but not much.
• If your job is “I solve problems with software”, demand is growing.

Kun backs this up with job data. US software engineering job postings grew this year, in the same year that coding agents improved the most. Most of the growth came from senior roles, AI roles and forward-deployed engineers. These are people who solve real problems with precision, agency and leverage.

And when two competing companies both have the same AI, who wins? The one with better people.

5. Code is cheap to write, not to own

Kamran Ahmed tells a story about a debate with a friend about “no engineers” and “yes engineers”. His friend’s view: engineers used to say no because software was expensive to build. Now AI can build almost anything in an afternoon, so engineers should say yes, ship it, and fix it later.

Kamran half agrees. But he points out that engineers never said no because of build time. They said no because every feature you ship is something you then have to own. Someone gets paged at 3am. Someone deals with the data loss or the security incident. Someone has to remember why the system was built that way. AI can help you read, refactor and debug code. It does not carry that responsibility for you.

So he splits code into two kinds:

• Disposable code: prototypes, experiments and one-off scripts. Generate it freely. You don’t need to understand every line.
• Product code: anything people depend on. It doesn’t matter whether a human or an agent wrote it. Someone must know how it works, why key decisions were made, where it can fail, and what happens when it does.

The real skill is to notice the moment a quick experiment becomes “our system”. That moment is exactly where a developer earns their keep, and no agent will tell you when you have crossed it.

My take

My own career is proof that the tools never stay still. I started as a .NET developer in 2011. I spent eight years as a freelance Sitecore architect, moving from agency to agency and client to client. Then I moved into Web3, and now I lead AI and engineering at HYVE Media.

Every few years, the stack I knew best became less important. The work never did. Every client, every contract and every product came back to the same thing: understand the problem, design a system that solves it, and get it into production.

AI hasn’t changed that. It has made the leverage enormous. Today I can take an idea from a rough brief to a live product faster than ever.

The biggest opportunity with AI isn’t rebuilding old software for free. It’s building things that couldn’t exist before.

If you’re a developer, here is what I’d do

1. Own the problem, not the ticket. Ask why before you ask how.
2. Learn the domain. Understand the business you are building for. That knowledge doesn’t come in a model.
3. Think in systems. Architecture, data, infrastructure, security and cost are where judgment matters most.
4. Use agents as leverage. Let them write the code you would have written anyway, and spend your time on the parts only you can do.
5. Say yes to experiments, and own what ships. Prototype freely. When it becomes product, make sure someone understands it.
6. Build something new. Don’t just ask what AI can copy. Ask what AI makes possible for the first time.

$ cat tl;dr.txt
software is not dead.     cheaper code = more software
developers are not dead.  the job was never the code
the job is:               solving problems with software
the cost is:              owning it, not writing it

Sources

Kun Chen’s series software is taking off, on X:

1. Part 1: Jevons paradox
2. Part 2: What happened in other industries
3. Part 3: Software is not just code
4. Part 4: Is software engineering dead?

Kamran Ahmed, To Slop or Not to Slop, September 2026.