Open Source Is About to Matter More Because of AI

Why AI could make software ownership, forking, and open-source trust more valuable than ever.

I’ve been thinking about something slightly weird lately. AI is making software cheaper to build. Not cheaper in the AWS sense, but the actual act of sitting down and turning an idea into working software. Things that would’ve taken me a week sometimes take a day now, and things I probably wouldn’t have bothered building at all become random evening projects because I can ask an agent to do most of the boring parts.

And I think this is only going to get more extreme. We’re probably heading towards a world where producing software isn’t particularly expensive anymore. At first I thought this would make open source less important. If anyone can recreate software, who cares if the original is open source? But the more I think about it, I think the opposite might happen.

Code is becoming cheap

For most of software history, code itself was expensive. You needed people who knew how to write it, those people needed time, and companies spent ridiculous amounts of money turning requirements into working systems. If somebody spent three years building a complicated product, recreating it wasn’t as simple as looking at the UI and asking an agent to make another one.

That assumption is starting to break. Obviously AI cannot perfectly recreate every complicated piece of software today. There is still an enormous difference between generating something that looks correct and maintaining something that actually works. But the direction seems pretty obvious. The amount of software one person can produce is increasing very quickly, and the cost of just trying an idea has collapsed.

And when the cost of producing something collapses, usually the valuable part moves somewhere else.

Maybe the valuable thing isn’t the code anymore
I’ve been building Zilobase, an open-source workspace, and this question comes up in my head a lot. What does being open source actually mean if an AI can eventually recreate most of the implementation anyway?

I don’t think the answer is just that you can see the code. That’s useful, obviously, but it feels increasingly incomplete. The more interesting part is that I can own the thing. I can run it, change it and keep using it even if the original maintainer disappears tomorrow. If somebody makes a product decision I absolutely hate, I can fork it. If a company gets acquired and the new owner decides the $10 plan should suddenly cost $40, the software itself hasn’t been taken away from me.

That’s a very different relationship from most software we use today. We don’t really own much software anymore. We rent access to it. And AI might make that distinction much more obvious.

Renting software made sense when rebuilding it was expensive
SaaS made an enormous amount of sense because operating software is annoying. Someone else hosts the database, deploys updates, fixes servers, manages backups and gives you a login. You pay $20 every month and don’t think about any of it. That’s a pretty good deal.

But there was another reason SaaS businesses were defensible: rebuilding the software was difficult. If a company had 40 engineers working on a product for five years, you weren’t going to casually recreate it because they increased the price. You either paid them or moved to another company that had also spent years building something similar.

AI changes that equation a little. Imagine a product you really like gets acquired. The new company removes three features, adds AI to the name and doubles the price. Today you complain on Twitter and eventually pay them anyway. But what happens when somebody can fork the last open version, ask an agent to implement the missing features and have a usable alternative running a week later?

That’s a very different kind of leverage.

Forking is going to become much more interesting
Forking has always been one of my favourite ideas in open source. Not because everyone actually does it. Most people don’t. It’s because you can.

The problem is that historically maintaining a serious fork was expensive. Imagine a project with hundreds of thousands of lines of code. You disagree with the maintainers, so you fork it. Great. Now congratulations, you own hundreds of thousands of lines of code that you have to understand and maintain forever. That’s not exactly freedom for most people.

AI changes the economics here too. Coding agents are getting much better at navigating unfamiliar repositories, making changes across large codebases, writing tests and explaining parts of systems you haven’t seen before. Suddenly maintaining a fork doesn’t necessarily require understanding every corner of the original project yourself.

It still requires judgement. It still requires someone who actually cares whether the thing works. But the amount of human effort required could become dramatically smaller, and I think that makes the right to fork much more powerful than it used to be.

Open source also changes what we can trust
There’s another part of this that I didn’t think about much until AI. We’re increasingly putting software in places where the software isn’t just storing data anymore. It’s reading our email, looking through our documents, writing code, executing tools and talking to other systems on our behalf.

At that point, “trust us” starts becoming a slightly uncomfortable security model.

Being able to inspect, modify and run the system yourself starts mattering a lot more. I think we’ll increasingly start asking questions like: Can I see what this agent is doing? Can I change it? Can I move my data somewhere else? Can I run it without asking the company that created it?

And probably the most important one: what happens if this company disappears tomorrow?

AI doesn’t kill open source
I think AI actually makes the reason for open source clearer. Open source was never valuable only because programmers could read the implementation. It was valuable because nobody had complete control over what happened next. You could take the thing and continue.

For a long time that ability was mostly theoretical for normal users because modifying serious software required serious engineering resources. AI might make that ability much more practical. If implementation becomes cheap enough, then source code itself stops being the moat. The community matters. The ecosystem matters. The decisions behind the product matter. The people maintaining it matter. And the ability to take the project somewhere else matters.

Maybe we’re heading towards a strange world where software becomes almost disposable but ownership becomes incredibly important. Anyone can make the code. The interesting question becomes whether you’re allowed to do anything with it.

I think that’s a pretty good reason to keep building things in the open.