Why build anything? And if you're gonna build anything, why shouldn't you build everything?
We're approaching the point at which N=all in the space of problems we as individuals are able to grapple with and conquer. I've always believed the bigger idea was the one worth pursuing. I've never quite managed to fully implement that in practice, yet.
What I do build, repeatedly, is custom versions of software that already exists. Since school: notes apps, Slack clones, terminals, meeting notetakers, browsers. Not as businesses. Because the software everyone else uses doesn't work the way I want it to.
Take notes apps. I've built two of them, actually — not one, two. The first is a lightweight scratchpad: summoned by a keystroke, no folders, no hierarchy, just somewhere to dump a thought and find it later with fuzzy search. The second is the opposite — structured, full markdown support, nested folders, backlinks, the works. Two different tools because I have two different kinds of "note," and no off-the-shelf app treats them as separate problems. I do, so I built both. Which is to say: the depth of what one person actually wants from their software is further down than any commercial app is willing to dig.
The flow of information is wrong. It's organized poorly. It's not optimized for my use case. It's only ok. So, I rebuild it — often several times. The question I always ask is the same though: why am I using software built for everyone when I know exactly how I want this to work?
The question
Why use the Notes app, designed for hundreds of millions of people, when I could have one designed for me? Why use Gamma to make slides when I could have something that makes decks exactly how I'd (or wish I could) make them, on my own machine?
"Good enough for everyone" is the default bar. Tools don't feel right? Adapt. "Customization" means picking from three themes someone else made.
The gap between knowing how you wanted something to work and actually having it used to be an entire engineering project every single time. That isn't quite true anymore, at least not for web apps.
That gap is what's always bothered me. I'd spend a lot of my free time building better versions of apps that actually suited me — my preferences, my tendencies. Then, after a lot of work and self-reflection, I'd try to shill them to my cofounders, colleagues, and friends, telling them this was the next big consumer app.
At the time I was operating under a startup principle that is, broadly, good advice — I was just misapplying it. Paul Graham's actual words, from "How to Get Startup Ideas":
“You can either build something a large number of people want a small amount, or something a small number of people want a large amount. Choose the latter.”
“The very best startup ideas tend to have three things in common: they're something the founders themselves want, that they themselves can build, and that few others realize are worth doing.”
— Paul Graham
The way I remembered it, after Michael Seibel and Emmett Shear hammered it into me and my cofounders at YC in 2023: you are the best customer you can build for, because you know yourself and your tastes, and you're not that special. If you like it, someone else will too. Same idea, less precisely put.
I internalized it a little too well. I started believing that because I really liked something, it had to be a good startup idea. After all — if we're all right as kids and only get dumber after that, then the midwit way to dodge bad startup ideas was to "make something people want," launch quick, and trust yourself as customer zero.
So every time I built yet another custom notes app or yet another browser, I'd pitch it to my cofounders as our next thing. They never thought it was a good idea. In hindsight, they were right about the specifics and I was right about the shape.
What I actually wanted wasn't "Superhuman for Notes where every action is a keyboard shortcut." I thought it was, but it wasn't. What I really wanted — what I think a lot of people want — is the ability to create personal software at the desktop level that replaces your existing app stack on demand and reshapes your life's OS. No more navigating through mediocre software that doesn't cater to your whims.
LLMs are what make this possible. The product creation and iteration cycle is approaching zero. For the first time, it's realistic to spin up the version of the app you've always wanted in minutes. Which means the real unlock isn't any single app — it's your ability to manipulate every piece of software you touch on your personal machine.
Web apps aren't the ceiling
Part of this gap already has a solution. Lovable, Bolt, Replit — describe what you want, get a working web app in minutes. The idea-to-working-thing gap I grew up frustrated by is, at least for anything that can live in a browser, genuinely closed. These tools are excellent at what they do.
But there's a second gap underneath the first: between "a web app I generated in a tab" and "real software on my machine that replaces what I was using and talks to everything else I've got installed." That's what still needs solving.
Web apps live in browser tabs. They don't replace the software you actually rely on day to day — the things you reach for with Cmd+Space, the tools that run when you're offline, the apps that hold your real work. They don't share data with each other except through integrations someone else chose to build. They're the fastest possible way to spin something up. They are not the thing most people want to live inside.
There's another layer underneath all that. The tools that build apps end the moment they finish building. Lovable, Bolt, Cursor, Claude Code — they use AI to construct the thing, then walk away. The result is a static app: whatever the model wrote that day, frozen. Inside the app, no intelligence. No assistant. No reasoning over your data. No "help me find that thing I wrote last month." The AI does the construction and leaves the building. You used a brain to make a calculator.
So why would the browser be the last layer of software individuals can build? And why would AI only be involved at the moment of construction?
The trajectory is visible. Only engineers → no-code → AI web apps → native apps → the OS itself. Each rung used to be impossible for normal people and then suddenly wasn't. No reason that stops at a tab in Chrome.
Linux already proves where this ends up. No two Linux users' desktops look the same — window managers, file managers, terminals, status bars, init systems, all swapped and mixed and shared. An artisan marketplace for personal software, already in motion. It just requires writing config files, so almost nobody participates.
Remove that gate.
Data is the real reason
When you own all your apps, you own the connections between them.
Today, if I want my notes to talk to my calendar, both vendors need to have shipped an integration. Even then I get whatever thin slice of data they decided to expose. Zapier, MCP, API glue — workable for engineers, still constrained to what the vendor lets pass through the wall.
My data, living in other people's apps, connected by permission slips those companies did or didn't sign.
When apps run on your machine, on the same platform, over the same local data layer, they just talk. No integrations, no middleware, no rate limits. Your CRM knows about your inbox because there's no wall between them. That isn't a feature. That's what should have been true the whole time.
People are more inventive than their tools assume
LLMs and Lovable changed my mind about one thing: people are way more creative with software than I'd given them credit for.
I used to think blank canvases paralyze most people. There's truth to that — opinionated tools are easier to pick up. Wispr Flow wins because it's "use your voice to type," not "use any modality you want." But when a tool is actually good, people find uses that go well past the pitch. They see it and immediately think "I could use this for X," where X is specific to their work and their friction and isn't on anyone else's roadmap.
Opinionated early adopters prove this out — people with definite ideas about how their software should feel. I'm one. There are more.
Build the engine, not every app
Instead of building my own notes app, my own recorder, my own CRM — build the thing that builds them.
Describe what you want. An agent assembles it as a native desktop app. It runs locally, you own it, and it talks to your other apps because they all sit on the same platform and the same data on the same machine.
And the agent doesn't leave once the app is built. The same engine that constructs your apps stays inside them as the brain — available across every app you've made, reasoning over the shared local data, the conversations, the events, the whole stack. The intelligence is the engine of the apps, not just the thing that built them. AI-native by default, not as a feature bolted on.
V1 is Lovable for native apps with a brain that stays. The destination is an OS where the base layer of software on your computer is shaped to how you actually work — not different wallpapers, different software, all of it intelligent.
If you have folders of half-finished side projects that are custom versions of things that already exist, or you've muttered "I wish this just worked like this" more times than you can count — this is for you.
Defaults are a tax on people with specific taste. llumos is how you stop paying it.