No. There, I spoiled the ending for you. You can now move on with your life knowing that a shell is not enough. But let me also explain why.

This week, I watched GitHub Copilot help me analyze a few gigabytes of log files by using rg to swim in a sea of unstructured data, extract some JSON with jq, pipe all of that through sqlite3, and generate a fairly comprehensive performance report - all using nothing but shell commands. No custom integrations, no MCP servers, no REST API wrappers, no cellphones in sight - just a terminal living in the moment.

Ah yes, the shell - the green text gateway to adventures.
Ah yes, the shell - the green text gateway to adventures.

It took 15-ish minutes to complete what would have been days of manual work. The question isn’t whether this is impressive. The question is: have we been overthinking tool integration this entire time?

I mean, the shell is a relatively simple abstraction that most developers and power users alike are quite familiar with. Think about it - when’s the last time you used the wrangler CLI to push one of your updated web sites to the cloud? What about gh to manage GitHub pull requests? And ffmpeg to convert that GIF to MP4? How about running an apt install to get a Ubuntu package you needed to compile the video driver for the hundredth time? Oh, and you just downloaded a ZIP with curl the other day. Command Line Interfaces, or CLIs for short, are quite literally everywhere. Whether you’re on Windows, Linux, or macOS - you likely used some command line tools in the past few years.

CLIs are, by all measures, ubiquitous and accessible to anyone with a bit of technical know-how. As a bonus, most widely-adopted products that ship as CLIs are also cross-platform to boot. There’s no excuse not to use them, right?

The Great Divide

When it comes to tooling in AI-based workflows, in the past few months I’ve noticed two distinct camps emerging:

  • Protocol Builders - Developers creating sophisticated integration layers like Model Context Protocol (MCP). I consider myself one of them, as I happen to be one of the Core Maintainers within the project. These protocols are multi-layered abstractions that provide controlled, secure interfaces between agent systems and external tools, and introduce a number of protocol-specific primitives that are meant to be universally adopted.
  • Shell Pragmatists - Developers who bypass all abstractions and let LLMs simply orchestrate CLI tools. Their philosophy is essentially: why build custom integrations when every tool they need already has a command-line interface?

I started out as a firm believer in the first camp, but after my log analysis experiment, I started questioning whether the second camp might be onto something fundamentally different about developer adoption patterns that can improve the LLM integration experience. I was definitely not the only one thinking about this concept in depth.

Why Shell-First Gained Steam

The more I’ve thought about tool adoption, the more I’ve converged on one particular insight: developers adopt tools that don’t require learning a new worldview. Sounds trivial, right? If something integrates with the tools you already work with, it’s easier to use that instead of a whopping new product that requires you to understand the inner workings of something you didn’t need a month ago. That’s the reason we have so many people excited to work on their own OAuth implementation instead of using off-the-shelf libraries.

This is a long way of saying that if you’ve worked in any engineering or engineering-adjacent team, you likely learned that developers are creatures of habit. They have preferences for languages, IDEs, color schemes, fonts, and so much more. To add to this, developers’ habits quite often revolve around the shell in some shape or form, even if that shell is not embedded in the actual OS terminal application. I see developers use their favorite shell from Visual Studio Code, others have it embedded in the browser when connected to cloud services, and so on. A shell is a portal to easily build complex actions from an almost unlimited number of tools and primitives. Just look at any relatively benign shell script and you will see that behind the seemingly simple few lines of code are actually multiple commands that each have their own mission. So, when an AI tool can play nicely with git, cron, and make (just a few commands to illustrate the examples, but they can do a lot as-is) it naturally fits in my and my peers’ developer workflow.

This is also complemented by the fact that modern LLM clients are really good about invoking CLIs if you provide enough context ahead of time, whether that is through a man page, a link to docs, or just a standard --help argument being available in the CLI in the first place. Not every client will be capable of doing this, but those that are generally are pretty decent at it, at least in my experience.

So, if I posit that CLIs are already part of the developer workflow, and LLMs and their clients are an added “workflow sugar” on top, could it be that all we really need is a shell with a couple of CLI components that are able to get the job done?

When Simple Doesn’t Mean Simplistic

A valid criticism of the shell philosophy usually comes on the heels of two issues: scale and complexity. Shell scripts can be fine for personal use, but they might crumble under the weight of real-world enterprise needs. This view misunderstands somewhat the power of the modern shell and the existing ecosystem around it.

The shell at its core is composable. As with any other tool, it has its limitations. You can work with a shell on a local computer just fine, but the moment you start dealing with remote scenarios or otherwise constrained environments that don’t allow you to execute arbitrary commands, things get off the rails. A shell can also add unpredictable complexity - you have to know that a CLI exists for what you’re trying to do if it’s outside the bounds of what the model was trained on. You also need to know that a specific CLI is, in fact, useful for what you are trying to accomplish. I’ve seen first-hand how models tend to hallucinate commands and parameters that simply do not exist.

