The Case for Language-Native Software

A while back, I wrote that the future of software might be conversational rather than autonomous. I still think the central observation was right, but since then I’ve become increasingly convinced I was looking at it through the wrong lens.

The word conversational turns out to be doing more harm than good. When people hear it, they think of chatbots and back-and-forth — they picture ChatGPT, they picture a conversation. When I ask a retirement planner to show the effect of delaying Social Security until seventy, I want fulfillment: I state intent, the system figures out what I mean and executes. A conversation might happen if intent is unclear. It isn’t the point.

Conversational software treats dialogue as the interaction model. Language-native software treats human language as the interface — you express intent, the system resolves it and runs the right deterministic operation. Chat is one path when ambiguity needs clearing; most valuable interactions are closer to a command than a conversation. That distinction explains several things the industry’s chatbot-and-agent obsession doesn’t.

I Think the Industry Learned the Wrong Lesson

When ChatGPT landed, most people fixated on the fact that you could talk to software. Understandable — it was the most visible part. You typed a question, the system answered, you refined, it answered again. It felt different because it felt like a conversation.

I don’t think the conversation was the important part. I think the important part was that millions of people experienced software that could understand instructions in natural language.

Conversation is a mechanism. Natural language understanding is a capability.

That distinction gets clearer once you look past chat apps. Take business intelligence: for decades, users learned where reports lived, how dashboards were organized, which screen had which metric. Now imagine asking, “Show customer churn by region for the last four quarters.”

Nothing about that requires a conversation. The system just needs to know what you mean and give you the answer. Same pattern in scheduling, financial planning, healthcare, design tools, dev environments — in each case, the value is understanding intent. The conversation is optional.

The False Choice Between Traditional Software and Agents

A lot of AI discourse is framed as traditional software versus autonomous agents. Traditional: rigid, menu-driven. Agents: adaptive, intelligent. One follows instructions; the other pursues goals.

Agents are seductive — describe a goal, walk away, let software fill in the details. If that worked reliably, it would strip a ton of friction out of how we use computers. What keeps bothering me is that this framing assumes execution is the hard part. In many domains, I’m not sure it is.

Databases execute instructions remarkably well. So do tax packages, schedulers, reporting engines. Execution is often the easy part. The hard part is deciding which instruction should run in the first place. A retirement planner can run thousands of projections; figuring out which one the user wants is often harder. A reporting system can answer thousands of questions; figuring out which question they’re actually asking is often harder. Language models fill that gap — they connect what the user means to what deterministic software can execute.

The industry often treats more reasoning as inherently better. Sometimes it is. An agent that keeps thinking after intent is clear has stalled; it hasn’t committed yet. That problem shows up again when conversation becomes the default interface.

The Evolution of Interfaces

We’re so focused on AI that we sometimes miss the longer pattern. Software interfaces have been evolving for decades. Early systems made you think in machine terms. Command lines were a step up — symbolic instructions instead of purely physical ones. GUIs were another: menus, windows, buttons, direct manipulation. Less memorization, less translation burden on the user. Each step made software more accommodating.

Natural language feels like the next step in that line. For decades, users learned the application’s language — navigation, workflows, forms, commands, config screens. You had a goal; you mapped it onto the interface. That stuck around because machines couldn’t reasonably interpret human language. Now they can — well enough, anyway, that the relationship is worth rethinking.

Natural Language and Chat Are Different Things

“Navigate to the nearest charging station.” “Show churn by region for the last four quarters.” “Move the launch to October and show every milestone that changes.” Natural language in each case; conversation in none.

Distinguishing natural language from chat is only half the picture. The industry also tends to treat conversation itself as the goal — as if more dialogue is inherently better. I don’t think it is.

Conversation is valuable only to the extent that it helps resolve ambiguity. Once intent is sufficiently understood, continued conversation usually creates more risk than value. I’d rather argue about correctness than token counts.

If I say:

Show my income.

clarification is valuable. Whose income? Which year? The conversation has a purpose.

If I say:

Show projected retirement income from age sixty-six through ninety-five assuming three percent inflation.

