App design: discoverability vs efficiency

The Linux community on Mastodon is a vibrant example of what a truly open and inclusive space can be. It’s full of passionate individuals who are not only deeply committed to the values of open-source software but also dedicated to fostering a collaborative environment. People here are open-minded, always ready to engage in thoughtful discussions, and they approach differing opinions with respect and curiosity. Mastodon allows me to interact with very interesting people. I am grateful to have the chance to exchange on regular basis with some of them thrgouh private communications.

Yesterday, I came across one of Ted’s posts saying that “the conventional wisdom says that if you want to sell software the Mac is the best platform because Mac users would be willing to pay a premium for a well-designed application. Linux would be the worst platform because most Linux would rather tolerate a poorly designed free application than pay for a well designed app.” Since I’ve recently wrote about apps design , I engage a conversation with him.

First, I wanted to clarify what Ted meant by “design”. It appears that he was talking about design as in the user interface. Is there a coherent information architecture? Does it behave in a way that complements its platform? Is it pleasant to use? Does it show respect for the users?
Aside from the last point, I think it’s tough to compare these things because every Linux user builds their setup differently, and there’s plenty of alternatives for each app that are also usually quite customizable. There’s most likely a good design for everyone in most Linux apps. It’s definitely easier though to make a standard design when your app runs in a tightly controlled environment, but that comes with a cost: you have to adapt to someone else design which may not be your own definition of a “good” one.
Anyway, this discussion made me think beyond the question asked by Ted and made me realize that I tend to avoid GUI apps in general for a series of reasons.

Minimalist tools scale better

Most modern apps solve the problem of accessibility, not efficiency. Their polished graphical interfaces often slow us down. Don’t get me wrong, they are necessary for a lot fo people, but buttons, menus, and nested settings lock you into a workflow thought by someone else and add up extra clicks, extra steps, extra mental overhead. GUI apps re built for discoverability, not speed. Their workflows hide functionality behind layers of abstraction, limiting automation and forcing users into rigid interaction patterns.

I rely mostly on minimalist-looking apps, not because they’re retro, but because they’re fast, predictable, and endlessly customizable. Simple in appearance apps are also less prone to failure if they are well coded simply because they require less elements to be coded, hence reducting the risk of conflicts or discrepancies.

Minimalist apps shine because they follow the Unix philosophy: do one thing well, accept text as input, output text predictably. This opens the door for interoperability. Tools can talk to each other without custom integrations or plugins. A terminal becomes a programmable workspace where processes cooperate instead of operating in silos.

Build your workflow over time

Most of the tools I use now look simple, almost bare, but they give me a kind of freedom I never found in GUI apps. That’s also one of the main reasons why I’ve left Windows decades ago.
I rely heavily on configuration files and occasional bash scripts to make my tools behave exactly how I want. Over the years, I’ve built small configuration files and lightweight bash scripts to streamline my everyday tasks. For example, I’ve tuned my calendar tool, Khal, so I can add events using more natural language. A few typed words trigger a series of automated actions in the background. It feels smoother than opening the app, navigating three layers of menus, and filling several text boxes just to add a meeting. It sounds tiny, but those little changes accumulate into a workflow that feels like an extension of my thoughts.
By contrast, GUI apps offer only limited control over interface elements or workflows.

One of the biggest advantages of CLI and TUI tools is that they’re surprisingly powerful under the surface. Many can interact with each other automatically. You can pipe the output of one tool into another, chain commands together, or let your system run tasks for you without intervention.
Of course, I have to use some GUI apps as well. I keep them as limited as possible and always go with the ones that meet my needs but that also offer a high level of customization. Some of them can also interact with my CLI tools (e.g. my internet browser and text/code editor), which gives me a reassuring feeling :) Looking at how many GUI apps integrate Vim/Emacs motion commands, I realize I’m not alone in this preference. This also highlights the significant role played by CLI applications.

The downside

There’s a trade-off, of course. Building a highly customized system takes time. Learning how to configure tools, write scripts, and understand how everything communicates doesn’t happen overnight. I’m not trained in computer science, so it took me years of slow, steady tinkering to figure things out. And even today, my coding skills would probably look rudimentary to an expert. But that’s the beauty of minimalist tools, they don’t require mastery, just curiosity and patience.

Why I keep choosing minimalism

In the end, minimalism helps me work faster and think less about the interface and more about the task. My tools adapt to me, not the other way around. Yes, it took effort, but the payoff has been a workflow that feels natural, efficient, and calm.

Even though I’m not working in the computing world, lots of my daily tasks can be done in the terminal, and benefit from this approach. Using the terminal is no longer as dull as it once was. Modern terminals offer numerous features and customization options. The terminal isn’t a way to make you look like a hacker of a 90’s movie. It’s a gateway to understanding the underlying logic of software. With text-based interfaces, the important parts are visible, scriptable, and composable.

I’m not saying GUI apps are not capable. One could be quite productive using them, but that will most likely involved relying less on the user interface (e.g. by using keybindings extensively). Interconnection between GUI apps will also be way more limited than what CLI tools offer.
Even with the time investment, working this way feels more natural to me. Minimalist apps give me a sense of control, calm, and efficiency that GUI-driven tools never offered. If I used to lose control when a GUI app wasn’t functioning as expected, now I can calmly adjust my CLI tools to achieve what I need.