Whereas, if you plug in a MCP server into your client, things are expected to just work.

Shells are incredibly powerful, and dare I say - even more powerful than any single MCP server. A shell can be used for anything. Write Python scripts and chain them to SQLite queries? By all means. Combine the outputs with some file system search and JSON parsing? Yes, please. Your entire abstraction is the shell. The boundaries are defined by the commands that you can execute within it. You don’t need to worry about the fact that a MCP server might not exist for your scenario (although this point is harder to make now, in September of 2025) - CLI tools are out there for almost anything.

The shell is a convoluted universal remote - the commands are there and the LLM needs to figure out how to use them.

It’s also worth remembering that while there might be a CLI for everything, you still need to bring that context into the client and the model you’re using. If they were not trained on content that covers said CLI, you will need to be creative in designing ways through which the CLI details can be embedded in your LLM-based workflows, like providing crisp usage instructions or guiding the LLM through the command documentation.

Where Did This Land In Practice

To put a bit of a practical spin on my long-winded advocacy effort for CLIs, let’s get back to the example I mentioned earlier in this blog post. For an unnamed project I needed to analyze gigabytes of unstructured data. It’s a bunch of scattered text files containing log information - some of it is JSON, some of it is in a weird YAML and XML combo (it could be so much worse) - just not something I wanted to deal with manually if I didn’t have to.

There are no MCP servers for what I wanted and implementing one would require me wrapping a bunch of existing CLI tools in the MCP interface, which would feel… redundant? Not necessarily an insurmountable task, but certainly one that would require some throwaway work, given that nobody but me wanted to do what I did.

Also, I kept in mind the fact that when it comes to invoking MCP tools, most clients are fairly restrictive on how many tools you can have accessible at any given time (that is getting better in some applications). This is driven by a limited context window in which you have to fit the LLM request, and it need to include tool metadata. If you have too many of them, you risk running out of room for your actual instructions. Not ideal.

Long story longer, instead of stitching together a quilt made out of random MCP servers, I included a number of CLI references in my global project agent file and let Copilot run through the data cleanup and parsing tasks from within Visual Studio Code. The agent put together a script that piped rg output to jq and then used sqlite3 to inject the data in a structured database.

Powerful stuff - a boring job that I was dreading got done in minutes. What was also really cool is that when Copilot put together the shell script, it broke down the workflow into proper, production-ready plan → dry‑run → confirm → execute stages, which was super helpful to be able to diagnose and analyze outputs before any changes are made. Not that I was working on a production database directly or anything like that, but the “thoughtfulness” (I am not trying to anthropomorphize the model here - it’s a statistical text prediction model on steroids) was neat. This level of observability is something that MCP servers don’t quite offer in their default configuration.

The entire saga exceeded my expectations both in terms of speed and just how well it was able to put together the necessary commands. There were some issues where it would accidentally spin up new terminal tabs when it didn’t need to, but overall the experience left me impressed - it did what it needed to do without me bringing in a bunch of custom tooling from third-parties. And for the pedantic readers - yes, ripgrep is third-party, but I already had it installed, so it doesn’t count.

What’s The Deal With Shell Universality

While the shell is a universal construct, the challenge with it is still that it needs to be on some box for you to be able to access it. If I run some tasks on my laptop that require reading code from multiple folders, the client needs to be able to invoke shell commands that access said folders. If suddenly I am running that shell from inside a container, the scope of access changes - I no longer have access to the content on my own computer without jumping through some hoops to mount custom volumes.

Similarly, if I want to run ffmpeg with GPU acceleration, it’s easy to do when I run it in the context of my own profile but becomes trickier when this needs to be done in some other context, like a sandboxed environment or a container.

And by the way, all of this is also sort-of applicable to local MCP servers. Because they’re just local binaries, they have the exact same limitations. A local MCP server is an application you install on a computer that has access to the OS the same way any other application would. It just happens to be invoked and managed by a LLM client. If you run a MCP server on the box, it gets access to whatever the executing user has access to. If you run it remotely, the scope of data access changes too.

So, for most scenarios that I’ve been investigating recently, developers really need the ability to execute actions in their current context - that is, forget about all that “running on the server somewhere” baloney. It’s all about running with all the tools, bells, and whistles that I have right here, on my computer. You can’t control Blender easily from far away.

No, you’re definitely not the only one calling this out. I’ve seen someone build a remote MCP server where they effectively allow arbitrary command execution through a MCP tool, which is all sorts of bad. That’s not quite the CLI integration that I am talking about. What I am envisioning is local execution of commands through LLM-based CLI invocations.

