Essays

The End of Apps as We Know Them

Forget app fatigue—the future isn't more tools, but a single conversation. Here's how Model Context Protocol eliminated my browser tab nightmare and built a digital workspace I can actually trust.

Darin Cassler

May 9, 2025 — 10 min read

Your Current Digital Life is Broken

We've all been there. It's 2:30 PM, you've got your third coffee in hand, and you're staring at a digital workspace that looks like a toddler arranged your apps. Twelve browser tabs, Slack notifications popping up like digital whack-a-mole, that Notion page you can't quite find, and somewhere, buried in your digital mess, is the exact piece of information you need.

A few months ago, I was in exactly this position—staring at a blank blog post draft, cursor blinking, coffee cooling. I had ideas. I even had some outlines buried in Notion. But the overhead of writing—the formatting, the remembering, the switching between tools—was getting in the way of actually thinking. I didn't need inspiration. I needed infrastructure.

You're not disorganized. You're just living in the Age of App Overload.

Every day, we perform a choreographed dance between interfaces—dragging documents from Google Drive into emails, toggling between calendars, copy-pasting code snippets, and constantly rebuilding context as we jump between tools. This isn't just annoying; it's actively draining your creative energy and focus.

The hidden tax on your productivity isn't just the time spent switching—it's the mental overhead of rebuilding context every time you do.

Our current setup is a patchwork of brilliant but isolated solutions. Email for external communications, Slack for internal chatter, Notion for documentation, repositories in VS Code, Trello or Linear for task management. Each one excellent at its core function, none designed to truly work together.

Want insights from your knowledge graph? That'll be multiple downloads, imports, and custom scripts. Need to summarize last week's meeting? Hope you enjoy manually extracting highlights from Fireflies and pasting them into Notion.

This fragmentation is costing you in three critical ways:

Your attention is shattered - Every context switch pulls you out of flow state, accumulating as mental debt throughout your day
You lose visibility - Which version is current? Did that update actually go through?
Accountability evaporates - When automations fail silently, you're left debugging phantom errors with no audit trail

Here's the painful truth: the complexity of integration now exceeds the complexity of your actual work.

Like a lot of people working at the intersection of product, engineering, and AI, I found myself watching the wave of "intelligent assistants" and "AI copilots" crest into something less theoretical and more operational. The tools were getting better—but they were also getting blurrier. What I wanted wasn't another black box assistant but something more boring and reliable: a predictable, inspectable layer of control over what AI was allowed to do.

Enter Model Context Protocol: The USB-C of AI Applications

If you've been following AI developments closely, you might have caught Anthropic's announcement on November 25, 2024: the introduction of Model Context Protocol (MCP). If you missed it, don't worry—this is about to change everything about how you work.

Think of MCP as the "USB-C of AI applications"—a universal port through which large language models can read, write, and execute operations across all your digital tools. From Postgres databases to Slack messages to your CMS, one protocol connects them all.

At its core, MCP defines a standard schema for tool invocation: a request object specifying what you want to do (read a Slack channel, search a vector database, update a document) and a response schema that returns what you need. It's elegantly simple, and that's exactly the point.

For the uninitiated, MCP is a way to structure how AI models interface with your systems and workflows. At a glance, it looks like plumbing: a schema, some handlers, a well-defined interface for passing tasks back and forth between a local process and a remote model. But if you step back, it's more than that. It's a conceptual framework for defining intent, boundaries, and accountability in AI-assisted systems. It's a reminder that context isn't metadata—it's governance.

Developers can either expose their data through custom MCP servers—like the Graphlit MCP Server for knowledge management or Neon MCP Server for Postgres—or use community implementations like Ghost MCP for publishing blog posts. There's a growing list of MCP servers on GitHub of varying complexity that you can try right now, or you can check out Smithery.ai for a more repository-like approach.

The real magic happens when you stop thinking about MCP as a technical specification and start seeing it as the foundation for a completely new way of working. And that's exactly what I did with my own workflow.

A Day in Your Future: Working Through One Interface

Let me paint you a picture of your workday in this not-too-distant future—and share how I've already started living it.

Today's Reality: The Tab-Switching Marathon

It's Wednesday afternoon. You get an email reminder about Friday's stakeholder meeting and the deliverables you need to prepare. Your workflow looks something like this:

