Computing interfaces are going through a major reset. Let’s look at how we got here, what’s changing and why we may be getting closer to an optimal interface for working with the machine
Early computing began with low-level, imperative interfaces. Engineers entered commands in languages like Assembly, dictating instructions with the specificity of the underlying hardware.
Set a register value. Move data around. Apply an arithmetic operation.
Everything had to be spelled out with meticulous precision. The computer was powerful but only if you could speak its language.
As we exited the “early computing era”, two big drivers pushed interfaces forward:
the need for greater efficiency
the need for machines to capture “business context” in a reusable and understandable way.
To boost productivity, developers moved toward higher-level languages with terser semantics. The goal was simple: spend less time thinking about registers and memory and more time thinking about the problem domain.
At the same time, computing was moving out of academia and into business. Digitization and automation were becoming must-haves for every serious corporation. Software now needed to represent customers, orders, workflows, permissions, inventory and all the messy concepts that make businesses run.
This led to a proliferation of new programming languages and paradigms. Some systems modeled software as networks of resources sending explicit messages to each other, like NextStep and Erlang. Others modeled the world through classes and objects, like Java and C#. Others decomposed business logic into declarative, recursively structured functions, like Lisp.
The late aughts brought a wave of cloud computing vendors and a major shift in expectations. You could now define the services you wanted, ask AWS to spin them up and let the platform handle the rest: allocating compute, launching instances and managing system health in some semi-distant data center in us-west.
Declarative interfaces soon spread far beyond DevOps. Docker and Kubernetes changed how teams packaged and orchestrated software. React, Flutter and SwiftUI brought the same basic idea to web and mobile development. Developers could describe the desired end state and let the framework figure out the messy implementation details.
This became especially important as platforms fragmented. Browser APIs were inconsistent, devices multiplied and screen sizes exploded. Frameworks got bigger because they had to absorb more complexity on behalf of developers.
Looking back, this era of interfaces was immensely successful. Dockerization accelerated the move from on-prem to cloud. iOS Auto Layout helped Apple ship new devices and screen sizes with thousands of apps ready on day one. The best interfaces of this era were the ones that unlocked entirely new platform shifts.
In all, this felt like the natural end state for interface design. Developers could focus on higher-order business logic while the implementation details were handled by an optimized, up-to-date system underneath.
Yet, in the past year or so, we’ve started to see a new kind of interface emerge.
The difference between a “declarative interface” and an “intent-driven interface” may sound semantic but it’s meaningful.
Declarative interfaces let us specify a structured end state. An intent-driven interface lets us express something messier: a mix of data, instructions, uncertainty and higher-order goals.
Put differently, intents sit at a different layer of the stack. Previously, we had to translate our thoughts into computer-readable input. That meant pre-processing the idea in our heads, evaluating possible approaches, choosing one and then structuring the request in a way the machine could execute.
Declarative interfaces streamlined parts of that process. Intent-driven interfaces start to replace it altogether.
Instead of carefully translating our intent into the machine’s language, we can express what we want more directly and let the system figure out what to do next. That may involve calling a declarative API, executing imperative instructions, asking a follow-up question or combining several tools behind the scenes.
LLMs were the missing link to unlock true “intent-driven” interfaces. And we’re just starting to see this vibe shift play out:
User interfaces: Every App is offering an AI interface that allows unstructured authoring into a structured format (eg. Jira tickets) - I know roughly what I want, make it so.
Developer interfaces: New API standards like Arazzo codify the mapping between “user-level workflows” and specific APIs, capturing concepts like control flow and sequencing.
AI interfaces: Agents are seemingly all the rage in the AI sphere. We’re being pre-sold a vision of “AI software engineers”, “AI customer support agents” and it’s actually starting to play out.
What does this mean for us? The obvious takeaway from LLMs is that we’re offloading a bunch of human tasks to agents. The robots are taking our jobs.
I see some of that but the more profound shift is that computing is becoming more human-shaped.
For most of computing history, humans had to compress their thinking into rigid machine inputs. Now, we can hand the machine something closer to raw thought. In return, the machine gives us something at human scale: a plan, a draft, a design, a workflow, a decision.
The lines between thinking and calculating are dissolving.
We’ve come a long way from telling a computer “I’ll instruct you step by step” (Assembly) to “I’ll give you a high level definition that you’ll implement” (Kubernetes) to “Give me something that looks good, matches these outputs and fulfills these conditions” (Cursor)
In the past few years, brain-computer interfaces have made massive progress. Across a growing set of tasks, we’re learning how to translate abstract human intent into machine-readable signals. Neuralink patients can already control cursors at impressive speeds. We’re hurdling toward a future where the interface between thought and software gets much thinner.
That may sound far out but it fits the broader pattern we’ve seen since we were handling stacks of punchcards: computing interfaces keep moving closer to the way humans naturally think, feel and act.
Soon, we may start to bypass the mouse and keyboard altogether and stream more complex thoughts directly into the machine. Intents will move from neuron to electrode, from synapse to bit.
In that world, we can finally start to unlearn “thinking in terms of what the machine expects”
At the risk of sounding hyperbolic, this feels like a Promethean moment. We are no longer bending ourselves to the elements. We are choosing to harness the fire.