There’s a shift happening in software that most people haven’t quite clocked yet, but once you see it, it changes everything.
We’re moving beyond the era of the interface.
Not in the sense that interfaces are disappearing entirely, but in the sense that the way users interact with software is fundamentally changing. From clicking through forms and screens, to simply having a conversation with software that understands their intent.
And that shift makes building software a whole lot simpler, more scalable, and actually more human.
The Evolution: From One Form to No Form
A few years ago, I tried to solve a challenge many SaaS builders face: how do you help users complete the right task, in the right place, without overwhelming them?
My solution was a single, dynamic form.. an entry point that could guide users based on their selections, leading them step by step through the fields relevant to their situation. No more navigating through five different screens to find the right form. No more empty screens asking users to make decisions they didn’t fully understand yet.
The goal was simple: make data entry easier by reducing friction, hiding irrelevant complexity, and keeping the user moving.
That approach worked. But it still required a lot of upfront logic; conditional field display rules, branching UI states, and a fair amount of mental load pushed to the frontend. Really complex to build, and even harder to maintain. Small changes often required significant refactoring of the flow of logic in the form.
Now, all of that is a thing of the past.
With the tools we have today, you can go one step further: ditch the form entirely and let the software lead the interaction as a conversation.
What started as One Form to streamline complexity has evolved into No Form—just a smart assistant that already knows where to start and what to ask next.
Software That Understands Instead of Reacts
Most traditional software still operates in a very mechanical way. It waits for a user to navigate to the right place, click the right button, and manually input what it needs.
That approach worked but there are better ways to do it now. Users aren’t thinking in terms of forms and flows. They’re thinking in terms of goals, progress, and context.
People don’t want to “fill out a form.” They want to complete a task, move something forward, or solve a problem.
Now that AI models can maintain memory, infer intent, and generate structured output from conversation, we no longer need to design interfaces that try to predict every possible path. The agent handles that.
The conversation becomes the interface.
Why This Is a Win for Builders
Here’s what might surprise some people: building this way is actually easier.
With traditional UI-heavy apps, you end up designing a screen for every workflow, handling edge cases in the frontend, writing validation logic for every field, and testing every permutation across roles, devices, and states.
Conversational interfaces simplify all of that.
The logic lives in the backend or agent, not scattered across the UI.
The frontend becomes lighter—often just a message feed or text box.
You reduce the surface area for bugs, UI regressions, and rework.
The end result? Faster dev cycles, less technical debt, and a far better user experience.
Microservices Make This Work
Agentic interactions work best when your backend is modular and composable. That’s where microservices come in.
Each functional piece—creating a record, analysing a document, validating data—can live as its own independent service. The agent acts as the orchestrator, calling the right services at the right time.
That decoupling makes your system:
- Easier to scale
- Simpler to maintain
- Reusable across multiple apps or entry points (web, mobile, chat, etc.)
Monolithic software, on the other hand, assumes a fixed flow. That rigidity makes it harder to build adaptive systems where the entry point is flexible and driven by user intent.
If you’re serious about agent-first software, microservices aren’t just a nice-to-have, they’re the backbone.
Beyond Usability: Designing for Trust
This isn’t just a technical shift. It’s a design one too.
When you remove the form and start a conversation, you’re not just helping users “get stuff done.” You’re building a relationship between the user and the system.
In the early stages, the agent explains what it’s doing and asks for confirmation. Over time, as it proves itself, the user naturally hands over more autonomy. What starts as “fill this in for me” becomes “you handle this now.”
That’s not usability. That’s trust.
And designing for trust requires different thinking:
- How does the system explain its reasoning?
- How can users correct it when it misunderstands?
- How do you show confidence or uncertainty?
- What tone of voice builds confidence instead of suspicion?
These are now core parts of product design—not just copywriting or UX edge cases.
Context Is the New Moat
Here’s where it gets really interesting.
The more a user interacts with an agent, the more it understands them. That context – preferences, patterns, goals – compounds over time.
That makes the system more useful with every interaction.
It also makes switching costs higher than ever. When users leave your platform, they’re not just losing features—they’re losing a system that knows how they work.
That kind of context-driven stickiness is incredibly powerful, and it’s hard to replicate unless you’ve built for it from day one.
So What Now?
If you’re building software in 2025 and still designing interfaces the same way you did five years ago, it’s time to rethink.
The interface is no longer the product, it’s a thin layer over a much smarter system.
The form is no longer the workflow… conversation handles that more naturally.
The user doesn’t want to choose what to do next, they want software that already knows what matters.
This shift isn’t just coming. It’s already here. And it’s not hype, it’s the inevitable direction software is going now that the tools exist to support it.
Final Thought
I used to spend hours refining forms, tweaking display logic, and trying to guide users through complex screens.
Now I spend that time making sure the agent has what it needs to have a useful conversation.
It’s a simpler, cleaner, more human way to build software.
If you’re tired of maintaining frontends full of edge cases and dropdowns, maybe it’s time to try something else.
The future isn’t form-first.
It’s conversation-first.
And frankly, what a relief!