2:00 PM: Open Notion, search for the project document, notice the metrics are outdated
2:15 PM: Switch to the Qdrant dashboard, upload last week's CSV, run queries, copy results back to Notion
2:30 PM: Jump to Slack to update the project channel, then someone asks for your timeline—back to Notion you go
2:45 PM: A colleague mentions something from a meeting recording, so you navigate to Fireflies, search the transcript, timestamp it, and send a link

Each transition costs you 10-15 seconds of pure mental adjustment. By day's end, those seconds have compounded into hours of productivity debt.

Tomorrow's Possibility: The MCP-Powered Workflow

Now imagine the same afternoon, but with an MCP-powered chat client:

2:00 PM: You type: @notion fetch "Stakeholder Meeting Document" and summarize updates since last week
2:05 PM: Then: @qdrant search for "top 10 deals by value" and chart trends
2:10 PM: Follow with: @slack post "Updated stakeholder deliverables are in the chat" to #project-status
2:15 PM: When asked about timeline changes: @memory recall "timeline change rationale"
2:20 PM: And finally: @ghost draft "Friday Recap: AI-Powered Workflows"

This isn't theoretical—I built something similar for my own blogging workflow. I was already using Ghost as a CMS, so I forked Ghost-MCP, an open-source project that connects Ghost with an MCP server. The setup process was remarkably straightforward: since I already had NPM installed, I simply dropped a configuration snippet into a file, and I was instantly authenticated against my blog using the Ghost Admin API.

From there, I scoped a few specific tasks for my workflow: generating post ideas, writing first drafts based on outlines, suggesting titles, and summarizing old posts. To make interaction more fluid, I added Raycast commands, letting me trigger these actions with a keystroke.

All of this happens in a single interface. No tab-hopping. No manual copying and pasting. Every action is explicit, logged, and reversible.

Remember that attention tax I mentioned earlier? It's eliminated. The visibility problem? Solved—your chat transcript becomes a comprehensive audit trail. Accountability concerns? Addressed through explicit permission models and traceable commands.

This isn't just faster; it's a fundamentally different way of relating to your digital tools. Instead of you adapting to each app's idiosyncrasies, your tools adapt to a consistent interaction model.

The result wasn't magic. It was just useful. I found myself moving faster without lowering standards. I spent less time wrangling markdown and more time deciding what I actually wanted to say. And because the tasks were well-bounded, the model never tried to outsmart me or go off-script. It did what I asked it to do—and nothing more.

The Transformative Benefits of Protocol-First Computing

The shift to MCP-centric workflows delivers three game-changing benefits:

1. Efficiency That Compounds

By collapsing complex integrations into a uniform command pattern, MCP dramatically reduces the friction of context-switching. Rather than memorizing dozens of UIs or APIs, you learn one protocol and a handful of commands.

This isn't just additive efficiency—it's multiplicative. Each additional tool you integrate actually makes your overall system more streamlined, not less. It's the opposite of our current situation, where each new app adds exponential complexity.

2. Complete Visibility

Every tool invocation is logged in your chat transcript. There's no mystery about which document version was retrieved, what metrics were calculated, or which channel was updated. Your chat history becomes the single source of truth, complete with structured metadata.

Think about the last time you wondered: "Did I actually update that spreadsheet?" or "Who changed the launch date?" That uncertainty vanishes in an MCP workflow, where every action leaves a clear trace.

In my own blogging setup, this meant I could see exactly what context the model had, how it made a decision, and what my role was in the process. Nothing went live without my review. This wasn't fire-and-forget automation—it was a structured collaboration with clearly defined roles.

3. True Accountability

Unlike the current generation of "AI agents" making opaque decisions, MCP interactions require explicit direction and consent. Permissions flow through the MCP server's governance model, and every action can be traced to a specific user request.

This addresses one of the most pressing concerns about AI automation: the fear of systems acting without oversight. With MCP, you remain firmly in control, directing rather than being directed.

That distinction matters. Most AI tooling today is built to maximize capability—it'll generate paragraphs, write code, translate documents, summarize meetings. But capability without constraints tends to drift. As we integrate more AI into our workflows, it's easy to fall into a kind of quiet abdication. You let the model suggest the text, the structure, the headline, the strategy. The risk isn't just bad content. The risk is disconnection. You stop being the author and start becoming the approver.

