CLI: Commands, Pipes, and the Unix Idea

The terminal stopped being intimidating the day I saw that every command, however cryptic, has the same four parts.

A command-line interface lets you operate a computer by typing instructions instead of clicking. You type a line, press enter, the machine acts. It looks primitive next to a polished app, and that plainness is exactly the point: text is precise, it can be saved and replayed, and anything you can type, you can automate.

Every command shares one shape. Once you can see it, the wall of cryptic text turns into something you can read. Here it is on a command you've probably run:

That's the whole grammar. A program, an optional subcommand, flags that change the behaviour, and the arguments it works on. Learn to spot those four and no command is opaque again.

The one idea that changed everything: the pipe

The command line came out of Unix, built at Bell Labs in the late 1960s and early 1970s. The idea that made it powerful arrived shortly after: the pipe, written with a vertical bar |. It feeds the output of one small program straight into the next. Watch a real one grow, a stage at a time — the task is “count the error lines in a log file.”

$ cat log.txt                     # the whole file pours out
$ cat log.txt | grep error         # keep only lines containing "error"
$ cat log.txt | grep error | wc -l   # count those lines  → 47

Three tools that each do exactly one thing — read a file, filter lines, count lines — snapped together on the spot into a fourth thing that none of them does alone. You didn't write a program to count errors. You composed one from parts in a few seconds.

That philosophy has a name. Doug McIlroy, who invented the pipe, summed up the Unix idea: write programs that do one thing well, and write them to work together. Instead of one giant tool that tries to do everything, you keep a kit of small sharp tools and combine them as needed. Standards later smoothed out the differences — POSIX defined common shell behaviour so a script written once runs almost anywhere.

Why builders — and now AI — live here

That “small tools that compose” idea is the root of nearly all modern automation: CI pipelines, deploy scripts, data plumbing, and agent workflows are all chains of single-purpose steps. It's also why the command line is the natural home of AI. Anything you can type, you can script; anything you can script, an agent can run. When you give an AI agent a tool that shells out to a command, you're handing it the exact same lever you use yourself.

Try this

Open a terminal and run ls | wc -l. You just piped the list of files in the current folder into a line-counter — a two-tool pipeline you built in five seconds. That, scaled up, is most of what automation actually is. The composition idea gets a lesson of its own in Craft & Systems.

Sources — Wikipedia, Command-line interface and Unix shell (Bell Labs history; McIlroy and the pipe; POSIX).