I hesitate to embrace the essentialism here and admit that these are types of people, or at least that the types are fixed. I also think most people have not had a fair chance to discover that they like CLIs for a number of reasons. And of course, even people who lean one way will have exceptions where for certain tasks or kinds of tasks, they prefer to use the other sort of tool.

That said, I am a CLI person, and I do think that preference has to do with some enduring personal traits.

GUIs are difficult for me because visual scanning is difficult for me, cognitively and physically. I've had extremely poor eyesight since I was a toddler. My vision is currently correctable to about 20/30 at best. Trying to decipher icons, or even just track a mouse cursor, feels like work for me. GUIs can be difficult or impossible to resize, and when they are resizable, resizing often causes layout issues. (Fullscreen magnification comes with a ton of downsides, and until I'm legally blind, I think it won't be worth using for me.) GUIs can also be inflexible with respect to colors and themes, which is likewise a problem for my eyes as I have photophobia (light sensitivity) and colorblindness. Apps choosing their own color pallettes, whether that is relying on colors I struggle to distinguish or not respecting a dark mode configuration, is not only distracting and difficult for me to read, but occasionally mildly physically painful.

Command lines come with a lot of accessibility features for free just because they are text-based environments and colors and sizes are configurable, including in some ways that normal CLI tools can't override. But none of that is really what makes the CLI great to me.

I like that shells are programming languages that you live in, where daily navigation is continuous with automation and programming. When daily computer navigation and programming overlap, as they do with composing Unix pipelines, skills in each area become mutually reinforcing. I also like that CLIs are languages, because languages have a kind of regularity to them which makes them easy to learn piece-by-piece. You learn a good chunk of the grammar, and then just learning individual words is a simple thing you can do to raise your fluency effectively. With GUIs it feels like there's no similar framework, and you can never really check something off your list as 'mastered'. Many GUIs doom you to perpetual rediscovery, which leaves you feeling like a perpetual novice. CLIs tend to be more masterable.

But that's not really what I love most in a UI, either. What I love in a UI is the ability to direct information to myself. CLI tools make it very easy for the user's gaze to drive the flow of information, rather than the other way around. A good Unix-like environment incorporates comprehensive, searchable information right there in the environment itself. When you need to review or learn how to fo something, there's no need for the switch contexts and scan. When you need to find something, you run the search yourself and you know exactly where to expect your answer. And there are great facilities for plugging all this into interactive tools, like fzf, to rapidly filter as you type, too.

You may notice that what I described in the last paragraph is not inherently limited to CLIs. That is part of why I wrote the little aside at the top. Some GUIs do a great job of allowing users to direct information on the screen, providing in-app discovery and documentation, and flexible search. Emacs is the prototypical exemplar in my mind, but here are some other examples:

- Plasma's app window search ('Present Windows') — like old-school Exposé but filters windows as you type, then organizes and enlarges the remaining windows at the center of your screen
- Spotlight search, PowerToys Run, KRunner, Launchy, etc.
- global app menus with search (like in macOS, Plasma, and Unity)
- VSCode's command pallette; Helm, Ivy, Vertico, etc., in Emacs
- dropdown terminals ('hotkey window' in iTerm-speak) and similar ways of summoning app windows
- the history-enriched search in your browser's URL bar
- the vim-like presentation of the next keystroke needed for menu navigation in Microsoft's ribbon menus (if you're already looking at the button you want to hit, you don't need to find the cursor or move one, the information about what key to press comes to the button you're already staring at)
- tooltips and sidebars in your IDE, where information appears in a reliable location or next to your cursor. Also things like jump to definition or jump to documentation

and you can probably think of others.

There are lots of other nice things that are common in CLIs and TUIs, like configurability and portability. But I think what draws me to them is the way they spare me from having to visually scan, which is something that GUIs can also do quite well, if their designers care.