This spring I shipped a budget app. It has two users, and one of them married me.
There’s no signup flow, because everyone who will ever use it lives in my house. There’s 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’s not a “real” product. It’s also some of the most successful software I’ve ever shipped, if success means the users are happy and nobody has churned.
It’s not alone. There’s 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’s a presentation system I built for my husband’s coaching practice. There’s a tracker that runs my freelance practice and would confuse any freelancer who isn’t me. None of these have a market. All of them have users.
Three years ago, none of them would’ve 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 if your problem was only shared by two people, it couldn’t buy a ticket. So personal problems got personal workarounds: the spreadsheet, the shared note, the folder named FINAL_v3. A spreadsheet is really just personal software that never got the chance to be 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’ll never meet, at a scale that justified the cost of building. We talk about the average user like it’s a design principle, and honestly, it’s not. The average user is just the person we invented because we couldn’t afford to build for the real ones.
Designing for two is a whole different sport. There are no personas. The persona eats dinner with me. There’s no feedback funnel either: my husband doesn’t file tickets, he mentions things over dinner, and the good ones are usually live before the weekend. There’s no onboarding, because the users were present at the birth. And there’s no settings page, because a settings page is basically an apology to people you couldn’t ask. I can ask… he’s 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 a toggle you can go find in settings. It’s the premise. That’s how our marriage works, so that’s 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 isn’t a flaw in those products. It’s just what scale costs. But it IS a cost, and you only see how large it was once you use software that doesn’t pay it.
I should be honest about the trap, because I’ve 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 doesn’t 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 didn’t need. So a tiny audience doesn’t excuse the editing… if anything, a tiny audience concentrates the editing.
Here’s where this connects to the work I get paid for. I’ve said more than once that generative UI is not a chat window. Watching software work at this scale is the clearest view I’ve found of what it actually is. The promise of GenUI was never conversation. It’s 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 the composing, 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’ll be the designers who’ve practiced fitting software to someone they can actually see.
Last month the budget app gained a feature because of a sentence my husband said while making dinner. It was live before the weekend, for an audience of two, and it gets measured by the only metric that’s ever really meant anything: he actually uses it. I spent twenty years designing for millions of people I never met. Turns out the most demanding client of my career sleeps next to me.
Software is finally allowed to be that specific, and design should learn to be. Mine gets to practice at dinner.