What If the Interface Is the Last Thing We Build?
I’ve been building an agent for Tomorrow Times.
Its job is surprisingly broad and powerful.
Behind the scenes, I’m continuously shaping what it does, tweaking workflows, refining behaviour, and slowly teaching it how I think about editorial decisions.
It helps shape stories, generate prediction questions, rewrite headlines, explore angles, and increasingly acts a bit like a very very bright editorial assistant. Over time, I’ve been nudging it toward understanding what makes something worth publishing versus what is just noise.
The interesting part?
There is no UI.
Not yet, anyway.
No polished dashboard.
No carefully designed workflow.
No sidebar full of toggles.
No product team arguing over whether a button should be blue or slightly more blue.
Just intelligence and iteration.
And it has made me wonder whether we might be building software backwards.
For decades, software has mostly worked the same way.
First, you design the interface.
Then you build the functionality underneath.
You sketch screens. Add buttons. Debate menus. Try to predict what users might want before they have even touched the thing. Eventually, the underlying capability catches up with the vision.
But agentic software seems to flip this entirely.
You can build the intelligence first.
You can live with it.
You can vibe with it for weeks.
Instead of imagining workflows, you discover them.
You notice the same requests happening again and again. Friction points reveal themselves. Weird edge cases appear. Things you assumed would matter turn out not to. Features you never planned suddenly become essential.
You are not designing in theory anymore.
You are observing reality.
What really crystallised this idea for me was testing another piece of agentic software recently: Helena.
Unlike my Tomorrow Times agent, Helena arrives with a polished UI from day one.
And while parts of it are impressive, I kept finding myself feeling oddly constrained.
The interface was already telling me what the product thought I wanted to do.
There were predefined workflows. Expected behaviours. Buttons nudging me toward particular actions.
And almost immediately, I found myself wanting to do things the UI did not really allow.
Not because the underlying intelligence could not do them, but because the interface had already formalised the experience too early.
The UI was getting in the way.
In traditional software, the interface is the product.
In agentic software, the interface might become the bottleneck.
If the intelligence underneath is highly flexible, a rigid UI can accidentally narrow possibility before users have even discovered what is valuable.
It freezes assumptions too soon.
With my Tomorrow Times agent, there is almost infinite flexibility because nothing has really been formalised yet.
If I want a different workflow, I change the behaviour.
If I want it to think differently, I refine how the agent works.
If something annoys me, I change it.
The product evolves through use.
Only later, once I understand what repeatedly works, would I even consider turning parts of that into a proper UI.
Maybe a faster workflow for reviewing prediction questions.
Maybe an editorial triage system.
Maybe shortcuts for repetitive decisions I find myself making every day.
But crucially, those interfaces would emerge from behaviour, not assumptions.
The interface would not be version one.
It would be the thing that happens after the intelligence proves itself.
Almost like software crystallising out of repeated interaction.
Messy first.
Structured later.
And I wonder whether many of the best products of the next decade will not begin with beautiful interfaces at all.
They will begin with intelligence.
The UI will come later.
Leave a Reply