Blog

Most Software Should Die Young

CN Camilo Nova Camilo Nova

Camilo Nova

CEO
6 min read.

The most expensive software you'll ever own might be the software you built for free.

I think companies should encourage their employees to build more software. Even badly written software.

That might sound strange coming from someone who has spent almost two decades building software professionally. But AI has changed the economics of software development, and I think we need to rethink software itself.

For decades, building software required specialized knowledge. You needed developers who had spent years learning programming languages, databases, infrastructure, and everything else involved in making software work.

The more experienced the developer, the more expensive they were. But generally, you were also paying for better quality.

Expertise was directly related to your ability to create software.

AI changed all that.

Today, someone with absolutely no programming experience can describe a problem to an AI tool and get a working application in minutes.

You can create prototypes, automate processes, build internal tools, and test ideas that previously would have required hiring a development team.

And I think that's fantastic.

But here's where I disagree with the idea that everyone is suddenly a software developer.

Knowing how to make software work isn't the same as knowing how to make software last.

I believe we're entering an era where we need to distinguish between two categories: disposable software and durable software.

Disposable software

Imagine you're running a company and want to test a new pricing strategy.

Before AI, you'd probably use a spreadsheet, ask your technology team for help, or decide the experiment wasn't worth the investment.

Today, an employee can build an application in an afternoon. They can test different prices, share the results with colleagues, and see whether the idea works.

If it doesn't, they throw the application away. No problem.

That's what I call disposable software. Software created to solve a specific problem, test an idea, or improve a process, without expecting it to last for years.

And here's my first take:

Most software should be disposable.

Companies spend too much time discussing ideas and too little time testing them.

We create committees, write requirements, prepare budgets, and spend weeks deciding whether something is worth building. Not to mention the crazy amount of time estimating the cost of software.

Now we can just build it and find out.

I would encourage employees to create ten different applications, knowing that nine might eventually be discarded.

Because the objective isn't to create ten great pieces of software. It's to discover which ideas actually generate value. If nine applications disappear but one helps the company improve an important process, the experiment was worth it.

Of course, disposable doesn't mean reckless. You still need to protect sensitive information and avoid exposing critical company systems. But you don't need to engineer every experiment as if thousands of people will depend on it.

The beauty of disposable software is that it doesn't need to be perfect. It just needs to help you learn faster.

The problem with successful software

Now imagine that one of those ten applications becomes incredibly useful.

It starts with three employees. Then an entire department begins using it. Eventually, other teams discover it, and the company starts making important decisions based on the information it provides.

Congratulations. You've found something valuable. But you've also created a new problem.

The application was built in an afternoon, probably without much consideration for security, reliability, scalability, or maintenance.

Nobody expected it to become important. And yet, people now depend on it.

The most expensive software you'll ever own might be the software you built for free.

Because the application that took an afternoon to build can eventually cost you thousands of dollars in operational problems, lost revenue, security incidents, or technical limitations.

What started as a successful experiment becomes a liability.

This is the paradox of disposable software.

When an experiment fails, you can simply delete it.

When it succeeds, it becomes increasingly difficult to replace.

And the longer you depend on something that wasn't designed to last, the more expensive the problem can become.

That's why I believe companies need to recognize the moment software stops being disposable.

And that moment has nothing to do with how many features it has or how sophisticated it looks.

It's about dependency.

If an application breaks and nobody really cares, it's probably disposable.

If it breaks and your company loses money, interrupts operations, or disappoints customers, you need to start thinking about durable software.

Durable software

Durable software is software designed to be relied upon.

It doesn't necessarily have more features or a better interface.

In fact, two applications might look exactly the same to their users, even though one is disposable and the other is durable.

The difference is what's underneath.

Durable software needs proper security, reliable infrastructure, good architecture, testing, maintainability, and the ability to evolve as the business changes.

These are things that are difficult to appreciate until something goes wrong.

And this is where experienced software engineers become essential.

There's a popular argument that AI will eventually eliminate the need for software developers.

I see it differently.

AI is making writing code increasingly accessible. But that doesn't eliminate the need for engineering judgment.

Someone still needs to understand how the different parts of a system interact, what could go wrong, how to protect information, and how to ensure the application can continue working as the company grows.

And those decisions require experience.

AI makes software easier to build. It doesn't automatically make software easier to trust.

The interesting part is that professional developers also use AI.

They use the same tools to build faster, automate repetitive tasks, and reduce development costs.

But they'll bring something that the person creating their first prototype probably doesn't have: the experience to recognize problems before they happen.

I think that's where the value of software expertise is moving.

Not just knowing how to write code, but knowing which code should exist, how it should be structured, and what it takes to keep a system reliable over time.

Don't fall in love with your code

There's another important distinction.

Turning disposable software into durable software doesn't necessarily mean taking the original application and adding more features, improving the design, and fixing a few bugs.

Sometimes, the right thing to do is rebuild significant parts of it. And that's okay.

The original application already did its job. It proved that the idea had value. It helped people understand what they needed. It generated feedback. It revealed how the business actually works.

All of that knowledge is incredibly valuable.

When experienced engineers come in, they shouldn't ignore what's already been built. They should study it, understand the business logic, reuse whatever makes sense, and rebuild the foundations that aren't strong enough.

Sometimes most of the original code can survive. Other times, almost none of it should.

Don't fall in love with your code. Fall in love with what you've learned from it.

I think this is particularly important because AI lets us create software so quickly that we can become attached to it before we've properly evaluated it.

Just because something works doesn't mean it's finished.

And just because you spent time building something doesn't mean you should keep it forever.

Build to discover. Engineer to protect.

Here's how I think companies should approach software going forward.

Encourage experimentation.

Give employees access to AI tools. Let them build applications to solve problems, test ideas, and explore opportunities.

Don't require every idea to go through a professional development team.

That would defeat the purpose of having such powerful tools available to everyone.

But establish a clear boundary.

When an application becomes essential to the business, treat it differently.

Bring in experienced engineers. Evaluate what already exists. Keep what works, rebuild what doesn't, and make the investment necessary to turn it into something reliable.

For the love of God, don't ask them to estimate how much it will cost; just let them build it.

And don't assume every successful experiment needs to make that transition.

Some applications are valuable precisely because they're temporary.

For years, software development was expensive enough that companies had to carefully choose what to build. Now, creating software is becoming so inexpensive that we can afford to experiment with almost everything.

But the cost of depending on unreliable software hasn't disappeared. That's the distinction I think business leaders need to understand.

We're moving from a world where software was expensive to create to one where software is cheap to create, but still requires serious investment to operate reliably.

We'll create more software than ever before, discard most of it, and invest in making the valuable applications durable.

The mistake would be treating every prototype as a permanent system. Or treating every experiment as if it needed to be engineered for the next ten years.

We need both.

Build software to discover value. Engineer it to protect value.

Most software should die young. The survivors must grow up fast.


Written by Camilo Nova

CN Camilo Nova Camilo Nova

Axiacore CEO. Camilo writes thoughts about the intersection between business, technology, and philosophy

Stay ahead of what's next.

Get fresh ideas, insights, and practical perspectives on AI, technology, and digital products, straight to your inbox.

We respect your inbox. Privacy policy

Wait. There's more:

NDAs Are Effectively Useless

Your NDA won't stop AI from copying your product. The real edge is something your competitors can't just clone.

4 min read.