MCP First: The Design Philosophy the AI Era Demands

Last month, I spent a weekend genuinely excited about something for the first time in a while. Vercel’s agent browser. Anthropic’s Claude for Chrome extension. AI tools that could see my screen, click buttons, fill out forms, navigate websites. I set them loose on real tasks - the kind of tedious, multi-step workflows I’d been dreaming about automating for years.

By Sunday night, that excitement had curdled into something closer to rage.

Not because the tools didn’t work. They did - sort of. The AI would squint at a dropdown menu, figure out which option to select, click it, wait for the page to reload, then hunt for the next button. It was like watching someone operate a microwave by poking the touchscreen with a stick. Technically functional. Fundamentally absurd.

And in that moment of frustration, something clicked that I haven’t been able to stop thinking about since.

We’ve Been Here Before

Cast your mind back to 2010. The iPhone is three years old. Mobile web traffic is climbing. And every website on the internet looks like garbage on a phone.

The industry’s response? Responsive design. Take your desktop site, add some media queries, squish it down. It was better than nothing, but it was fundamentally backwards. We were building for the big screen first and then trying to cram the same experience into a 320-pixel-wide viewport as an afterthought.

Then Luke Wroblewski gave us a phrase that changed everything: Mobile First.

The idea was deceptively simple. Instead of building for desktop and degrading down, start with the constrained environment - the phone - and enhance up. Design for the small screen first. Then add complexity for larger viewports. Not because mobile was more important than desktop, but because starting with constraints forced you to make better decisions about what actually mattered.

Mobile First didn’t just make better mobile sites. It made better websites, period. The discipline of starting small forced designers to prioritize content, simplify navigation, and think critically about every element on the page. The desktop version got better because the mobile version came first.

We’re standing at exactly the same inflection point right now. And we’re making exactly the same mistake.

The Absurdity of What We’re Building

Here’s what’s happening in 2026: We have AI that can reason, plan, and execute multi-step tasks. And we’re building elaborate tooling so these AIs can… pretend to be humans using human interfaces.

Think about that for a second. Really sit with it.

A human interface exists for one reason: to translate human intent into computer signals. I move a mouse. I click a button. I type characters. Each of these actions is a clunky, lossy translation layer - my brain wants something to happen, and the interface is the bottleneck through which that intent gets squeezed into something a computer can understand.

The computer on the other side of that interface doesn’t care about the button. It doesn’t need the dropdown. It doesn’t experience the form. The UI is entirely for my benefit - a human who can’t speak the machine’s language directly.

AI can speak the machine’s language directly.

So why are we building tools to help AI operate our human-shaped bottlenecks? Why are we teaching machines to click buttons when they could just… call the function the button calls?

It’s like building a robot that operates a light switch with a mechanical finger instead of just wiring it into the electrical system. Technically impressive. Conceptually bankrupt.

MCP First

Here’s my proposal, and I’m giving it away freely because I care more about this happening than about getting credit for it. I’d be thrilled if someone with a bigger audience steals this idea wholesale and runs with it. Seriously. Take it. Make it yours. Just make it happen.

MCP First is the principle that software should be built with a machine-callable interface as the primary interaction layer, and the human interface added as an enhancement on top.

Just like Mobile First, the name is the strategy.

When you build a new feature, a new service, a new product - before you design a single screen, before you pick a color for a button - you define the protocol interface. The structured, machine-readable way for any agent (AI or otherwise) to discover what your software can do, understand the parameters, and execute actions. An API, yes, but more than that: a self-describing API with context, constraints, and capabilities that an AI can reason about.

MCP - Model Context Protocol - already exists as a standard from Anthropic, and it’s a great start. But “MCP First” isn’t about one protocol. It’s about the mindset. It’s about the order of operations. It could be MCP, it could be OpenAPI with better semantics, it could be something we haven’t invented yet. The protocol matters less than the principle:

Build for the machine first. Enhance for the human second.

What This Actually Looks Like

Let me make this concrete. Say you’re building a project management tool.

The old way (Human First): You design screens. A dashboard. A kanban board. A form to create tasks. You build the frontend, wire up the backend, and your API is an implementation detail - whatever endpoints the frontend happens to need. If you’re generous, you publish API docs as an afterthought. If an AI wants to use your tool, it has to screenshot the kanban board and try to figure out which card is which.

MCP First: You start with the protocol layer. “Here are the actions available: create_task, assign_task, move_task, list_tasks, get_project_status. Here are the parameters each accepts. Here are the constraints and business rules. Here’s how to authenticate. Here’s what the responses look like.” It’s complete, self-describing, and machine-callable from day one. Then you build the human interface on top of that same protocol layer. The kanban board is just a pretty visualization of the same data the AI interacts with directly.

Notice what happened? Just like Mobile First made better websites overall, MCP First makes better software overall. Your API isn’t an afterthought - it’s the foundation. Your human UI is forced to use the same clean abstractions the machines use, instead of accumulating special-case hacks. Your business logic lives in one place, not scattered across frontend components.

This Isn’t Just for New Software

I know what you’re thinking. “Cool, Leon, but I have a ten-year-old WordPress site and a client who panics when I change a font size.” Fair. I live in that world too.

MCP First can be adopted incrementally. You don’t have to rebuild from scratch. You can start wrapping your existing functionality in machine-callable interfaces, one capability at a time. WordPress itself is actually ahead of the curve here - the REST API was a step in the right direction. It just needs to be taken further, made more self-describing, made more discoverable.

Every plugin you build, every custom integration - ask yourself: “If an AI agent needed to use this feature, how would it?” If the answer is “it would have to simulate clicking through the admin panel,” you’ve got work to do.

Why I’m Giving This Away

I don’t have a massive following. I run a small two-person web shop and do a fair amount of AI work on the side. I’m not going to keynote a conference next month and unveil MCP First to thunderous applause. And honestly? I don’t need to.

What I need is for this idea to exist in the conversation. I need smart people - smarter than me - to pick it up, poke holes in it, improve it, and push it forward. I need framework authors to think about this when they’re designing their next major version. I need WordPress core contributors to consider it. I need the React team and the Laravel team and the Django team and every open-source maintainer to ask: “Are we building this for machines first?”

Because here’s the thing: the AI-powered web is coming whether we design for it or not. Just like mobile came whether we designed for it or not. We can either repeat the mistake - spend years building human-first interfaces and then awkwardly bolting on AI interaction as an afterthought - or we can learn from history and get it right this time.

Mobile First gave us a better web for everyone, not just phone users. MCP First will give us a better software ecosystem for everyone, not just AI agents. The discipline of building machine-first interfaces will force us to think more clearly about our software’s capabilities, write cleaner APIs, maintain better separation of concerns, and ultimately build better human interfaces too.

The Movement Starts Small

I’m not naive enough to think one blog post changes anything. But movements always start somewhere small.

If you’re a developer, try it on your next feature. Define the protocol interface before you open Figma. See how it changes the way you think about the problem.

If you’re a product manager, ask your team: “How would an AI agent use this?” Not as a hypothetical - as a real requirement.

If you’re building a framework or a CMS or a SaaS product, consider shipping an MCP server alongside your product. Make your software natively accessible to AI agents, not through browser automation hacks, but through clean, intentional protocol interfaces.

And if you have a bigger platform than me and this idea resonates - take it. Blog about it. Talk about it. Put your name on it. I genuinely do not care. I just want to stop watching AI poke at dropdown menus with a stick.

We learned this lesson once with mobile. Let’s not take another decade to learn it again.