Your Code Isn’t Special Anymore. Now What?

With LLM-powered code generation tools, you can sit down, describe a product in plain English, and watch working code appear. What’s changed isn’t just the speed, it’s the interface itself. The barrier between idea and execution has collapsed into language. It’s not perfect and it’s not always elegant, but it’s increasingly good enough to ship, demo, and, more importantly, make you pause and wonder what part of this was ever supposed to be hard. And that pause leads to a slightly uncomfortable question.

If software can be generated this easily, does the cost of building it trend toward zero? And if it does, is it even worth keeping it proprietary? If it doesn’t, then what actually changes?

This isn’t a philosophical argument about open source being good or bad. It’s a practical, economic one. If something that once took months or years can now be approximated over a weekend with a decent prompt, too much coffee, and questionable sleep decisions, what exactly are you protecting?

For a long time, we’ve operated under a shared assumption, close enough to a religion, that the code itself is the value. You hire smart engineers, build proprietary systems, and wrap it all in just enough mystery to call it a moat. It feels rational. It feels earned. It’s the story people fund, scale, and repeat.

But GenAI doesn’t really care about that story. It just keeps generating code cheaper, faster, and more accessible. And when something becomes abundant, it stops being the thing that differentiates you.

Which brings us to the more direct version of the question that’s been sitting underneath all of this:

If your app’s code is free forever… what exactly are you selling?

How We Got Here

We didn’t get here overnight. It’s been a gradual shift, the kind you don’t fully notice until the shape of things starts to look a little different.

Open source was the first shift. Quiet, almost polite. Linux, Kubernetes, Postgres, massive pieces of infrastructure that nobody really owns, but everyone depends on. Entire companies built on top of them. We celebrated it, called it community, called it progress, and kept moving without asking what it meant for differentiation.

Then cloud came along and removed another layer. You didn’t need to own the machines anymore. Infrastructure became abstracted, then commoditized, then invisible. It was liberating. It was efficient. It also quietly stripped away another place where advantage used to live. And almost overnight, starting a company began to look… easy. Still emotional, still soul-crushing, but at least the upfront cost collapsed. You no longer needed racks of servers and a small army to get something off the ground. That shift didn’t just change how companies were built; it changed how many could exist. Programs like Y Combinator went from funding dozens to hundreds a year, and now thousands, of companies, because the cost of trying dropped so low it was almost irresponsible not to.

And now GenAI enters the room, like a bull in a china shop that somehow thinks it’s being polite, casually knocking things over while insisting everything is fine, and starts producing working software at a pace that would have felt absurd a few years ago, more like a vending machine for code than anything resembling craftsmanship. You describe something in plain language, and it gives you code. Not perfect, sometimes a little strange, but increasingly good enough to matter.

That phrase, good enough, is doing a lot of work here. Because when something becomes good enough, fast, and cheap, it stops being special. It becomes expected. And once it’s expected, it’s very hard to build a business around it being scarce.

Where Value Moves

This is where the old idea of “software as the moat” starts to feel a little dated. Not wrong, exactly, just incomplete. If most of what you’ve built can be recreated quickly with the right tools and a bit of persistence, then the code itself isn’t acting as a meaningful barrier. It still matters, but it’s no longer what keeps others out. Software is starting to look less like the advantage and more like the cost of admission. The baseline. The thing you need just to participate.

And when that happens, the question shifts in a way that’s subtle but profound. It’s no longer about whether you can build something. More people can than ever before, and there are whole waves of people learning as I type these words. The more uncomfortable question is why anyone should care that you did. When one thing becomes cheap, value doesn’t disappear, it relocates. It flows toward whatever is hardest to replicate.

Right now, that’s increasingly not code.

Code is fluid. It’s copyable, adaptable, generatable. It moves quickly, which is both incredible and deeply inconvenient if your advantage depends on it being slow and difficult. So the center of gravity shifts. Away from what can be written, toward what has to be accumulated. Away from what can be generated, toward what has to be built over time.

You see this most clearly when you leave the purely digital world and run into anything that exists beyond a screen.

Hardware, for example, has a kind of stubbornness that software simply doesn’t. You can spin up infrastructure in seconds, but you can’t spin up a factory. You can’t prompt your way into a supply chain. You don’t casually generate a fleet of devices distributed across the real world collecting data that only you have access to.

Physical systems come with friction, manufacturing constraints, logistics, delays, failures. They are slower, more expensive, and far less forgiving. Which, paradoxically, is exactly what makes them valuable. That friction becomes a form of protection. It’s not elegant, but it’s durable.

Then there’s regulation, which is perhaps the least glamorous and most underestimated form of defensibility. It’s easy to ignore because it doesn’t look like innovation. It looks like paperwork, compliance, and conversations you’d rather not have. But in many industries, it’s the difference between being allowed to play and not being in the game at all. Licenses, approvals, certifications, these are not things you can shortcut with better engineering. They require time, relationships, and a deep understanding of systems that were not designed to move quickly. While one group is focused on features and user experience, another is navigating the boundaries of what is legally allowed. And in markets like healthcare, finance, or telecommunications, that distinction matters more than almost anything else.

Once you start looking through this lens, it shows up everywhere. Take Uber. The application itself, while well-designed, is not the hardest part of the business. The real complexity lives in the operational layer, driver supply, city-by-city regulations, incentives, and timing. The software enables it, but it doesn’t define it. Telecom companies operate in a similar way. Their advantage doesn’t come from writing better code; it comes from controlling infrastructure and spectrum that others simply cannot access without enormous investment and approval.

Even in something as cutting-edge as autonomous vehicles, the bottleneck is not just the software. It’s validation, safety, capital, and regulatory acceptance. The code matters, but it’s only one piece of a much larger system.

Across all of these examples, software is necessary. It’s just not sufficient.

What Holds

Interestingly, this doesn’t diminish the role of open source, it amplifies it. If code becomes cheap, then distribution becomes one of the most important levers available, and open source is an incredibly effective way to build that distribution through community, creating trust, lowering barriers to adoption, and forming networks around shared tools. But it doesn’t, on its own, create lasting defensibility; the enduring value tends to emerge in the layers around it, data, ecosystems, services, and relationships that don’t get copied along with the codebase. Open source pulls people in, something else has to keep them there. It would be convenient to land on a clean set of actions, a simple checklist you could plug into a strategy document and call progress, but the reality is less tidy. It starts with asking better questions: what exists here that cannot be generated on demand, what do we control that others cannot easily access, and where, specifically, does replication begin to break down? If those answers are unclear, or uncomfortable, then the issue isn’t tactical, it’s structural.

So What

If code is effectively free, or even just trending aggressively in that direction, then it can’t be the thing your business relies on for differentiation; it becomes the baseline, the expected layer, the cost of admission. And that realization can be a bit disorienting, especially if a lot of identity has been built around being the group that writes the code, ships the product, builds the system. But the system is evolving, and the thing you build is no longer the thing that protects you, which is probably worth sitting with a little longer than is comfortable.