The Last Interface

There is a certain type of software developer — you may know one, or be one — who has, in recent years, migrated their entire working environment to the terminal. Not out of nostalgia, not because GUIs don't exist, but as a considered choice. They're using Helix instead of VS Code, Zellij instead of Kitty tabs managed by a mouse, lazygit instead of GitHub Desktop. Their screen, when you look over their shoulder, looks like 1992 except it's running on a $3,000 laptop and they've mapped every keybinding by hand.

This is interesting for a few reasons. The most obvious is that it contradicts forty years of received wisdom about interface design. We were supposed to be moving toward more visual, more tactile, more intuitive software — toward touchscreens and voice and eventually some kind of immersive spatial computing. And we are, in a lot of contexts. But in the domain where software is made, a countermovement has taken hold, and it's worth understanding why.

What's actually happening

Nadia Okonkwo is a backend engineer at a fintech company in Midtown Manhattan. She made the switch to a terminal-first setup about two years ago, starting with her text editor and eventually moving her file management, git workflow, and note-taking there as well. When I asked her why, she gave an answer I heard in some form from almost everyone I talked to: "I got tired of the GUI lying to me."

What she means by "lying" is not deception exactly, but misdirection — the way a graphical interface presents a simplified model of what's actually happening underneath. When you click a button in a deployment dashboard, you don't see the command that runs. When you use a file manager to move something, you don't see the filesystem operation. This is, of course, the entire point. Abstraction is how you make software usable by people who don't know what's underneath. But for people who do know what's underneath, or who want to, the abstraction can become a source of opacity. "I want to know what's happening," Okonkwo said. "In the terminal, the output is the truth."

James Park, a systems programmer in San Francisco, put it differently. He described the GUI as imposing a particular model of how you should think about a problem — one path through the interface, one set of options surfaced, a workflow the designers assumed you'd want. The command line makes no such assumption. It gives you primitives and leaves composition to you. "You can pipe anything to anything," he said. "That's philosophically different. The interface is not deciding what's useful. You are."

The tools that made this viable

Terminal-first workflows have always been possible, but they haven't always been practical — or pleasant. The tooling has improved dramatically. Helix, a modal text editor written in Rust and released as stable in 2022, offers a VS Code-competitive feature set (LSP support, tree-sitter parsing, multi-cursor editing) without any of the Electron overhead. It starts in under 50 milliseconds. Zellij is a terminal multiplexer that is, by any measure, easier to understand than tmux — its default configuration is sane, its documentation is clear, and it doesn't require a cheat sheet to use. lazygit gives you a full git workflow in a TUI that is, for many operations, faster than GitHub Desktop and works with any repo on any machine.

These are not novelty tools. They have active maintainer communities, stable release cadences, and in some cases — Helix and Zellij both — several hundred contributors. They represent a bet that the terminal is a legitimate, sustainable place to work, not a legacy that needs to be escaped.

What this reveals about abstraction

Every layer of abstraction in software is a trade. You give up expressiveness and transparency; you gain accessibility and safety. The trade is almost always worth making for end users. For software makers, it is sometimes worth making and sometimes not, and the right answer depends on what you're actually doing.

The command line doesn't win on every dimension. It has a steep learning curve, almost no discoverability, and terrible defaults if you don't configure it. "There's a real cost to learning this stuff," admitted Okonkwo. "I spent weeks getting my setup to a place I was happy with. I couldn't have just handed it to a new grad and said 'here you go.'"

"The GUI is for getting things done. The terminal is for understanding what's happening while you get things done. Both are true at different moments."

— James Park, systems engineer

This is not an either/or argument. Most of the people I spoke with still use graphical tools for specific tasks — browsers, obviously, but also Figma for visual work, or specific desktop apps where the GUI is genuinely better. What they've rejected is not GUI software but the idea that the terminal is a primitive stage that better design eventually supersedes. It's not a step on the way to something else. For certain kinds of work, it is the destination.

The deeper question

There's something the terminal revival points at that extends beyond developer tooling. We spend most of our days in interfaces that have been optimized for engagement rather than understanding, for simplicity rather than power, for the median user rather than the expert one. The terminal, for all its friction, is the rare interface that trusts you to know what you're doing. It gives you the raw materials and gets out of the way.

Whether that's a feature or a bug depends on who you are and what you're trying to do. But the fact that a growing number of people — not as a retro affectation but as a practical choice — are choosing it suggests something worth taking seriously. The abstraction is not always the product. Sometimes the thing underneath it is.