There’s a lot of excitement right now about tools like Lovable that can spin up entire web applications from a natural language prompt. And for good reason - this is genuinely transformational. For the first time in years, building software feels fun again. That sense of possibility we had when we first learned to code - when the gap between idea and reality felt thrillingly small - is back. Coding agents have collapsed the distance between “what if” and “here it is.” But as much as I’m enjoying this moment, I don’t think its the future.

The future isn’t AI building better web apps. The future is AI replacing the human on the other side of them.

The User is Dead, Long Live the User

Think about what a web application actually is: a translation layer between what a system can do and what a human can understand and manipulate. We spend enormous effort on this translation. Color theory, accessibility, responsive layouts, loading states, error messages, tooltips, onboarding flows - all of it exists because humans need help understanding and interacting with systems.

But what if the user isn’t human?

AI agents don’t need a carefully designed button hierarchy. They don’t care about your color palette. They don’t get confused by a cluttered interface or miss a tiny icon in the corner. Given a well-documented API and a clear schema, they can interact with a system directly and efficiently. The web application becomes unnecessary overhead.

This is Already Happening

If you’ve used any MCP-enabled AI workflow, you’ve seen this in action. MCP (Model Context Protocol) lets AI agents interact directly with external systems - databases, APIs, file systems, issue trackers - through tool definitions. The agent reads the schema, understands the available operations, and gets to work.

I’ve been using Claude with MCP servers for things like Linear and GitHub. The experience is striking: I describe what I want in natural language, and the agent figures out the right API calls, handles pagination, deals with the response format, and presents me with results. There’s no UI in the loop. The Linear web interface, which someone spent considerable effort building, is completely bypassed.

And here’s the thing - this works better. Not because Linear’s UI is bad (it isn’t), but because the intermediate translation layer is gone. I don’t have to learn Linear’s mental model of how to organize my view, remember which filters I had set, or click through multiple screens to get context. The agent handles all of that.

What This Means for Engineers

If AI agents become the primary consumers of your application - and I think they will - the investment calculus changes dramatically.

The traditional breakdown might be something like 70% of engineering effort going into the web application layer, 30% into backend logic and data modeling. In an agent-first world, you might flip that entirely. Suddenly the important questions become:

  • Is our API well-documented and consistent?
  • Are our schemas expressive enough to capture the domain?
  • Do our error messages help an agent understand what went wrong?
  • Can an agent discover available operations without prior knowledge?

These are fundamentally different questions than “is the button in the right place” or “does the loading animation feel snappy.”

This is actually liberating. Most engineers I know would rather spend time on interesting domain modeling problems than building yet another CRUD interface. When your primary user is an AI agent, you get to focus on the substance of what your application does rather than the form of how it’s presented.

The Human Isn’t Gone

I’m not saying web applications will disappear entirely. There will always be cases where direct human interaction is important - creative tools, real-time collaboration, situations where the human needs to maintain tight control. And humans will still need some interface to direct their AI agents, though this might look more like a conversation than a traditional GUI.

But for a huge swath of software - the boring-but-important stuff that runs businesses, manages infrastructure, processes data - the primary user is increasingly going to be an AI agent acting on behalf of a human. Building for that future means investing in clean APIs, good documentation, and solid domain modeling. The web app can be an afterthought, or even generated on-demand by an agent that knows what the human actually needs to see.

For someone who has spent years thinking about infrastructure that makes the internet more usable, this feels like a sea change. We’ve been building translation layers for humans. Now we get to build systems that speak directly to intelligence.

Time to get hacking.