Wrapware

Right now every attempt to put AI into an operating system looks about the same. There's an assistant in a sidebar. It can see your screen. It reaches into your apps through whatever crack it can find — either driving the interface like a very fast hand, or calling the handful of functions some vendor decided to expose.

Call it wrapware. A model wrapped around software that was never built for it.

It gets defended as the practical choice. The apps already exist, so meet them where they are.

But wrapping isn't a one-time cost. It's translation, forever, per app and per version, against interfaces that were specifically designed not to be protocols. A GUI isn't an undocumented API. It's a surface made for an eye and a hand. Reaching through it means reconstructing from the outside a structure the app already has on the inside and simply never had to say out loud.

Rebuilding sounds like the fantasy and wrapping sounds like the discipline. I think it's the other way around.

You're not rewriting Photoshop

The obvious objection to rebuilding is that it means rebuilding everything, which is insane.

But nobody needs everything. What you need on a given afternoon is a sliver. The only reason that sliver ever showed up welded to nine hundred others is that shipping software used to be expensive.

Apps got big because distribution was costly and switching was costly, so each one had to earn its install by serving a median buyer. Features piled up to close deals. Lock-in got designed in on purpose. None of that describes anybody's work. It describes how you reach a market.

Drop the cost of building and the bundle has no reason to hold. An app can be the size of the thing it does, because it doesn't have to stand alone anymore.

Composition used to require agreement

The real prize isn't smaller apps. It's apps that connect.

Pipes worked because everything agreed on one type, a stream of text. That agreement was cheap in 1973 and it paid out for decades. Graphical software never got there. It speaks pixels and private formats, and the clipboard is the leftover stub of what composition could have been.

Every attempt since has broken on the same rock. OLE wanted documents to embed each other. CORBA wanted every object to be able to call every other object. The semantic web wanted the entire internet to describe itself. Most of the API economy wants the same thing with better docs and a billing page.

Each one needed everybody to agree in advance on a shared shape. Advance agreement doesn't scale, because the number of pairs that need it grows way faster than anyone's patience for negotiating them.

Models remove the requirement. They can absorb the mismatch at runtime — take one app's output and shape it into another's input without either one having known the other existed.

So the rule quietly changed:

Composition used to require standardization. Now it only requires legibility.

If an app's inputs, outputs and actions are legible — typed, addressable, describable — then anything can be wired to anything, and the wiring can be asked for in a sentence instead of negotiated in a committee.

Karpathy gets near this when he says agents are a new consumer of digital information, sitting alongside people using GUIs and programs using APIs, and that we should be writing docs and building infrastructure for them. I'd push it further. Legibility isn't a courtesy you extend to agents. It's the property that makes composition possible at all, and it's the first thing wrapware destroys.

A wrapper's entire job is to stand between the app and everything else.

Free composition needs constrained flow

Connect everything and you leak everything. Once any output can become any input, the question stops being whether an app may read your files and becomes where a specific piece of data is allowed to travel.

That's a stricter idea than permissions as we usually do them, and a better one. The unit isn't the app, it's the flow. This contract can reach the summarizer and not the outbound mail. This client list can inform a document that never leaves the machine.

So composition and permission aren't two features sitting next to each other. They're one mechanism held in tension. Connection is only safe to make free because flow isn't.

Sharing falls right out of it. An app becomes something you can hand to someone, carrying a manifest of what it wants to touch. They see the ask, they grant or refuse. The trust question gets answered by the system instead of by a brand.

Where the value goes

It's tempting to say all this takes the price of software to zero. What actually goes to zero is app logic — the sliver, the interface, the glue, the parts anyone can generate now.

The cost doesn't disappear, it moves. Inference is metered and recurring. Data is still expensive to gather. Doing things in the real world is still hard. Total spend might even go up as licenses go away, and the value slides toward whatever stays scarce: your data, real action, and the layer underneath that holds state and enforces flow.

Apps get cheap. What they run on doesn't.

Afternoon software

The part I'm most excited about isn't better software. It's software for problems that never cleared the bar.

Everyone has a shelf of these. The review with the weird method only you use. The approval queue with three exceptions nobody can explain. The thing you do by hand four times a year because automating it would cost a week and you don't have a week.

They live in spreadsheets, in glue scripts, in one person's memory. They aren't edge cases. Added up, they're most of the work.

Make building cheap and outputs composable and the bar drops far enough that the afternoon tool becomes a reasonable thing to make. Expressiveness goes up because pieces combine. Fidelity goes up because software can fit the work instead of the market. Frequency goes up the most, which is the one people underrate — not better tools, but tools where there were none.

None of that comes from wrapping a model around what we already have. Wrapware keeps the apps and asks the model to reach through them.

The other path keeps the capability and lets the apps go.

P.S. Quick test for wrapware: if the app underneath shipped a redesign tomorrow, would it still work?