Intents: the end-game for computing interfaces?
It's a bigger deal than you think
Computing interfaces are undergoing big changes. Let’s explore how we got here, what it means and why we may be approaching optimality.
The gradual shift from imperative to declarative interfaces
Early computing began with low-level, imperative interfaces. Engineers painstakingly entered commands in languages like Assembly, dictating inputs with the specificity of the underlying hardware. Setting register values, applying arithmetic operations, all with meticulous precision.
As we exited the “early computing era”, we saw two big drivers for new interfaces: the need for greater efficiency and the need for machines to capture “business context” in a reusable and understandable manner.
To boost productivity, developers turned to higher order languages with terse semantics, allowing them to focus on the problem domain rather than the low-level details.
At the same time, computing trickled out of academia and into business. Digitization and automation became a must for every corporation. To adapt to this need for capturing business semantics, computer scientists developed new programming languages and computing paradigms.
We saw a proliferation of approaches: from defining networks of resources that send explicit messages to each other (eg. NextStep, Erlang), to modeling real-world entities with classes and objects (eg. Java, C#), to decomposing business logic into declarative, recursively structured functions (eg. LISP)
The late aughts rolled in a wave of cloud computing vendors, driving an industry wide shift in expectations. You could now granularly define what services you wanted spun up, and AWS would handle the rest - divvying up compute, launching instances, managing system health in some semi-distant data center somewhere in “us-west”.
Declarative interfaces spread far beyond DevOps (eg. Docker, Kubernetes) and became the norm for popular web and mobile frameworks (eg. React, Flutter, SwiftUI). In response to massively fragmented vendor support for browser APIs and a wave of new devices, frameworks grew large and were tasked with abstracting away more and more complexity.
Looking back, this era of interfaces was immensely successful. Dockerization expedited the transition from on-prem to cloud, iOS Auto Layout gave Apple the ability to ship new devices and screen sizes with thousands of supported apps on day one.
In all, it seemed like the natural end state for interface design - as a developer, you could focus on higher order business logic and all the implementation details would be handled by an optimized, up-to-date system.
The rise of the intent
Yet, in the past year or so, we’ve started to see a new kind of interface emerge.
While the distinction between an “intent-driven interface” and a “declarative interface” may sound like a matter of semantics, the distinction is meaningful.
While declarative interfaces focus on specifying a structured end state, “intent-driven interfaces” represent an unstructured mix of data, instructions, uncertainty, higher order goals.
Put differently, “intent-driven interfaces” sit at a totally different layer of the stack. Previously, we had to translate our human thoughts into computer input. We had to go through a chain of steps: pre-processing our ideas (in our heads), evaluating possible approaches, selecting one and structuring that input into the machine to meet the desired outcome.
While declarative interfaces streamlined some of those steps, “intents” replace the steps altogether.
“Intent-driven interfaces” allow us to directly express ourselves and pipe our thoughts into the machine, allowing it to figure out what to do next - whether that involves using declarative interfaces, imperative instructions or whatever else.
Intents, suddenly everywhere
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 what I think is much more exciting is that we’re moving into a new computing paradigm that’s inherently more human-centric: we can pipe a stream of consciousness into a machine and get human-scale outputs.
So, what’s next?
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)
To end on an even more sci-fi note, we’re just scratching the surface on how we transmit intents. In the past few years, we’ve seen massive advances in brain-computing interfaces. Across a variety of tasks, we’re now able to translate abstract intent into processable machine signals. Neuralink patients are able to move cursors faster than most humans with a mouse.
We’ll soon bypass the need for a mouse and keyboard and will be able to stream more complex thoughts directly into the machine. Intents will seamlessly flow from neuron into electrode, synapse to bit.
Looking ahead, the evolution of interfaces from imperative to declarative to intent-driven marks a shift in how people and machines will coexist. We’re heading towards a future in which software truly aligns to how we think, adapts to our needs and breaks us away from the barriers to entry we’re used to. We can finally unlearn “thinking in terms of what the machine expects.”
At the risk of sounding hyperbolic, this is our Promethean moment - rather than bending to the will of the elements, we’re choosing to harness fire.