The UI of AI is CLI
We spent decades trying to make computers easier to use. We went from punch cards to command lines to graphical user interfaces to touch screens. We added buttons, menus, icons, gestures, or really anything to avoid making people type commands into a terminal.
And now? Now we’re instructing AI to use… command lines.
Plot twist of the century, right there.
The Great UI Circle of Life
Here’s the evolution in a nutshell:
- 1960s-1970s: Computers are massive, cryptic beasts. Only specialists can use them.
- 1980s-1990s: We invent GUIs! Click buttons! Use a mouse!
- 2000s-2010s: Touch everything! Swipe! Pinch! Even toddlers can unlock your phone!
- 2020s: AI agents are here and they’re… typing commands into terminals?
We’ve come full circle, except now the one typing the commands isn’t human. It’s an AI that never complains about memorizing flags, never forgets the order of parameters, and doesn’t mind reading man pages.
Why CLI is the Perfect AI Interface
Here’s what makes the command line the ideal interface for AI agents to interact with software.
Context is Built In
When you click a button, you get an action. When you run a CLI command, you get context.
git commit --help
The tool itself tells the agent what it can do, what arguments it accepts, what formats it expects. The documentation is in the interface. The context is part of the command structure.
An AI agent doesn’t need to guess or hallucinate. It can ask the tool directly: “What can you do? How do I use you?” And the tool will answer in structured, parseable text.
Controlled Command Structure
Every CLI tool has a defined grammar:
command [options] [arguments]
This isn’t just convention. It’s a contract. A protocol. A standard that every tool follows.
For an AI agent, this is gold. It’s a predictable structure it can learn once and apply everywhere. No special cases. No visual layouts that change. No hidden functionality that only appears when you hover over the right icon.
The command structure is controlled, consistent, and composable.
Arguments Are Known and Well-Defined
Take git commit:
git commit -m "message" --amend --no-verify -a
Every flag is documented. Every argument has a type. Every option has a meaning. There’s no ambiguity. The -m flag always means message. The --amend flag always modifies the last commit.
An AI agent can learn these arguments, understand their purpose, and use them correctly every single time. No interpretation needed. No “is this button enabled?” uncertainty. Just structured, well-defined parameters.
It Returns Everything You Need
But here’s the real magic: CLI tools don’t just execute commands. They teach.
Run a command wrong?
$ git commit
error: pathspec 'file.txt' did not match any files
The tool tells you what went wrong. It provides directions.
Need to know what options are available?
npm install --help
The tool gives you documentation. It shows you examples. It explains itself.
Want to understand what just happened?
$ git status
On branch main
Your branch is up to date with 'origin/main'.
Changes to be committed:
modified: src/app.js
The tool provides details. Context. State. Everything an agent needs to understand the system and make the next decision.
This is the trifecta: actions, directions, and details. All in one interface. All structured. All machine-readable.
The Building Blocks of Agentic Development
Now add the Model Context Protocol (MCP) to the mix, and things get really interesting.
CLI provides the interface. The structured, self-documenting way for an agent to interact with tools.
MCP provides the protocol. The standardized way for an agent to discover capabilities, maintain context, and coordinate actions across different systems.
Agent provides the intelligence. The reasoning layer that understands intent, plans actions, and learns from results.
Put them together and what do you have?
An a-la-carte software development system capable of building most anything.
Why This Combo Works
The CLI is deterministic. Run the same command with the same arguments, get the same result. No hidden state. No visual ambiguity. Pure cause and effect.
MCP is standardized. It doesn’t matter if you’re calling a database tool, a deployment script, or a code formatter. The protocol for discovering and using that tool is consistent.
The Agent is adaptive. It can read the docs, understand the context, try a command, see the result, adjust, and try again. It learns the tools by using the tools.
You’re not building custom integrations for every tool. You’re not writing bespoke APIs for every action. (Well, MCP maybe, but that’s more of a symptom of failing to design API first.)
Instead, you’re leveraging decades of CLI design that was already built for composability, observability, and scriptability.
The Consistency Factor
This is what makes agentic development actually work at scale.
When every tool follows the same command structure, accepts the same flag patterns, returns structured output, and provides inline help, an agent can confidently interact with any tool without special training.
Need to deploy code? kubectl apply -f deployment.yaml
Need to run tests? npm test
Need to query a database? psql -c "SELECT * FROM users"
Same structure. Same patterns. Same predictability.
The agent doesn’t need to learn 100 different interfaces. It learns one interface that 100 different tools all implement. That’s the power of standardization.
The Software Development Paradigm Shift
Here’s what this means for how we build software.
Traditional Development
- Human writes code in an IDE
- Human runs tests manually
- Human debugs errors by reading logs
- Human deploys using a GUI tool (or maybe scripts)
- Rinse and repeat
Agentic Development
- Human describes intent to an agent
- Agent reads tool docs via CLI (
--help,man pages) - Agent executes commands, reads structured output
- Agent adapts based on results (exit codes, error messages, success output)
- Agent chains together tools to achieve the goal
The CLI isn’t just an interface anymore. It’s the contract between human intent and machine execution.
Building Anything, A-La-Carte
Want to build a web app? The agent can:
npm create vite@latest
npm install
npm run dev
Want to set up infrastructure?
terraform init
terraform plan
terraform apply
Want to deploy to production?
docker build -t myapp .
docker push myapp:latest
kubectl rollout restart deployment/myapp
Each command is a capability. Each tool is a building block. The agent just needs to know how to read, execute, and interpret CLI commands.
You’re not building a monolithic system. You’re composing capabilities on demand. A-la-carte. Mix and match. Whatever the task requires.
Why This Actually Works
GUIs hide complexity to help humans. CLIs expose structure to enable automation.
And that structure - the controlled command syntax, the well-defined arguments, the self-documenting help systems, the consistent error reporting - that structure is exactly what AI agents need to work reliably.
We didn’t design CLIs for AI. We designed them for automation, for scripting, for power users who needed predictability and composability.
But it turns out? That’s exactly what AI needs too.
The terminal isn’t a step backwards. It’s the foundation of agentic software development.
CLI + MCP + Agent = Software development at the speed of thought.
And the best part? The infrastructure is already there. The tools already exist. The commands already work.
We just needed AI to show us that the perfect interface for building anything was sitting in a terminal window all along.
-Rob