When I first learned about Unix and “Unix-like” operating systems, I was intrigued. I had only known the colorful world of Windows 3.1 so far. Like Japanese carpentry, everything seemed to be carved out of one block with no apparent cracks (except that Japanese carpentry is rock solid, and the same cannot be said about Windows 3.1 with a straight face). Imagine my surprise when I sat in front of a command-line prompt for the first time. The blinking cursor dared me to enter something and there was, at first, no obvious way to achieve any of the things I already knew a computer could do. A formidable puzzle—I was hooked! Thanks to a surprisingly well-stocked library the next village over, I learned that there are different flavors or evolutionary cousins of Unix, and that some of their behavior is codified by standards like POSIX. I also learned about GNU and the heroic efforts of the first waves of hackers who made all of this software available to a world that seemed more interested in locking down everything and preventing any tinkering. O brave new world!

But I persisted. I stared down the ever-blinking prompt and fed it. Many moons later, after a detour with FreeBSD, I remain an avid Linux user since it suits my working style: I like to live dangerously, often deferring kernel updates right before important deadlines—what a thrill—and generally being quite optimistic about my ability to get myself out of any jam. What I appreciate is that Linux lets me exercise my self-efficacy. In essence, virtually all the pain I may experience by using it is, to a large extent, self-inflicted. That feels so much better than having to pray that the next iOS update does not destroy my devices or some other nonsense.

This attitude is often met with blank stares or the usual “Anyway, …” by people who just don’t get it, i.e., almost everyone else who is not a huge nerd, Neal Stephenson fan, or blessed with an abundance of free time. Next to the nice tingling sense of danger, the thing that entices me most about Linux is the ability to mold it to my purposes like digital clay. Many of the command-line tools I use have been around for quite some time now ^{but they still work admirably and allow me to do things like this:}

rg -t py "^\s*url ="                               \
  | grep -Eo "(http|https)://[a-zA-Z0-9./?=_%:-]*" \
  | awk -F/ '{print $3}'                           \
  | sort                                           \
  | uniq -c                                        \
  | sort -rn

In natural language, the purpose of this command is to extract and count domain names like github.com from URLs that are assigned to variables named url across all Python files in the current directory and its subdirectories. If this reads like gibberish to you, my younger hothead self, full of (neo)vim and vigor, would have hit you with the old “Linux is very user-friendly; it’s just also super picky about its friends.” Yes, younger me was adept at making enemies like a craftsman.

With the wisdom and mellowing of the years, I would now be diplomatic, but it still strikes me as odd that this way of working with a computer is so alien to many. Explaining my ancient workflow to someone who is used to only modern GUIs is a bit like explaining higher dimensions to someone inhabiting Flatland: At best, they will politely listen before discarding what you said as mildly odd and going back to their old ways. But again, I persisted and stuck to my conviction that a computer should offer you a general-purpose interface that enables you to build things you like. GUIs can only partially sate that need since they need to guess what path you are wont to take. By contrast, the Unix graybeards of yore realized that it is futile to guess or railroad user behavior—instead, they opted to equip everyone with a couple of smallish tools that adhere to a certain philosophy:

1. Write programs that do one thing and do it well.
2. Write programs to work together.
3. Write programs to handle text streams, because that is a universal interface.

Decades later, this still works. Programs have become larger, more complex, but also more convenient for highly-specific cases like video editing—but at the core of many machines lies this wonderful interface that offers nigh-limitless fun. ^{Instead of widening the gap between the CLI dwarves and the GUI elves, however, something unexpected happened, viz., the development of large language models. Presenting at first nothing but an input box to the user, they constituted a deliberate break in habits for many. Here, then, was no GUI waiting for you to specify what type of picture you wanted to create. The prompt was daring you to dream big. I imagine for some, it must have been a bit shocking even—a program that does not tell you what to do with it was unheard of.}

And progress marched on, leaving the prompts of the early days ^{for ever-refined queries in natural language. Now, instead of having to know about awk, grep, and friends, one can just ask their favorite LLM:}

I want to extract and count domain names like github.com from URLs that are assigned to variables named url across all Python files in the current directory and its subdirectories. How do I do this with a set of shell commands?

The output is quite competent:

grep -rhoP "url\w*\s*=\s*['\"]\Khttps?://[^'\"]+" --include="*.py" . \
    | sed -E 's#https?://##; s#/.*##'                                \
    | sort                                                           \
    | uniq -c                                                        \
    | sort -rn

The commands do more or less the same thing. My hand-crafted one with rg automatically ignores hidden directories, though, which is typically what you want to do when searching code, but I did not provide that context to the LLM. Moreover, -P will fail on operating systems that use the BSD variant of grep. Again, the LLM lacks the context, but this command will work when I copy and paste it into my terminal. I could even use one of the CLI tools myself to make it directly execute the command for me, with the LLM serving as a translator between natural language commands and ancient Unix incantations.

In that sense, LLMs are embodying the Unix philosophy. Of course, this analogy has holes so big you can easily ride a horse through. LLMs are neither small nor do they do one thing—you could even argue that some of the things they do, they certainly do not do well. These issues notwithstanding, LLMs understand that text is the universal interface. Instead of users needing to learn how to talk to the computer, the computer now talks to you. A couple of years ago, this notion would have seemed utterly optimistic. No one would have expected that “text and tokenization” are the recipe for building general-purpose AI models. But here we are, relying less and less on GUIs and instead going back to our beloved Unix-like interface.

For all the problematic things around AI, ^{we may at least find some comfort in being vindicated after so many decades: Text reigns supreme and Unix won.}