Artificial General Software
We’ve spent years debating artificial general intelligence. Meanwhile, something quieter happened: artificial general software. Computing is moving from clicking through menus to stating goals. When that happens, switching costs collapse, because the interface is just language. And when switching costs collapse, the defensible advantage stops being features and starts being trust, rooted in control and provenance.
Consider how much of modern work is really translation. You have an outcome in your head. You break it into app-shaped pieces. You learn each app’s vocabulary, its hierarchy of menus and abstractions, its particular way of carving up a problem. Then you stitch the pieces back together. Most of the effort isn’t thinking. It’s compliance with software that was designed for a different era’s constraints. Rich Sutton’s bitter lesson applies here : general, scalable methods outlast the handcrafted. Every bespoke workflow is a liability waiting to be absorbed by something more general.
I see this constantly building Careswitch. Customers ask for the same thing over and over: one platform that does everything. Export to ADP for payroll. Sync invoices to QuickBooks for accounting. Pull candidates from Indeed for recruiting. Their instinct makes sense. Every seam between systems is a place where work gets lost, where someone has to manually translate one app’s output into another app’s input. Vertical integration has always been the traditional answer to that pain. But it’s the wrong abstraction. The problem was never that you had too many systems. The problem was that you were the integration layer. An agent that works across systems dissolves the seam without needing to own both sides of it.
Language is what makes that absorption possible. “Remove the background.” “Draft a Q4 plan from last year’s deck.” “Refactor the module and add tests.” Each of these is a goal with context, something a person would say to a capable colleague. The gap between intent and execution has always been where software lives; what’s changing is that the gap is shrinking to nearly nothing.
Copilots inside apps will give way to agents that work across them. That part is predictable. The harder, more interesting question is what happens to trust. Menu-driven software has a built-in accountability: you see every step, because you’re the one clicking through them. When the interface becomes language and the system handles the rest, that visibility disappears. The work happens behind a curtain. So the builders who win will be the ones who give that visibility back, through previews, versioning, and rollbacks, through letting people verify outcomes they didn’t manually produce.
Artificial general software reframes computing: from feature lists to outcomes you can verify. The tools that win will be the ones that make verification easy and honesty the default.