I'm not about to put any money down - I lack that degree of confidence in my prognosticating - but I doubt the terminal will ever really vanish, for much the same reason that 20 years of touch screens hasn't really put in a dent in a keyboard and mouse for serious work, and game controllers have barely changed despite multiple attempts at VR and other interfaces, and why the stylus is still going strong after more than 5000 years. Sometimes you just get it right.

A text interface is just really damn good at efficient and precise information delivery and interaction, in a way that takes a lot more work for a GUI to match, and they are composable in a way GUIs simply are not. Most users won't - and currently don't - care about terminals, but I doubt it will ever stop being a standard tool for power users.

I don't doubt we'll see new paradigms emerge, but I think they'll come in the form of higher level abstractions for certain classes of task rather than a replacement for the sort of TUIs and GUIs we have today.

This stuff stands on the foundations it's built off of. It's very hard to argue against the stoic determinism of an `ls` call.

And all the success stories I've seen in people using these tools have had a similar theme: top level might be LLM-y but you rush to get to deterministic straightforward building blocks so that you can have reliability.

That, to me, looks like writing up a bunch of small programs to help establish vocabularies and workflows to avoid just churning and getting lost in the weeds.

I'd be interested in seeing some future form of process orientation, but in the meantime.... shells in general have proven they are decently good at tying stuff together quite well.

`ls dir | grep thingy | process` gonna involve less possibility of annoying drift and churn than "run process on all the files with thingy in their name in directory"

Coining this phrase now: "It's the tokens stupid"

Hooking up to and generating calls across filesystem APIs cost multiple orders of magnitude more than calling `ls`. These tooling ideas are interesting, though. Maybe Kenneth_E._Iverson was right all along?

Talking to another senior dev over drinks tonight, we both worried not about our work but about who might come up never having written a single line of code. Never even opened a terminal. Is looking at the code something you learn in semester 5?

I think computer science education is going to stomp onward, poorly. And we will get that generation. And things like "terminal tooling is going out of style" won't even be said any more. Hacker groups will turn from discussions about new ideas to talking about doing leetcode without AI.

Our art died because we used our art to kill it. We are the last human masters.

That's a funny thing to think about.

The end of terminals has been forecast ever since mouse pointers showed up. If you build any nontrivial workflow across weird infra and hairy edge cases, GUIs locked to whatever version of "AI assistant" they're pushing will either make you faster or block you until you rage-reopen a shell.

I think there will always be a class of tool for users who want escape velocity from vendor UX conferences and forced upgrades. The moment sandboxes or walled gardens get in the way of the weird things that keep devs productive, someone will bolt a CLI to the latest AI.

A terminal still offers a more composable interface than a GUI. Analog feedback is still a concern for high level pilots. You are confusing power tools with entry-level instruments.

I'm somewhat agreeing with it. CLI tools won't go away, since lines of text as an exchange format between tools is extremely powerful, especially with text based LLMs. However using an interactive TUI application to prompt agents will probably be less relevant in the future. E.g. if I want to build a web frontend, why wouldn't I just prompt and interact directly on the side I'm building?

My current assumption is that the interfaces and workflows that stakeholders and product owners use today to manage software engineering resources are the future interfaces and workflows towards agentic engineering systems.

I think AI tooling has actually reminded us how useful the terminal really is. running claude code, running formatters and linters and test suites, managing incremental work with git etc. Are all vital in the modern way we write code. I don't see how you can put a glossy UI on top of that and maintain any fine-grained control. Since we're already giving up a LOT of control by having agents write our code, we need to retain some control and certainty over the quality control and review process of the outputs.

[dead]

[flagged]