Moving Back to the Terminal

History has taken an amusing turn. Advanced users once lived in Norton Commander and similar tools: two panels, keyboard shortcuts, and almost no friction between thought and action. Then everything moved into graphical interfaces. IDEs grew more powerful and user-friendly, while the terminal began to look like a place for sysadmins, Linux diehards, and people who enjoyed making life difficult for themselves.

Then AI tools arrived, and the terminal moved back to center stage.

The GUI is not dead, and nostalgia for a black screen has little to do with it. The terminal simply fits this new kind of work remarkably well. Graphical tools are still better for visual navigation, debugging, and browser devtools. But when a task becomes a sequence of operations across a project, its files, tests, and git state, the terminal starts to make a compelling case again.

The terminal used to be where you ran commands yourself. Now it is also a place where an agent works beside you. Claude Code, Codex, Aider, Hermes, and similar tools fit naturally there because everything they need is already present: code, git, tests, the shell, ssh, logs, tmux, and the actual workflow.

Why the Terminal Is Useful Again#

The terminal keeps friction low. Everything is close at hand. You do not have to jump among windows, tabs, and panels or translate every intention into a series of clicks. You can think more directly: find this, check it, compare it, run it, fix it, show me the diff.

Norton Commander was more than a file manager. It was a machine for reducing friction. You did not admire the interface. You got work done. Navigation, copying, renaming, archives, permissions, batch operations — all from the keyboard, all quickly.

New AI tools in the terminal play a similar role at a different level. Back then, you managed files. Now you increasingly manage intent: figure out what is happening here; find the failure; compare these branches; prepare a fix; run the tests; show me the diff.

All of this happens in an environment where the tool does not need to simulate access to the real work. It is already inside it.

Say a test fails after a module changes. In a graphical workflow, I might jump among the IDE, terminal, browser, git client, and logs. In the terminal, it becomes one continuous flow: status, diff, related code, the failing test, its error, a small fix, and another test run.

There is no magic here. There are simply fewer context switches and fewer places for context to disappear.

TUI No Longer Looks Retro#

Interface density is another reason the terminal is returning. A good TUI is almost always more compact than its graphical counterpart. One screen can hold more useful state with less decorative noise.

lazygit, tig, yazi, rmpc, htop, btop, k9s, and network tools such as netwatch have already shown that a text interface does not have to feel archaic. It can be fast, tidy, and pleasant to use every day.

Many modern TUIs are built in Rust and similarly fast stacks, so they feel nearly instantaneous. New terminals can also display images directly in the window through features such as the Kitty image protocol. That does not turn the terminal into a GUI, but it does make it feel less like a bare command line and more like a complete workspace.

tmux, the more modern zellij, and the agent-oriented herdr add another useful layer. For agentic work, this environment becomes a kind of desktop: the agent, tests, logs, shell, and git all live next to one another. You can leave a session running on a server, return later, and continue where you stopped.

AI Was the Catalyst, Not the Cause#

Interest in the terminal did not grow because of AI alone. AI was the catalyst. The ground was already prepared by fatigue with overloaded GUIs, mature keyboard-driven workflows, remote work, ssh, containers, and the habit of thinking through git and automation.

AI fits this environment so well because it works best where real tools are already available.

The terminal can still intimidate beginners, and that is understandable. Mistakes are easy to make, and sometimes the consequences arrive before you understand what happened. Even basic GUI habits break: Ctrl+C means copy in most graphical apps, while in the terminal it usually interrupts a running program.

The terminal did not suddenly become simple because an agent appeared beside it. An agent can handle some navigation, explanation, and routine work. It does not remove the need to understand what is happening, but it lowers the barrier to entry.

Where the Terminal Beats the GUI#

The "GUI versus terminal" debate feels too simplistic. These tools have different strengths. The terminal is especially good again for sequential work with code, commands, and state.

For developers, this changes not only the shape of the work but also the way we think about it. You once managed individual actions: open a file, press a button, choose a menu item, run a command. Increasingly, you manage a stream of tasks. You state an intention, then either carry out the sequence yourself or delegate it to an agent working beside your usual tools.

In that sense, the terminal is no longer a symbol of austerity or a club for retro enthusiasts. It is simply the shortest path from thought to action when the work consists of text, code, commands, state, and transitions.

We are not moving back to the terminal out of romance. We are moving there because it is useful again.