Parts of this article were drafted with the help of AI.
Disclaimer: The content here is my personal opinion and does not represent the collective opinion of any organization.
I used to hide my code
Early in my software career, I used to wonder how naive someone had to be to make their code open source. Back then, code meant hard work. You spent time, thought and effort bringing something to life. Coding felt like a superpower that turned me from a consumer of technology into a creator. People new to the industry may never feel the dopamine of a C++ program compiling without errors on the first try.
I was always scared of plagiarism. I didn't want someone to take my hard work, fork my repository and call it theirs.
Things are different today. My projects are open source by default and the business models I come up with assume from the start that the code will be public. This article covers what changed, what changed my mind and what I think will change next.
Early understandings of open source
At first I thought of GitHub as a place to share code and work on it together, not as a place where code was open by default. My new repositories were private and I only made one public when someone asked me to. Forking a project felt like stealing. Taking an existing project and reshaping it for my own needs felt like a shortcut and a sense of guilt always came with it.
Looking back, I treated code as the valuable thing, so giving it away felt like giving away value. It took me years to see that code is rarely where the value lives.
What changed my outlook
The first time open source paid off for me was when I built a project at Hack Club. It got 10 stars and a $200 grant. That was enough to get me contributing to other people's repositories. After hackathons I would look for ways to contribute to the sponsoring companies' repositories and that eventually landed me my first paid gig and later a job.
The rewards weren't only financial. Contributions earned me a reputation in certain developer communities and that reputation grew into a network. The network eventually led me to my current role as a devrel at Logos.
None of that would have happened if my code had sat in private repositories. The code I was so afraid of losing turned out to be my best calling card, because people could see it, use it and build on it.
Asking what's under the hood
My career put me in a space where I started asking questions most of us never ask as consumers of technology. What actually happens behind the scenes when I use a closed source app? Where does my data go? Who can read it? What happens to it if the company is acquired, goes bankrupt or simply changes its mind?
Once you fall down the privacy rabbit hole, you notice that most of these questions can't be answered from the outside. A closed source app is a black box. You can read the privacy policy, but a policy is a promise, not a guarantee. Promises can be rewritten with a single email titled "We're updating our terms." Every time I use an app that isn't open source, my mind goes to the worst case. Maybe my identity is being sold. Maybe ten years from now my data ends up in a breach dump.
Open source answers part of this. If I can read the code, or trust that enough other people have, I can check what the software does instead of taking someone's word for it. But open code alone doesn't help much if the code runs on someone else's server and my data lives in someone else's database. I can audit the client all day and the black box has simply moved to the backend.
This is where local first comes in.
Working at Logos rewarded me for asking these questions. It's a place where "who controls this?" is treated as a design question, not paranoia.
What local first actually means
The term comes from a 2019 essay by Ink & Switch, Local-first software: you own your data, in spite of the cloud. The idea is simple: the primary copy of your data lives on your device and the cloud, if there is one, is just a way to sync it.
Compare that with how most software works today. In a typical SaaS app, the real copy of your data lives on the company's servers and your device holds a temporary view of it. If you lose your internet connection, the app stops working. If the company shuts down, your data goes with it. If they double the price, you pay or you leave and leaving usually means losing your work.
Local first software flips this around:
- It works offline. The app reads and writes to local storage first, so a flaky connection becomes a minor inconvenience.
- It's fast. No network round trip stands between you and your own data.
- It outlives the company. If the developer disappears, the app on your machine and the files it produced keep working.
- It's private by default. Data that never leaves your device can't leak from someone else's database.
- You own it. You can back it up, move it, export it and open it in other tools without asking permission.
Collaboration and sync still exist. Tools like CRDTs (data structures that let many devices edit the same data and merge changes without conflicts) let several people work on the same document and reconcile later, without a central server deciding who wins. The server goes from being the owner of your data to being one relay among many and in a peer-to-peer setup it doesn't need to exist at all.
Pair local first with open source and the black box goes away. The code is readable, the data is yours and nothing important depends on a company continuing to behave well.
The SaaS reality in an AI-driven world
For the last decade or so, SaaS had an unfair advantage: most people didn't care what was under the hood. We got used to renting software instead of owning it. Subscriptions replaced licenses, accounts replaced files and we ended up paying monthly for tools we didn't understand and data we couldn't take with us.
The business model worked because building software was expensive. If you needed a habit tracker, an invoicing tool or a small CRM, the realistic options were to pay for one or spend weeks building it yourself. Most people paid.
AI has changed that equation. For a lot of everyday tools, describing what you want to an AI model and vibecoding it is now easier than finding an existing SaaS, comparing pricing tiers, onboarding, handing over your data and then working around the features it doesn't have. The result fits your needs exactly, runs on your machine and stores data wherever you choose.
That's bad news for any business whose main advantage was "we wrote the code so you don't have to." When code is cheap to produce, keeping it secret protects very little. Anyone can build a clone and some of those clones will be open source and local first from day one.
AI also makes local first more practical. A few years ago, running a capable model meant calling someone's API. Today, tools like Ollama let you run strong open-weight models on a laptop or a modest home server. The same shift is happening across the stack: local databases, sync engines and peer-to-peer networking libraries are much better than they were. I explored what this looks like for AI inference in Xenia, a peer-to-peer inference marketplace with no server in the middle.
Evolution of business models in the AI landscape
If code is no longer the moat, what is? A lot of projects are now working out how to make money once their code is public. The models that I think hold up all charge for something other than access to the code:
- Convenience and hosting. Most people don't want to run their own infrastructure. An open source project can still sell a managed version, the same way companies sell hosted databases built on open source engines. The difference is that customers can leave, so the hosted version has to keep earning its place.
- Sync and backup as a service. A local first app can be fully functional for free while charging for optional encrypted sync, backup or sharing. You pay for a service that makes your data more available, not for the right to reach your own data.
- Support, integration and expertise. The people who built a tool are usually the best people to deploy, customise and maintain it. Businesses pay for that.
- Trust and reputation. When anyone can clone your code, your name, track record and community become the product. People pick the original because they trust its maintainers.
- Public goods funding. Grants, retroactive funding and ecosystem programs, which I first ran into through Hack Club, are increasingly a real way to sustain open infrastructure.
- Protocols and networks. In Web3 especially, value often sits in a network that many parties take part in, not in any single codebase. Open code is a prerequisite for people trusting the network at all.
What these have in common is that value moves away from controlling software and toward providing ongoing service, trust and community around it. That's a healthier arrangement for users and I think it's a more durable one for builders.
What I think will change
These are my predictions, so take them with a pinch of salt:
- "Open source" becomes a default expectation for privacy-sensitive software. For tools that handle messages, health data, finances or identity, being closed source will start to read as a red flag rather than a neutral choice.
- Personal software becomes normal. More people will build or generate small tools tailored to their own lives instead of subscribing to generic ones. Most of those tools will be local first, because a local file is the easiest thing to build on.
- Many SaaS products turn into sync, hosting or service businesses. The ones that survive will be those that make users' lives easier rather than holding their data hostage.
- Data portability turns into a selling point. "You can export everything and leave at any time" will become a feature companies advertise, because users will have alternatives.
- Local AI becomes the default for personal data. Running a model next to your notes, emails and files, instead of sending them to someone else's server, will go from a niche preference to the obvious choice for anything sensitive.
None of this means the cloud disappears. Servers are still useful for coordination, discovery and heavy computation. But the default is shifting from "your data lives with us" to "your data lives with you and we help."
Closing thoughts
The version of me who kept every repository private was protecting the wrong thing. Code was never the valuable part. The valuable parts were the problems I understood, the people I could help and the trust I could earn. Keeping code private only made it harder for anyone to see any of that.
Now that AI makes code cheap, I think the industry is about to learn the same lesson. Closed source, cloud-only products asked us to trust a black box because we had no alternative. That alternative is getting easier to build every month.
I'd rather own my software than rent it and I'd rather build things people can inspect, run themselves and walk away from. That's what I mean by local first.
