Three Chords and a Terminal
I set out this morning to rebuild the iPhone voice memo app. The stock one is fine but it’s not laid out the way I want, there are a few small features I want to add, and for the first time that was a good enough reason to just make my own. What I wanted to change doesn’t matter; that’s not the interesting part. The interesting part is that the sentence “so I’ll make my own” was, that morning, a completely reasonable thing to think.
That observation is mundane. Everyone’s had some version of it by now. Software got cheap; the writing of a first version has collapsed toward free, and you can feel the whole industry recalibrating around it. Fine. But the fact that I can build the app is the least interesting thing about that fact. What’s interesting is what a build cost near zero does to the question of what’s worth building at all — and, a few steps further down, to what software even is.
For many years, a piece of software had to justify its existence to a market before it was able to exist. That ticket booth is gone. And the thing that comes through the gate when nobody’s checking tickets is a new DIY culture — closer to a garage band than a startup.
The Ticket Booth Is Gone
The old logic was brutal arithmetic. If a thing costs $500k to build, you need a market big enough to return $500K plus a margin, which forces you up-market toward a mass audience whether you want to go there or not. That’s a filter, and it quietly killed every idea whose natural audience was only twelve people. Not because those ideas were bad, but because they couldn’t clear the cost floor. An enormous amount of useful software was never made badly. It was never made at all. You only ever saw what survived the filter, which is why the filter was invisible.
When the build cost approaches zero, the viability question stops being is the market big enough and becomes do I want this enough to spend an afternoon. That’s a completely different gate, and it’s a personal one. It’s tempting to describe this as “now the smaller markets are viable too,” but that’s still market thinking with the numbers turned down. The real move is stranger. It’s not a small market. It’s no market. An audience of one, with no ambition to be otherwise.
And once you accept that, most of the infrastructure we call software just falls away. App stores, installs, updates, accounts, versions, releases, support — nearly all of it exists to solve one problem: getting a single artifact to a lot of people who aren’t you. Delete that problem and you delete the whole apparatus. There’s no version, because there’s no one to be out of sync with. No update, because you don’t update, you just change it. No support, because the author and the user are the same person in the same chair. What’s left collapses to something closer to a note you can run. The voice memo app becomes a .bashrc with a UI.
A Mass of Singulars
The phrase people reach for here is “mass personalization,” but the phrase is unstable.
It’s originally a manufacturing idea — the Dell configurator, the custom sneaker — and there it always meant personalization within a menu the manufacturer controls. You get options, but someone upstream decided which options exist. That’s personalization as deviation from a base product. What’s happening here isn’t that. There’s no menu, no base, no manufacturer setting the option space. The thing is grown to fit rather than selected from variants. It’s bespoke at the root, not adjusted at the surface, and “personalization” almost undersells it, because personalization implies a norm you’re departing from and here there is no norm.
“Mass” is doing something odd, too. It isn’t mass in the usual software sense — one artifact reaching millions. Every artifact here is an audience of one. What’s mass is the capability. The scale lives in the sheer number of one-off things that now exist, not in the reach of any of them. A mass of singulars, nearly the opposite of what “mass” has always meant in this industry, where scale meant sameness.
For the entire history of software, generic was the ground state and personalization was the expensive, rare layer you added on top when it was worth it. Flip the figure and the ground: bespoke becomes the default, and the mass-market generic product demotes to the special case — the compromise you accept when you can’t be bothered to grow your own. Off-the-shelf doesn’t disappear. It just stops being the center of gravity.
The Barbell
To guess what actually gets built, we need to find the one thing that didn’t get cheaper. The explosion happens in its shadow.
AI made software free. It did not make other people free. The last fifteen years weren’t dominated by apps; they were dominated by apps whose entire value is other people being there. Facebook, Instagram, and TikTok aren’t valuable because the software is good necessarily. They’re valuable because everyone you know is already inside them. That’s the one thing you still can’t summon on a weekend afternoon — you can build yourself a TikTok clone in an hour and it’s worthless, because you can’t build yourself the people. So the mass-social layer stays consolidated. It was never really software competition. It was a gravity well made of humans, and abundance doesn’t drain the well.
Which means the explosion happens in the complement — everything whose value doesn’t depend on aggregating strangers. And that turns out to be an enormous, systematically suppressed space, because the old regime didn’t just favor social apps, it actively selected against their opposite. It rewarded engagement, retention, generality, scale. The software that gets built now is the inverse of each of those pressures.
Tools that don’t run on engagement, because no one downstream is monetizing your attention — so they’re built to get you out, not to keep you. The physical signature is the missing database. A voice memo doesn’t need a server; the server was never a technical requirement, it was where your data became someone else’s asset. Rip out the business reason and the architecture inverts: no account, no sync, no telemetry. Local-first isn’t a privacy feature here. It’s just what software looks like when nobody’s harvesting it. You strip out the extractive organs and discover that most of the app was organs.
Tools that are hyper-contextual, an audience of one that never has to average over a crowd. A generic product dies by breadth: the more people it must serve, the less it can commit to any of them, and every user gets served the mean of all users. An app whose N is one never has to average at all. Not “a fitness app” but the app for your exact rehab, from your exact surgery, with the exact equipment in your room — precise in a way a product literally cannot afford to be, because that precision has an audience of one and an audience of one couldn’t fund a product. The dilution was never bad execution. It was the cost of needing a market.
So the shape of the landscape isn’t “new platforms replace the old platforms.” It’s a barbell. Mass-social stays consolidated at one end — maybe more dominant than ever, because it’s the last thing abundance can’t touch. At the other end, a vast asocial understory of singular tools that never had a name because they never shipped. What hollows out is the middle: the mid-size generic product serving a modest market, because that’s the zone where growing your own now beats adopting the compromise.
A Birthday Card You Can Play
The strangest region is the disposable end, and it’s worth going all the way out to it, because it breaks the last assumption standing.
Start with software cheaper than the problem it solves — an app you spin up to serve a single use case this afternoon and never run again. Single use was insane under the old economics; you can’t productize a thing that gets used once. But when the app is cheaper than the task, software-as-a-passing-thought becomes a real category. Not an app you install. An app you emit.
Now push it to the limit and make a game as a gift. Put someone’s face on Space Invaders. Mechanically trivial, emotionally not, and the crudeness is the entire point — it doesn’t have to be good, it has to be for them. Here’s the tell: the thing that makes it work as a gift is precisely the thing that would make it worthless as a product. It’s illegible to everyone but the recipient. The inside joke, the reference to the one trip, their face on the alien — all of it is noise to a stranger and the whole signal to them. A product has to be legible to a market, which means stripping out the hyper-specific stuff that makes a gift land. So this isn’t a small game. It’s an object optimized in the opposite direction from a product: maximally meaningful to one person, illegible to all others.
Which is why it reads less like software than like a birthday card. Nobody asks what the market is for a handwritten birthday card, or thinks it’s impressive engineering. The point is that you made a specific thing for a specific person for a specific moment, and the medium is incidental. A handmade game is a card with more surface area — more room to encode I know you, more places to hide the joke. A card you can play.
The Saw Got Cheap
What do we name this type of application? Personal, local, disposable, occasional — every one of those names a property of the artifact, and the artifacts are heterogeneous. The voice memo app is durable; the gift game is disposable. The tracker is solitary; the game is social. The single thing true of all of them is negative: not built for a market.
If we stop thinking about the software and name the relationship, the most fitting name I can come up with is “DIY Software”. The one constant across everything above is that the maker and the user are the same person. That’s what DIY means. It also imports the right baggage. DIY is allowed to be crude — a hand-built shelf has visible saw marks and nobody minds, because the point was never the finish, it was that you made it and it fits your wall. And DIY has never implied a market; nobody asks what the market is for the thing you built in your garage. The question is a category error there in precisely the way it’s a category error for my voice memo app.
DIY has always required one thing, though: some skill. You had to actually be able to use the saw. And that skill requirement is the exact thing that kept build-it-yourself software tiny for decades. The saw was programming, and most people never learned it. What AI did was hand everyone the saw. So DIY software isn’t a new idea — people have made it forever — it’s a newly available one, because the specific barrier that always gated DIY is the specific thing that just fell. It was even, briefly, normal — Flash games on Newgrounds, shareware traded on disks, a homepage hand-coded over a weekend — before the app store and the feed turned making into posting. What looks like a frontier is closer to a return; the understory didn’t fail to exist, it got paved over.
Punk’s not dead
Everything up to here explains why market-free software is now possible. What turns a cost fact into a culture is that there’s already a word for what happens when the gatekeeper says you need the studio, the label, the training, and a garage says no you don’t.
Punk’s founding move was this collapse, and the amateurism was the message, not something to apologize for. A polished record proved you’d been admitted by the industry. A rough one proved you never asked. The saw marks aren’t tolerated, they’re worn. Seen from that angle, local-first, no account, no telemetry, no server holding your data hostage isn’t just a simpler architecture. It’s a refusal, and it has a specific, recent thing to refuse. After fifteen years of extractive, engagement-farmed, dark-patterned software, the antagonist is right there and it’s earned.
That’s the difference between a trend and a scene. Cheap tools on their own just give you a lot of people independently making little apps — diffuse, nobody in it together, an economic footnote. What makes it cohere into something that knows itself is the shared sense that it’s against something. The bedroom coder emitting a weird disposable app for one friend is doing the same thing as the kid with three chords: making the thing themselves, badly and gloriously, specifically because nobody gave them permission to.