MCP is a counterweight to that drift. It forces you to define the system. It makes you specify what the model should know, what it should be able to do, and when a human needs to intervene.

The Real-World Challenges We'll Face

I'm not painting a utopian picture here. Transitioning to MCP-centric workflows will surface genuine challenges:

Authentication Complexity: Mapping your credentials across multiple services to MCP tokens isn't trivial. Each service has its own OAuth flow and permission scopes that need careful orchestration.
Experience Limitations: While chat interfaces excel at linear workflows, they struggle with spatial visualizations. How do you represent a Gantt chart or design mockup in a conversational UI? This remains an area for innovation.
Governance Hurdles: Organizations must define clear policies for which agents can invoke which servers, under what conditions. Without robust role-based access control, there's risk of privilege escalation or misuse.
Error Handling: When a server fails or hits rate limits, the experience needs to degrade gracefully. Early MCP implementations will likely have rough edges here.

But these challenges pale in comparison to the potential benefits. Just as we worked through the early UX issues of graphical interfaces, we'll iterate toward elegant solutions for conversational computing.

Why This Matters More Than You Think

If you're thinking this sounds interesting but not revolutionary, consider the trajectory of computing interfaces.

We moved from command lines to GUIs because visual manipulation offered more intuitive ways to interact with information. Now we're approaching another inflection point—one where natural language becomes the primary interface, not because it's trendy, but because it's the most efficient way to express complex intents.

Microsoft is already preparing to embed MCP support in Windows AI Foundry, enabling AI applications to interface with native components like the file system and Linux subsystems.¹ This isn't a peripheral feature; it's a foundational shift in how operating systems will work.

Imagine a future where your voice assistant doesn't just launch apps but orchestrates complex workflows across them. "Draft a response to that client email, schedule a follow-up meeting next Tuesday, and update our project timeline to reflect the new deadline"—all executed through MCP calls without opening a single app window.

This whole experiment started as a way to reduce friction in a very specific part of my creative process. But it ended up clarifying something broader: my relationship to AI shouldn't be passive. It should be designed. And if I don't define the boundaries, someone—or something—else will.

The Future Belongs to Protocol-First Applications

As this vision matures:

Traditional UIs will recede into the background, invoked only when necessary for precision tasks or rich visualizations
The primary interface will be conversational, with LLMs executing MCP calls under your direction
Developers will focus on creating specialized MCP servers that expose their domain logic once, rather than maintaining separate frontends for multiple platforms

Remember the app overload I described at the beginning? That fragmentation will give way to synthesis. The boundary between human and machine agency will become clearer, more deliberate, and more controllable.

Much as USB-C standardized hardware connections and sparked a wave of interoperable devices, MCP can become the connective tissue of our AI-enhanced workspace—one where we direct rather than react, where context flows seamlessly rather than being repeatedly reconstructed.

I'm already using this with Claude Desktop, which supports MCP natively. I can tell it to remember something, ask what it knows, or use context to write and post updates directly to Slack—all while maintaining control over what the AI is allowed to do.

What You Should Do Now

If you're a product manager, start thinking about how your application might expose its functionality through MCP servers.
If you're a developer, familiarize yourself with the MCP specification and consider how it might simplify your integration challenges.
If you're an end-user, start asking your vendors about their MCP roadmap. The more demand we create, the faster adoption will accelerate.

The cognitive overhead of our current multi-app world isn't just annoying—it's unsustainable. As work becomes increasingly complex, we need tools that reduce rather than amplify that complexity.

Model Context Protocol offers us a path forward: a standardized, open conduit allowing AI to orchestrate data and actions across our fragmented digital landscape. It promises not just productivity gains but a more humane approach to work—one where our tools anticipate context without overwhelming us with interfaces.

The future isn't another feed or dashboard. It's a lightweight, protocol-first approach where AI executes our intents seamlessly across systems. And unlike many hyped technologies, this one is already here—the implementation details being worked out in real-time.

We don't need AI to be smarter. We need it to be more accountable. And that starts with us being clear about what we're delegating, why we're delegating it, and how we make sure we're still responsible for the outcome. MCP doesn't solve that for you. But it gives you a place to start.

The era of MCP-powered workflows is beginning now. The question is: will you be leading the change, or catching up later?