My Problem 🤔
I started programming when the shell wasn’t an option, it was the place. There was no mouse, there were no windows. Just a blinking cursor, waiting for a command. I learned to think in text: input, output, pipe, redirection.
Then came the turn. The industry decided that productivity had the face of a window. Each discipline got its own program, with its own interface and its own learning curve:
- Databases — their app with its panel and its tabs
- Version control — another window, another way of seeing the same thing
- Deployments — another dashboard, another account, other buttons
- Observability — another panel, other charts, another subscription
The shell was relegated to “that thing used by people who know a lot” and to the tasks that graphical interfaces hadn’t yet conquered.
I went with the flow. I kept accumulating apps, dashboards and windows until I stopped visiting the shell. I dusted it off less and less often, until it only showed up when there was no other choice.
The problem arrived when I brought AI into my workflow. Not as a search engine or a snippet generator, but as an agent that acts on my environment. And that agent has no mouse. It doesn’t open windows. It works exactly like I did at the beginning: with text, with commands, with the shell.
The question left floating was uncomfortable: had I spent years learning graphical interfaces to do the same thing I was already doing when I started, but with more steps in between?
My Solution 🧩
The solution wasn’t a break. I didn’t slam windows shut or write an anti-interface manifesto. I just stopped resisting going back to the shell when the work led me there naturally.
The change started by observing. When an agent needs to inspect something, it doesn’t look for a pretty view — it writes a command. When it wants to see logs, it reads them with a pipe. It doesn’t care which app I prefer. It only cares about the result.
My first instinct was to correct it: “Wait, I have a graphical tool for that.” But when I stopped, I understood that I was adding friction where there was none. The agent knew what to run. I knew how to read the output. The interface added nothing — it only added steps: open, connect, navigate, find.
So I started doing the same on my own. Where I used to open a window, now I open a shell:
- Checking a state — a direct command instead of a panel to load
- Transforming data — I chain operations instead of exporting, opening and saving again
- Automating a task — I write it once and reuse it anywhere
- Reproducing a flow — I copy and paste text instead of explaining clicks
Not out of nostalgia, but because it’s faster and more composable.
That was the real mental shift: commands compose in a way graphical interfaces will never match. A window offers me what its designer imagined I would need. The shell gives me what I decide I need.
And there was something that surprised me: the knowledge was still intact. There was no need to study again. There was only need to dust it off.
My Result 🎯
The result hasn’t been a break with graphical interfaces. I still open windows when they offer something text can’t. But the shell has returned to the center of gravity of my workflow, instead of being the last resort.
What changed concretely:
- Speed — a command is almost always faster than navigating to the equivalent option in a GUI
- Composability — I can chain operations that no window contemplates in combination
- Consistency with AI — we speak the same language; there’s no translation between what the agent runs and what I see
- Portability — a command works the same locally, on a server and in CI
But what struck me most was the learning I didn’t have to do. I assumed going back to the shell would demand time and practice. That time had already been invested decades ago: the commands, the pipes, the redirection logic — it was all still there, waiting for an excuse to be used again.
AI didn’t teach me to use the shell. It reminded me that I already knew how.
The cycle that started with a tricycle, went through the rocket of graphical interfaces and returns to the fundamentals isn’t a step backward. It’s a circle that closes better than it opened. Sometimes the future of development isn’t about learning something new, but about rediscovering what we already knew how to do when we started.
Keep coding, keep running 🏃♂️