Simple commands beat complex protocols

In February 2026, GitHub's Eric Holmes published a post on his blog under this title:

"MCP is dead. Long live the CLI."

His argument: Anthropic's ambitious Model Context Protocol (MCP) had, just a few months after launch, effectively failed. Neither OpenClaw nor Pi supports MCP. Why not?

※ A command-line interface (CLI) is a way of controlling a computer or piece of software by typing commands at a text terminal with your keyboard, rather than clicking with a mouse. A shell interprets each command and prints the results to the terminal. Compared with a GUI, it is better suited to automation and to managing complex infrastructure. CMD/PowerShell on Windows and Terminal on macOS/Linux are the familiar examples.

The command turned out stronger than the protocol

※ MCP (Model Context Protocol) is a standardized communication spec, developed under Anthropic's leadership, for connecting AI models to external data, tools, and applications (Slack, Google Drive, and the like). It acts like a USB-C port for AI agents — letting them take real actions such as querying databases, analyzing files, and automating work — and it cuts down on repetitive integration.

When MCP arrived, the industry was electrified. Every company rushed to build an MCP server to prove it was "AI-first." New endpoints, new communication formats, even new authentication schemes. The stated goal was to make the link between LLMs and existing services smoother.

But reality told a different story. LLMs could already use command-line tools flawlessly. An AI trained on millions of manual pages, Stack Overflow answers, and shell scripts in GitHub repositories simply didn't need a new protocol.

When Holmes hands Claude a 'gh pr view 123' command, it just works. A separate protocol? Not needed.

What happens when humans and AI use the same tools

So what about the time Claude pulled an unexpected result out of Jira? Holmes says he could run the very same 'jira issue view' command himself and see exactly what the AI had seen. Same input, same output.

With MCP, by contrast, the tool exists only inside the LLM conversation. When something goes wrong, you have to dig through JSON transport logs. Debugging now requires a protocol decoder.

And here is the key insight. When humans and AI use the same tools, collaboration becomes possible. A person can understand and fix what the AI produced, and the AI can pick the work right back up in the environment the human set up.

The power of composition beats the protocol

CLI tools compose. You can connect them with pipes, chain them with grep, and redirect them to files. Beyond mere convenience, this is sometimes the only solution.

Consider analyzing a massive Terraform plan. On the command line, a single line does it: 'terraform show -json plan.out | jq '[.resource_changes[] | select(.change.actions[0] == "no-op" | not)] | length''.

And under MCP? You either dump the entire plan into the context window (expensive, and often impossible) or build custom filtering into the MCP server. More complex work for a worse result.

A philosophical shift hidden inside simplicity

MCP didn't fail because something else was technically superior. It failed over a difference in philosophy. MCP assumed "we need a special protocol," while the CLI says "what already exists is enough."

Authentication makes this even clearer. MCP is needlessly stubborn about auth. Why should a protocol whose job is to hand tools to an LLM concern itself with authentication at all?

CLI tools don't bother. aws uses profiles and SSO, gh uses 'gh auth login', and kubectl uses kubeconfig — battle-tested auth flows that work the same whether a person is at the keyboard or Claude is driving.

Tools that non-developers can understand

Here is where something interesting emerges. As complex protocols fade and simple commands move into the mainstream, non-developers are stepping into this territory too.

Connecting to APIs and processing data used to be the exclusive domain of developers. You had to understand a complicated SDK, manage authentication tokens, and implement error handling.

But in an era where AI translates CLI commands from plain language, that changes. Say "tell me how many GitHub issues created this week carry the bug label," and the AI writes and runs 'gh issue list --label bug --created ">=2026-02-24" --json number | jq length'.

So what happens next? A product manager analyzes marketing data, a designer automates asset placement, a content team extracts SEO metrics. No need to learn a complex protocol — you just need a clear goal.

The tools disappear; the thinking remains

This is the real meaning of MCP's failure. The more complex the technology becomes, the more users focus on the goal rather than the technology itself. You no longer need to understand the protocol, and you no longer need to memorize command syntax.

So what's left? The ability to express clearly what you want. The thinking that defines a problem, verifies a result, and designs the next step. In other words, the realm of attitude.

When Holmes collaborates with Claude, what matters isn't understanding the MCP protocol. It's judging what data is needed, what to do with that data, and how to respond when the result differs from what was expected.

The simpler the tools get, the more important the human role becomes. This is an age in which the wisdom to know what to solve through technology matters more than the skill to operate it.

Come to think of it, what does this shift — complex protocols dying and simple commands being reborn — really mean? In the end, it is the process of humans becoming the masters of technology rather than its slaves. The victory of the CLI is, in the end, the victory of the thinking human.