All of this sits on my table and draws roughly 100 watts under load, about as much as an incandescent lightbulb.

For perspective: the Apollo Guidance Computer ran at roughly 85,000 instructions per second, with 4 KB of RAM, and weighed almost 32 kilograms. Deep Blue reached about 11 GFLOPS. The ~15 TFLOPS on this table would have been the fastest supercomputer on Earth in 2001. Compute that once required a room, a government, or a world-champion chess match now sits in the general-purpose devices I use to watch cat videos.

The Waste

Almost nothing I do each day touches the ceiling of this hardware.

Yet every time I open X, I see another product launching online that could, or should, run locally. I’ve shipped these too.

It takes data and context already on my computer, sends them to a machine in Virginia, performs the work there, and sends the result back. The builder pays to create another execution environment; the customer already has one.

That duplication is the waste. Not every HTTP request. Not every server. Work whose data and context already live on the user’s machine, the machine sitting right in front of the person who wants the result.

Sun Microsystems spent two decades telling the industry that “the network is the computer.” The industry finally believed it, right as it stopped being true. The network is the phone book. The computer is the computer.

The internet gives people a permanent, addressable presence. It lets parties discover one another, communicate, and establish shared state.

Servers exist so parties can find each other and agree on what’s true. Everything else is waste.

Servers are excellent at coordination, authority, persistence, and work too large for the client. But computation should have to earn its trip across the network.

Software that runs locally is cheaper to build on and easier to trust. And it keeps working when the internet doesn’t.

Where This Breaks

“Zero marginal cost” is true for compute, not for engineering. Client-side software means a larger testing matrix, hostile machines, weak devices, and need for a robust update pipeline. The capacity is already paid for; making it dependable is not.

But that price was set a decade ago, when dependable meant a QA lab full of laptops and a hand-rolled updater. Wasm gave us one runtime everywhere; update pipelines are commodity; the testing matrix is exactly the kind of grunt work models now do. Most builders are working from a quote they never re-requested.

Some work belongs on a server. People want data synced across devices. Providers cannot trust clients to report billing honestly. Old and weak devices still exist. Long-running tasks should survive a closed laptop. Google Docs beat desktop Office on zero install, no data loss, and access from any device. And frontier models are unlikely to fit on your machine anytime soon.

Those are not edge cases. They are the boundary of the argument. The only question is which side of that boundary your product actually sits on. Checked, not assumed.

The Architecture Already Exists

But games never had the luxury of ignoring the client. Physics forced the architecture: a data center can stream frames, but latency is a law of physics, and you don’t get to repeal physics. So game developers put latency-sensitive physics, rendering, and interaction on the player’s machine, while servers arbitrate the shared world: who is where, who hit whom, and what counts as true.

The client computes. The server coordinates.

Nothing about that split is specific to games. Figma’s renderer was written in C++, compiled to WebAssembly, and runs in the browser. The server handles the shared document and collaboration. It does not draw every rectangle in us-east-1 and mail the pixels back.

And now there is Claude Code, Codex and Cursor. The model may live on a server, but the harness lives where the code, tools, credentials, and developer already are. The server streams intelligence; the client gives it hands.

That is the form factor people like because it does not pretend the computer in front of them is a dumb terminal.

AI has made the old mistake expensive enough to notice again. Builders now pay per second for cloud sandboxes that poorly imitate a laptop: cloning repositories, rebuilding environments, copying secrets, and reconstructing context that already exists on the user’s machine.

Sometimes that is the right trade. Background agents need persistence. Untrusted code needs isolation. Large jobs need hardware the customer does not own. But “put the harness in the cloud” should be a conclusion, not a default.

So the answer to “what should we do about it” is a default, not a product. When you design the next feature, sort the work into two piles: state that other parties must agree on, and everything else. The first pile earns a server. The second pile already has a computer: the one your customer is looking at.

Notice what the first pile keeps: identity, billing, the source of truth. Everything you actually charge for. Moving the compute doesn’t move the meter.

Take the last feature you shipped. Which pile did most of the work sit in, and which pile did you build it in?

Consumer hardware has become absurdly capable. The industry has treated that capability as somebody else’s problem.

---

The photo at the top of this essay hasn’t changed. Six computers, maybe 100 watts. Tomorrow they will spend most of the day displaying spinners, waiting on Virginia for work they could do themselves.