additional dialogue rarely creates value. At that point the system should execute.

I suspect the industry sometimes treats extended conversation as evidence of intelligence. In many business systems, it may be evidence that intent has not yet been resolved. Success means resolving intent quickly and accurately — not running up the turn count. Conversation is one mechanism for getting there, and a poor proxy for progress.

Every additional conversational turn creates another opportunity for intent to drift. Assumptions change, context expands, misunderstandings accumulate. Latency grows, context windows swell, and the system and user can slowly move away from the original objective. If intent is already sufficiently resolved, continued dialogue often increases complexity without increasing certainty.

A well-designed language-native system should seek clarification only when necessary and proceed to execution as soon as intent is sufficiently resolved. Natural language remains important. Conversation remains useful when ambiguity needs clearing. The objective is execution.

The association between natural language and chat will fade as language stops being bolted onto chat UIs and starts showing up everywhere else. So will the assumption that a longer interaction is a better one.

Natural Language as the User’s Programming Language

One analogy keeps coming back: programmers express intent in code; a compiler turns that into something machines run. Users never had an equivalent.

For decades, software developers designed the language and users learned it. Menus, workflows, forms, and navigation structures were specialized languages for expressing intent. You operated inside those constraints.

Natural language flips the relationship. For the first time, users can say what they want in a language they already speak. Structure still matters — responsibility for providing it shifts toward the software. More of the translation burden moves from the user to the software.

That shift is easy to underestimate because interfaces have always required translation — we just got used to the user doing it. Menus and workflows didn’t eliminate ambiguity; they relocated it.

Historically, software expected users to adapt themselves to the system. Language-native software asks the system to adapt itself to the user.

That inversion may ultimately prove more significant than any individual AI capability.

Calling that a “programming language” makes some engineers squirm — programming implies precision, natural language implies ambiguity. Fine. The analogy doesn’t require executing English directly. The interesting bit is translation: user expresses intent, the system resolves ambiguity, converts to structure, deterministic software executes. Sophistication lives in the translation layer; execution stays disciplined.

The Interaction Boundary

Most of my career, architecture meant execution — databases, APIs, services, workflows, business rules. Language models pull attention upstream: before anything runs, the system has to know what you meant. Old interfaces handled that with structure: buttons, menus, forms — all ambiguity reducers. Natural language strips a lot of that away, so intent determination becomes an explicit design problem.

Build systems that get intent right first — then execute correctly.

That distinction matters because the two sides have different jobs. Intent determination lives with ambiguity, probability, and interpretation. Execution lives with correctness, predictability, and accountability. Blur them and the system gets harder to reason about — and harder to govern.

I think that boundary will matter more over the next decade. Human intent is messy; execution can’t be. That’s a different emphasis than traditional software engineering usually gives it.

Why Determinism Still Matters

People sometimes worry that natural-language interfaces dilute the need for deterministic systems. I think the opposite is true. The more flexible the front door, the more you need a locked-down back room. Tax math demands precision regardless of how casually you asked the question. Medical recommendations can’t tolerate the looseness of everyday speech. Compliance has no use for “close enough.”

As understanding gets better, intent vs. execution matters even more. When something goes wrong, you need to know where: misunderstood intent? Wrong operation chosen? Right operation, wrong execution? Those are different failures. Smushing them together makes systems harder to trust; separating them makes them easier to govern.

Engineering discipline has to follow. If natural language becomes an interface, that interface needs the same design, testing, validation, and governance we apply to APIs, databases, and distributed systems. Language-native systems will require similar rigor around intent determination and validation.

The Case for Language-Native Software

Conversational UIs and capable agents both matter. Neither label captures the whole shift. What does: software that accepts intent in the language users already speak, translates it into structured operations, and executes them deterministically. Call it language-native if you like — the phrase may not stick. The direction will: language as the interface itself, freed from the chat window.

Software is beginning to understand instructions in human language. Chat was just where we noticed first.

Once you look at it that way, chatbots and agents start to feel less like the destination and more like early manifestations of a much larger shift.

Natural language is becoming an interface. That’s the story worth following.