I recently had the chance to sit down with one of my favorite educators in web development, Kent — someone whose courses and talks played a big role in my own late-career transition into tech. We started out talking about React Server Components… and somehow ended up in a full-on conversation about the future of the web, AI agents, and why Model Context Protocol (MCP) might be as big a shift as the early days of the internet.
You can watch the whole talk here, of keep reading for everything we covered.
Kent said something that really stuck with me:
“Users are fleeing the browser and moving to AI agents.”
If you think about your own habits, that might already be true.
I realized I barely use Google anymore. Most of the time I don’t search for a page — I ask an AI a question.
Instead of:
…I just open ChatGPT or Claude and type what I want.
That’s not just a nicer UX. It’s a fundamental shift in the primary interface between users and software:
Browsers and search engines are trying to adapt (AI answers on search result pages), and AI tools are trying to adapt (chat + files + tools + browsing), but the direction is pretty clear:
The main way people interact with software is becoming “Asking”, not “Searching”
At React Conf, Kent showed a short promo video for an upcoming ChatGPT feature: ChatGPT apps.
The idea:
That app appears inside the chat, as:
Input becomes multimodal: text, voice, clicks, typing. The agent chooses whatever mix of UI + conversation makes the most sense for the task.
The important mental shift:
In the future, you won’t just be designing for “the user in the browser.” You’ll be designing for the user’s agent, which is acting on their behalf.
That means your app needs a way to say to the agent:
“Here’s what I can do. Here are the actions I support. Here’s how to call me.”
That’s where MCP comes in.
MCP stands for Model Context Protocol. Under all the buzzwords, it’s basically:
A standard way for AI agents (like ChatGPT, Claude, etc.) to talk to external services in a structured, predictable way.
You expose your app as an MCP server, which defines:
Then an agent can:
Kent has been focusing a lot on consumer-oriented MCP servers (not just dev tools in an IDE). One of his example projects is a journaling app, exposed via MCP:
That’s the pattern:
Your app becomes a capability provider to agents, not just a website with a login form.
Kent compared this shift to the early web:
He sees MCP and agent integration the same way:
Imagine:
If your competitor has MCP integration and you don’t, the agent will prefer the one it can seamlessly call. Browsing your website and scraping forms will always be a worse UX than direct integration.
Yes, agents can technically browse the web. But:
Agents are incentivized to use directly integrated tools whenever possible. That’s why Kent argues:
Ignoring MCP and agent integration will eventually feel like not having a website in 2010.
Does this mean UI is dead? Not at all.
Kent thinks custom UI will be important for at least the next five years (and probably longer — but forecasting beyond that gets dicey fast).
A few key points:
Branding still matters
Trust still matters
UI libraries may become “building blocks”
In the future, a service might expose:
The agent could then compose those components into custom layouts based on what the user is trying to do.
We may eventually see agents generate full UI on the fly, but we’re not there yet. For now:
Frontend work is still about building components, flows, and branded experiences — just increasingly in collaboration with agents instead of only with browsers.
We had to talk about the big fear: AI replacing developers.
Kent’s take was both simple and kind of liberating:
So planning your life around that scenario is pointless. You can’t act on it.
Now remove that from the table and ask a more useful question:
“Assuming AI remains a powerful tool, not an instant replacement, how do I stay relevant and valuable?”
His answer:
And this matches my own experience too. I’ve used AI to:
But here’s the catch:
The skills that matter more than ever:
Kent even tries to talk to LLMs the same way he’d talk to another engineer — not just “do this,” but with context, constraints, and reasoning. That habit itself is a valuable engineering skill.
A few practical bits from Kent’s workflow:
He treats the existing codebase as context for the model:
He also uses ChatGPT outside the editor to:
In other words, AI isn’t a replacement for thought — it’s a partner in thinking and typing.
One of the most interesting parts of the conversation was about the current wave of “AI apps.”
For the past few years, companies have been building:
RAG (retrieval augmented generation) systems that:
Those are useful, but they have big limitations:
They don’t have the broader capabilities of ChatGPT/Claude:
If instead you expose your knowledge base (and other capabilities) via MCP:
ChatGPT can combine your data with:
You don’t have to maintain a completely separate chat UX if you don’t want to
There are still valid reasons to build your own “wrapper”:
But even then, Kent recommends:
Build your own chatbot on top of an MCP server you control.
That way:
You get both:
A few myths Kent keeps running into:
It does. And the spec has been improving quickly:
Is it perfect? No. But it’s absolutely not “no auth.”
For developer tools, sure — a CLI might be fine.
But:
--help and parse textMCP gives you:
Something that works across:
If you’re a developer or technical founder, here’s a simple roadmap pulled from our conversation:
Accept that agents are becoming the new frontend. Users will increasingly talk to AI first.
Keep investing in UI skills — they still matter. Branding, trust, and good interaction design aren’t going away.
Get good at using AI in your workflow. Treat it like a powerful teammate that’s great at drafting, exploring, and refactoring.
Start learning about MCP.
Think in terms of “capabilities,” not just “apps.” Ask:
Stay optimistic. Ignoring AI doesn’t protect you — it just puts you behind. Integrating it makes you more capable, not obsolete.
Kent closed our conversation with this:
“Be optimistic. The version of you that learns to use and integrate AI will be better than the version of you who doesn’t.”
I tend to agree.
You don’t need to predict the entire future of AI. You don’t need to know exactly where we’ll be in ten years.
But you can start today: