The personal software era
50 years after personal computers, introducing personal software.
For thirty years, getting something done with a computer meant finding the right software and bending your work to fit it. You bought a tool built for everyone, learned its thousand buttons, used about ten of them, and spent the rest of your day copying data from one into the next. The software was generic because it had to be — to sell to everyone, it had to do everything. The work of making it fit you was yours.
That's backwards now.
When an agent already has your context — the tools you use, the data you keep, the way you like things done — and can write and deploy working software in a few seconds, the whole ritual collapses. You stop shopping for software. You make it, for the exact job in front of you, and nothing else.
That's what we mean by apps.
The software used to be the product. Now your work is the product, and the software is just how it gets done.
What generic software costs you
A CRM, a project tracker, a marketing suite — each starts simple and opinionated, then grows to cover everyone's case, because that's how you sell to everyone. A few years in, it has twenty connectors, a dozen automation builders, and settings pages you'll never open. You care about ten percent of it and wade through the rest to reach that ten percent.
The escape hatch has always been to build your own — a spreadsheet that's secretly a database, a Notion page wired with automations. The people who do this well are rare, and even they're fighting the platform the moment the need gets slightly specific. The ceiling is high but the climb is steep: one macro in and you're debugging someone else's idea of how your work should go.
What an app is instead
An app is a small piece of software built for you, by your agent, out of everything it already knows.
Connect your Twilio credentials and ask for a phone line that transcribes calls live onto a dashboard. The agent finds the number, wires the webhooks, builds the dashboard, and hands you a working line. You configured nothing. Or the agent builds a tool for itself: a generator that turns a post into a LinkedIn carousel, kept around because it'll want it again. Or a sync that pulls your Stripe data and shapes it the way you actually reason about churn and lifetime value — so the slow per-customer question you could never get a straight answer to is just sitting there, answered.
None of these is a product someone shipped for a market. Each is one piece of software that fits one person's work exactly, made in the time it used to take to find the settings page.
From once to ten thousand times
The same surface stretches. The first time, your agent does the thing by hand, like a craftsman — figuring it out from what it knows about you and the job. Do it again and it has a jig: faster, more precise. Do it enough and you want it to run ten thousand times, correctly, while you sleep — and now it's a workflow, hardened software with the agent in the loop where judgment is needed and plain code where it isn't.
Apps live across that whole range. There's no rewrite between "help me do this once" and "do this reliably forever" — just the same thing, tightened. That gradient, from artisanal to automatic, is most of the work most people actually have.
The screen is the tip of the iceberg
Apps are visual, and that matters: seeing the thing is how you come to trust it. You watch the total recompute, you click the row that's wrong, you believe it because you can look at it — the same reason people reach for a spreadsheet over a script.
But the screen isn't where the value is. The value is underneath — the data pulled into one place, the connections between your systems, the small interfaces one app exposes so the next one can build on it. One dashboard reading from your Stripe sync, your email sync, your calendar. That composition is the hard part, and it's the part generic software can never do for you: it was built for everyone, and the shape of your work is the one thing it doesn't have.
This is the line between buying software and being able to make it. Some tools do your tedious work for you; some let you build apps for other people to use. This is the other thing — software you make to get your own work done, shaped to you, thrown away or kept as you like.
In the old world, you found software and stitched it together. In the new world, you are the software.