CLI, API & MCP for Complete Beginners

The Big Picture

You already have a Terminal. Then people say “call the API” or “connect MCP” and it sounds like a third career.

These are not three products. They are three doors into the same building: a way to ask a system to do something or answer something.

CLI — you type a command in the Terminal. git status is this door. Visible, easy to audit, you are present.

API — one program asks another in a format both agree on. You rarely see it. Every app refreshing a feed is this door.

MCP — a standard plug so an agent can use tools (mail, files, a store) without you writing custom glue. USB for AI. Still your approval on anything expensive.

The Restaurant Analogy

You at the counter→CLI

A ticket through the window→API

Intern + ticket pad + your sign-off→MCP

The kitchen→Gmail, GitHub, a store, a host

“I need last week’s sales”→The job — independent of the door

You do not need to build an API or write an MCP server. You need to know which door you are standing at, and what that door cannot do.

Key Terms

CLI

Command Line Interface. A program you operate by typing. The Terminal is the window; the CLI is the program’s words.

API

A published way for software to ask other software for data or actions. You rarely see it.

MCP

Model Context Protocol. A USB-shaped plug so an agent can use tools without custom wiring.

Key / token

A password for programs. Treat it like a password. Never drop it in a skill file.

Door 1: CLI

Who talks: you (or an agent typing as you). Where: the Terminal.

terminal

% git status
On branch main
nothing to commit, working tree clean

GitHub Desktop is the same job with buttons. Other CLIs: gh, npm, host CLIs when you deploy. Each program has its own words. The Terminal is just the room they sit in. See Terminal 101.

Use it when you are at the keyboard, the steps are known, and you want to see exactly what ran. An agent can run CLI commands — if you would not paste the command yourself, do not nod through the approval.

Door 2: API

Who talks: a program, to a program. Behind “Sign in with Google,” behind every app refreshing a feed.

A contract: if you send a request that looks like this, with this key, I will send data back that looks like that. Human version: git status. Machine version (you do not memorize this): GET /repos/you/project with a key.

Use it when two systems need to talk on a schedule or at volume, and a human typing every request would be the bottleneck. You still do not have to build one. Operators use APIs by connecting tools. JSON — the curly-brace text — is a labeled lunchbox for data. You can read the labels.

Door 3: MCP

Who talks: an agent, through a standard plug, using tools you attached. Where: Cursor, Claude Code, Codex, Buzz, and other hosts that speak MCP.

Before MCP, every agent needed custom wiring to read Gmail. MCP says: tools advertise themselves in a common shape. The host is the app the agent lives in. The server is one plug (Gmail, Drive, a store). Each tool is one allowed action.

MCP is not a model, not a skill, and not automatic permission to spend money or email a customer. A skill can say “use the Gmail tool.” MCP is how that tool exists.

Same Job, Three Doors

Job: get last week’s sales into a recap.

Door	What happens	You feel
CLI	You run an export, paste the file into chat	Hands-on, visible, easy to audit
API	A script or dashboard pulls numbers every Monday	No typing; you still bought or built the pipe
MCP	The agent calls an allowed “get sales” tool, then follows your skill	You ask in English; you still approve writes

All three can be correct. The recap skill does not care which door the numbers came through — as long as the numbers are real.

How to Pick

Ask: who is talking? Me / a script / an agent. And: what are they allowed to do? Read only, or also change something.

Situation	Door
I am at the keyboard and the command is known	CLI
This should happen on a schedule, no chat	API (or a tool that wraps one)
I want to ask an agent in English, with live data	MCP
I am still learning the job	CLI or a paste — then automate
The action spends money, emails a customer, or edits a listing	None of them unattended

If you cannot name the system (Gmail, GitHub, Seller Central), you are not ready for a door. That is a skill problem, not a plumbing problem.

Permissions

The intern with the ticket pad should not get the vault keys.

Read is cheaper than write.
Approve anything that sends, publishes, spends, or deletes.
Keys are passwords. Never in SKILL.md, never in a public repo.
One plug at a time. Twelve MCP servers on day one is how you lose the plot.
Revoke is a feature. If a key leaked, kill it.

CLI access to your whole machine is a bigger blast radius than one MCP tool that can only list yesterday’s orders. That is the point of the menu.

How This Fits the Other 101s

Skill = how to cook the dish. CLI / API / MCP = how ingredients get to the counter. Buzz / Cursor = which kitchen you are standing in. HTML is the page — a different 101.

Common Mistakes

Mistake	Better
Calling everything “the API”	Name the door: CLI, API, or MCP
Treating MCP as a model	MCP is a plug. The model is the cook.
Skill and tool in one bucket	Skill = recipe. Tool = hands.
Full shell because MCP felt like work	Start with one read-only tool
Keys in chat or `SKILL.md`	Password manager / env file / gitignore
Twelve integrations on day one	One door, one system, one job

Cheat Sheet

map

Job: weekly sales recap
  Recipe  → skill (SKILL.md)
  Hands   → CLI export  or  API pull  or  MCP tool
  Kitchen → Cursor / Buzz

Type git status → CLI. Two apps sync every morning → API. Ask an agent “what landed in support yesterday?” → MCP, read-only. Stop re-explaining the recap format → a skill, not a new door.

Glossary

CLI = you type commands at a program. API = programs ask each other. MCP = standard plug for agent tools. Terminal = the window, not the same word as CLI. Tool = one allowed agent action. Host = the app the agent lives in. Key = a password for programs. JSON = labeled text for data.