The Case for Language-Native Software

There's a piece making the rounds this week that pushes back on one of AI's most comfortable assumptions: that the chatbot is the destination. The author, who previously wrote about software becoming "conversational," now says that framing was a mistake. What actually changed when ChatGPT arrived wasn't that software could talk. It's that software could finally understand plain instructions. Chat was just the most visible wrapper around that capability, not the capability itself.

The distinction sounds academic until you apply it to something like a retirement calculator or a business dashboard. Ask a system to show customer churn by region for the last four quarters, and nothing about that request needs back-and-forth. You want an answer, not a rapport. The essay calls this language-native software: you state intent in plain English, the system resolves any ambiguity, and then a deterministic engine underneath — the same kind of tax math or database query that's always powered enterprise software — does the actual work. Conversation only enters the picture when the system genuinely doesn't know what you mean, not as a default mode of operation.

That reframing also cuts through the current obsession with autonomous agents. The pitch for agents assumes execution is the hard part — that if you just let an AI keep reasoning and acting, it'll eventually get where you wanted. But execution, the author argues, has been the easy part for decades. Databases execute perfectly. Tax software executes perfectly. The genuinely hard problem has always been figuring out which of the thousand possible operations a person actually wants run. More reasoning turns or extra dialogue don't necessarily fix that; they just add more chances for the system's understanding of your intent to drift away from what you actually meant.

There's a useful analogy here to programming itself. Coders have always had a formal way to state intent — code — that a compiler turns into machine instructions. Ordinary users never had that; they had to learn menus, forms, and workflows instead, essentially adapting themselves to the software's language. Natural language flips that relationship, putting the burden of translation on the system instead of the person. That's a bigger structural shift than any specific model release, and it argues for treating intent-detection as its own serious engineering discipline, separate from — and just as rigorously tested as — the deterministic execution layer underneath.

Which is really the piece's central claim: as the front door gets more flexible, the back room needs to get more locked down, not less. Tax calculations, medical logic, and compliance rules can't get looser just because you can now ask for them conversationally. If anything, natural-language interfaces raise the stakes on governance, because when something breaks, you need to know whether the system misread your intent, picked the wrong operation, or executed the right operation badly. Those are three different bugs requiring three different fixes.