There is something funny happening in tech right now. We have the best screens, the best graphics, the smoothest interfaces we’ve ever had. And a growing number of people are choosing to stare at a black window with white text instead.
The command line is back. And AI is the reason it matters this time for everyone, not just for engineers.
Last week I wrote about how the prompt became the new interface, and I touched the terminal briefly as a historical note. But the CLI (command line interface, the black window with white text) deserves its own episode, because it turns out to be one of the most powerful ways to actually work with an AI today. So let’s go deeper on that.
A quick history for the rest of us
If you’ve never used a terminal, here’s the short version. Before we had windows and icons and mouse pointers, the only way to use a computer was to type commands. You had to know the exact words, the exact order, the exact punctuation. One typo and the machine would just stare at you with an error message.
Then came the graphical interface. Buttons, menus, drag and drop. Suddenly you could use a computer without memorizing anything. It was a revolution for obvious reasons.
But developers and system administrators never fully moved on. For them, the terminal stayed faster, more powerful, and more flexible. You can chain small programs together, automate repetitive work, and do things in seconds that would take dozens of clicks in a graphical tool. The terminal just went underground for a few decades, used mostly by people who already knew it.
Why it’s coming back now
Two things happened at roughly the same time.
First, a new generation of terminal tools appeared. Programs like bat (a better file viewer), ripgrep (a faster search), fzf (fuzzy finder), eza (a modern file listing) made the command line not just powerful but also pleasant to look at. The old terminal was ugly and utilitarian. The new one has syntax highlighting, smart formatting, and actual usability improvements. There’s a whole online subculture of people customizing their terminals into something close to art, trading color schemes and layouts the way others trade desktop wallpapers.
Second, and more importantly, AI arrived. And it turns out that AI and the command line were made for each other.
Text in, text out
Think about how an AI model works. It reads text and it produces text. That’s it. It doesn’t see your screen. It can’t move your mouse. When an AI needs to actually do something on your computer (not just answer a question), the simplest way is through the terminal. Type a command, read the output, decide what to do next.
This is why the most capable AI tools today are terminal-based. They don’t need to recognize buttons or navigate menus. They just read and write text, which is exactly what the command line does.
And here’s the interesting pattern: AI tools followed the exact same path as computing itself. First came the terminal versions (for developers and power users). Then came the polished graphical interfaces on top (for everyone else). The same cycle, but compressed from decades into months.
The wall that disappeared
I want to share something personal here, because it’s the best example I have for what this shift actually means in practice.
I’m a programmer. I’ve used terminals before. But when I decided to switch to Linux as my main operating system, the thing that worried me most was the command line. On Windows, you can mostly avoid the terminal. On Linux, it’s part of daily life. And the syntax is different from what I was used to. I didn’t want to spend weeks memorizing new commands.
So I installed an AI coding assistant right after setting up the system. And from that point on, I barely had to type a command myself. I just described what I wanted in plain language: “find all files larger than 1 GB,” “set up this drive to mount automatically,” “change the default application for PDF files.” The AI translated my intent into the right terminal commands and ran them.
It completely changed the experience. What used to be a wall between me and Linux turned into something natural. Within weeks, Linux became my daily driver, and I rarely boot into Windows anymore.
Learning by watching
The interesting side effect is that I actually started learning the commands anyway. When the AI runs something, I can see exactly what it did. If I’m curious, I ask it to explain. Over time, some commands just stuck.
It’s a different kind of learning. Not “read the manual, memorize the syntax, then try it.” More like watching someone work and gradually picking things up. The AI is both the executor and the teacher, and it has something that Stack Overflow never had: it sees your actual system. It knows your file structure, your permissions, your setup. The answers aren’t generic. They’re specific to you.
The invisible assistant
Here’s something that surprised me about working this way. I started running things through the AI even when I already knew the command. Not because I needed help, but because of context.
When the AI runs a command, it remembers what it did. It knows what was changed, when, and why. If I run something manually in a separate terminal window, by default the AI has no idea it happened, and next time I ask for help it might work from outdated assumptions. I could keep a notes file for it to read later, but that becomes its own small chore. Running through the AI keeps the memory continuous without the bookkeeping.
It’s a bit like version control. You commit your changes so your team can see what happened. Now I run commands through the AI so it can see what happened. It sounds small, but it changes how you think about the relationship. The AI stops being a tool you use when you’re stuck. It becomes more like a partner you keep informed.
Still a hidden world
Despite all of this, the command line is still a niche. Most people who use AI daily have never opened a terminal. They use web interfaces, chat windows, graphical apps. And that’s fine. The terminal doesn’t need to be for everyone.
But I think it’s worth knowing that it exists, and that it’s where a lot of the real power lives. When you use a friendly AI interface and ask it to organize your files or search through your documents, there’s a good chance that behind that polished surface, it’s running terminal commands. The graphical layer is just the translation between your words and the machine’s native language.
The command line started as the only way to talk to a computer. Then it became a specialist tool, hidden behind decades of graphical interfaces. Now AI is bringing it back, not by making everyone learn terminal commands, but by speaking both languages at once: yours and the machine’s.
For me, that’s what the CLI renaissance is really about. It’s not that the terminal got cooler (though it did). It’s that for the first time, you don’t have to choose between power and accessibility. You can have both, as long as there’s an AI in the middle doing the translation.