Anyway, for CLIs to work the way we want them to, in a lot of scenarios you will need an unrestricted and singular environment, and that just won’t work well in a lot of enterprise scenarios. Which leads me to my next point.

How You Doin’, Security

We haven’t even talked about shell usability yet, and security is already rearing its… head. Giving a LLM direct access to your shell can make any IT monitoring solution spontaneously combust. Excuse me, it did what with your database, and with what user account?

This kind of functionality would make even the most security-savvy professionals think twice.
This kind of functionality would make even the most security-savvy professionals think twice.

This is where remote MCP servers bring a bit of a shield - you are protected from the worst side-effects of a potentially malicious local server because a remote MCP server can’t quite invoke a rm -rf on your local development box without something going catastrophically wrong. Yes, prompt injections are a thing, I know.

On the other hand, a CLI or a local MCP server can do a bunch of funky stuff - exfiltrate local data, delete things, reconfigure your machine, install more things you didn’t ask for, and the list goes on. Yes, even a local MCP server can do that. Remember when I said it’s just a local application? Yeah.

But realistically, so can any running application that you installed on your machine. Assuming that the developer of the local MCP server is not obviously malicious, if the server can only read database entries - that’s all it can do with your database. No matter how the LLM contorts its prompts, it won’t be able to do more than what the MCP server tools allow it to do. CLIs obliterate that constraint - you may be able to instruct the LLM to not delete the database, but if it somehow “decides” that the easiest way to fix your build error is by wiping the disk clean from your source code and start from scratch, it can absolutely do that.

Unfettered access to the shell can spell doom very, very quickly - the security aspects of this approach would give me nightmares on the best of days, let alone in the threat landscape we live now where a page your LLM queries can tell it to do a bunch of things you didn’t ask for. All of this means that a developer now needs to think through all sorts of ways in which they must restrict the execution of shell commands to avoid potential disaster.

You could integrate things like bubblewrap, work on network rules to prevent processes from doing data egress, and even add in-client constraints, but a lot of that comes at the cost of ergonomics. YOLO-ing through this won’t work in the long run.

Where MCP Shines

This is where I think MCP has the opportunity to really establish itself as a differentiator - not by wrapping CLIs or APIs, but rather by helping create a more controlled environment for agents to operate in.

The more you immerse yourself in this space, the easier it is to recognize that the real risk comes from agents not having guardrails and doing their own thing as they see fit. This is a core feature of modern LLMs but also (and I can’t understate this) a major liability.

MCP servers bring a set of pre-baked primitives to the table that can be safely used by clients without having to worry that you will wake up with your disk wiped. To be clear - there’s still risk depending on the kind of MCP server that you’re using, but it’s a much more managed risk than letting your LLM do anything.

MCP also provides a convenient abstraction layer over things that you really don’t want to reinvent. Let’s say that in the example above I wanted to upload my data to some remote cloud database. Often those come with CLIs, but sometimes the CLI is only allowing me to manage resources instead of allowing me to manage the content within the resource. In this scenario, a CLI can help me create the database or scale it, but will not help me with actually adding entries in.

Could I invoke the authentication APIs with curl, and then craft the exact JSON body for the request, and invoke curl once more with a POST request to submit the data, and then check the response and retry if needed? Sure. But this would be way more complicated than me just adding a MCP server from said database vendor to my client and have it handle authorization and the invocation of the create_entry tools.

A MCP server can also, by design, be compatible with any MCP-ready client. There are some platform considerations to keep in mind, of course - you might need to have python or npx available. But in general, and especially as it applies to remote MCP servers, you won’t have trouble plugging them in across the board. Anthropic is also working on making this better for local servers. The same can’t be said for every single CLI out there you might need. I have jq on Linux, but on Windows outside WSL? I need to bring it in separately. On macOS I can bring in a bunch of stuff with brew, but on Windows this will be useless as winget has a different set of packages available. My shell adventures would not always be portable, while with MCP I get that out-of-the-box.

You should treat MCP as a great convenience layer that removes the burden of implementing tool abstractions over and over, but it also should not be used when there are really good CLIs available for the same scenarios. The pattern here is not to re-implement or wrap CLIs or APIs 1:1 in MCP servers. It’s to use them as complementary tools in your AI toolbox. You have a hammer and a screwdriver - you don’t need to use one or the other for everything.

So Where Does That Leave Us

MCP servers are not meant to replace CLIs. CLIs are not meant to be a universal substitute for MCP servers. They serve quite different purposes depending on what you are trying to accomplish, and you shouldn’t try to shoehorn one as a universal solution instead of the other. And of course, because MCP as a protocol is still maturing, I would encourage you to go to GitHub and help us make it better!