This spring I shipped a budget app. It has two users, and one of them married me.
There is no signup flow, because everyone who will ever use it lives in my house. There is no pricing page, no feature comparison, no roadmap. It manages exactly one household’s money, ours, around exactly one philosophy, ours. By every professional measure I know, it is not a real product. It is also some of the most successful software I have ever shipped, if success means the users are happy and nobody has churned.
It is not alone. There is a folder on my desktop that turns any video dropped into it into a seamless loop, because I need seamless loops more often than any reasonable person should. There is a presentation system I built for my husband’s coaching practice. There is a tracker that runs my freelance practice and would confuse any freelancer who is not me. None of these have a market. All of them have users.
Three years ago, none of them would have existed. Not because nobody wanted them; the wanting was always there. The economics said no. Building software cost so much that a market was the price of admission, and a problem shared by two people could never buy a ticket. So personal problems got personal workarounds: the spreadsheet, the shared note, the folder named FINAL_v3. The spreadsheet is where personal software went to be almost built. Software had to be for everyone before it was allowed to be for anyone.
Most of what we call product design grew out of that constraint. Personas, onboarding flows, settings pages, segmentation, the research rituals themselves: devices for serving people you will never meet, at a scale that justified the cost of building. We talk about the average user as if it were a design principle. It was never a design principle. The average user was the person we invented because we could not afford to build for real ones.
Designing for two is a different sport. There are no personas; the persona eats dinner with me. There is no feedback funnel; my husband does not file tickets, he mentions things over dinner, and the good ones are usually live before the weekend. There is no onboarding, because the users were present at the birth. And there is no settings page, because a settings page is an apology to people you could not ask. I can ask. He is right there.
The deepest difference is that personal software gets to commit. Our budget app is built on one shared pot of money. Not as an option, not as a mode. As the premise. That is how our marriage works, so that is how the software works, and everything downstream of that decision is simpler and truer for it. A mass-market budget app could never do that. It has to survive every possible household, so it hedges: yours, mine, ours, a toggle for each, and an interface that fits every arrangement loosely and none of them well. Hedging is not a flaw in those products. It is the cost of scale. But it is a cost, and you only see how large it was once you use software that does not pay it.
I should be honest about the trap, because I have written about it before. When building costs an evening, nobody stops you from lovingly building the wrong thing. The discipline of deciding what deserves to exist does not get easier at this scale; it gets easier to skip. I have a small graveyard of tools that fit my life perfectly and my life did not need. A tiny audience does not excuse the editing. It concentrates it.
Here is where this connects to the work I get paid for. I have spent a couple of essays insisting that generative UI is not a chat window. Watching software work at this scale is the clearest view I have found of what it actually is. The promise of GenUI was never conversation. It is software that fits one context completely: this person, this moment, this need, with the hedges removed. Every home-cooked app is that promise built by hand. Right now the composing is done by me, in the evenings. The direction of travel is that the software does it, at the moment of need.
When that arrives at scale, the average user retires for good, and the instincts this tiny software teaches become the job. Committing to a real context instead of hedging across imagined ones. Noticing what a specific person actually does, not what a segment reports. Refusing features that fit the category but not the life. Someone has to teach interfaces to fit people that closely, and it will be the designers who have practiced fitting software to someone they can see.
Last month the budget app gained a feature because of a sentence spoken while making dinner. It shipped before the weekend, to an audience of two, and it is measured by the only metric that has ever meant anything: he actually uses it. I spent twenty years designing for millions of people I never met. The most demanding client of my career sleeps next to me.
Software is finally allowed to be that specific. Design should learn to be.