You text a number. Within seconds, a reply comes back: “Your flight is delayed. I’ve rebooked you on the 7:45, and your hotel check-in is now 9 PM.” No app. No dashboard. No pixel-perfect UI. Just a conversation with an agent that knows you, knows your itinerary, and just does things.
This isn’t a sci-fi demo. This is what native MCP tools look like right now. And if you’re still building shiny frontends, you’re missing the signal.
The frontend isn’t dead; the LLM has simply become the new frontend.
I’ve seen the future, and it runs on Telegram. One HN user described their setup: an OpenClaw/Hermes agent connected to a suite of native MCPs (Model Context Protocol tools), and they interact with it entirely through WhatsApp or Telegram. No React. No Vue. No DOM. Just text in, action out. The only UI is the conversation itself.
Let’s be honest — that’s thrilling and terrifying in equal measure. Thrilling because we’re finally living the promise of “just tell the computer what you want.” Terrifying because everything we’ve learned as frontend developers — state management, responsive design, accessibility — suddenly feels like medieval masonry in an age of steel frames.
We are building increasingly complex backend infrastructure specifically to make the user experience radically simpler.
Native MCP tools strip away the visual layer entirely. Instead of designing a form, you design a tool that an LLM can call. Instead of building a login screen, you expose an authentication token via MCP. The entire value chain shifts from crafting pixels to engineering efficient backend integrations. The new bottleneck? Token consumption, latency, and context window management — not rendering performance or color palettes.
I spoke to a developer who replaced five SaaS dashboards with a single agent. “I just text it what I need,” he said. “I don’t even open the apps anymore.” His team spends more time optimizing MCP calls for cost-per-token than they ever spent on CSS. The trade-off is brutal: you win on UX simplicity, but you lose on cost predictability. Every query burns tokens. Every tool call adds latency. The math flips — UI complexity is replaced by token economics.
You should be asking yourself: Is my value in how I present information, or in how I make information actionable?
The provocative truth is this: the frontend isn’t going away — it’s just being absorbed into the LLM itself. The chat interface becomes the universal UI. And that means the skill that matters most in 2025 isn’t React or SwiftUI. It’s the ability to design tools, APIs, and prompts that let an agent fulfill intent without ever showing a screen.
I’m not saying every app will become a chat agent tomorrow. But the writing is on the wall. The highest-growth startups in the AI-native space are already building with this mindset: no frontend, just MCPs and a text interface. They’re not worried about bounce rates or conversion funnels. They’re worried about context windows overflowing and token bills ballooning.
So take a side. Either this is brilliant — the inevitable simplification of human-computer interaction — or it’s dangerous, a world where we surrender control to black-box agents. I’m leaning brilliant, but I’m also watching my old frontend skills with the kind of nostalgia you feel for a dying craft.
Stop polishing pixels. Start engineering token efficiency.
FAQ
Q: Does this mean no one will ever build a visual UI again?
A: Not at all. But for a growing class of tasks where speed and simplicity matter more than visual richness, chat-based agents will win. Think booking flights, checking order status, or querying internal databases. High-fidelity UIs will still exist for creative tools, gaming, and complex data visualization.
Q: What's the practical implication for my SaaS product today?
A: Start adding an MCP layer to your API. Let users interact with your product via chat agents. Your competitor will. The cost of not doing it is losing the 'just text me' generation. Also, monitor your token usage – native MCP tools can get expensive fast if you don't optimize.
Q: Isn't this just a fad? We've seen 'no UI' trends before.
A: The difference this time is the LLM's ability to understand context and execute multi-step tasks reliably. Previous 'bots' were rigid. MCP tools let agents call real backend functions. This is a paradigm shift, not a fad. That said, the hype cycle will overshoot – many 'agent-native' apps will discover that cost and latency make them impractical for certain use cases. The smart money is on hybrid approaches: a thin chat layer for simple tasks, full UI for complex workflows.