Durable Software in an Age of Abundance

Maybe this sounds familiar

You went fast. AI made it possible to build, and rebuild, almost anything. For a while it felt great.

Then things started to go wrong. Bugs show up in places nobody expected. Fixes cause new problems. Customers start to notice. Dates slip. Outages take longer to fix, because fewer people understand how the system really works. The system is harder to trust. When you ask your team what's wrong, they don't quite know. Their answers keep getting vaguer.

Part of it is simple. Going too fast lets disorder creep in. Soon there's more code than anyone understands.

But there's a deeper cost too. Building something used to be a journey, and the journey is where the learning happened. You found the hard parts, made mistakes, and came to understand the system along the way. When you jump straight to the destination, you skip all of that. You end up with the thing, but without the understanding that used to come with it.

Whatever the cause, if that's your company today, keep reading.

Software is abundant now

For most of the history of software, it was scarce. Building anything took so much time and money that software tended to be durable by default. The economics never made throwing parts away an option.

That's changed. For the first time, software can be disposable. Prototypes, experiments, internal tools, screens that change every month. Build them fast, use them, throw them away, build them again. Disposable software also makes personalization possible for each customer, each team, even each user. That level of personalization was never worth building before. Now it can be.

But it brings a decision most teams have never had to make. Which parts can be disposable, and which must be durable? The parts your customers trust, the data you can't lose, and the core everything else stands on still need care, real understanding and the time to get them right.

In my experience, the damage rarely comes from using AI. It comes from never deciding, on purpose, which parts can be disposable and which must be durable.

How I think about technology

Over my years as a CTO, I've come to believe that every new technology has a boundary. That boundary has a size and a shape. Some use cases sit inside it, where the technology can accelerate them. Other use cases sit outside it, where it struggles, or quietly causes harm over time.

One thing that separates good technologists from bad ones is that they see the boundary clearly and place each use case on the right side of it.

Many technology failures come from getting the boundary wrong. Hype makes it look bigger than it is. And when a technology is new, everything starts to look like a nail for the shiny hammer. AI is no exception. Its boundary is wide, real and growing. The parts of your software that must be durable are where getting the boundary wrong costs the most.

What working together looks like

I work as a fractional CTO, a part-time CTO who works with your leadership for a few days a week or month. I start by deeply understanding your product and technology, and how they fit your business. I get there by asking hard questions. Where you have good answers, we build on them. Where you don't, we work through them together. Then I work with your team to make clear architectural and design decisions. One of the most important is which parts can be disposable, so you can go faster, and which must be durable, where it's worth taking the time. Another is giving the durable parts clear interfaces, so AI agents and disposable software can build on them safely.

It starts with a conversation to see whether we're a good fit. I only take on work where the business feels the problem, not just the technology team. You may not know exactly what the problem is or where it lives. But you know there is one, and you're serious about fixing it. If it isn't the right time, I'll tell you.

If this is you

If this feels uncomfortably familiar, I'd like to hear your story. If it sounds like a company you know, please pass it on.

— PJ Kirner

Co-founder and former CTO of Illumio & Knit AI. Previously a Distinguished Engineer at Juniper.