← All posts

Terminal First: An Old Philosophy for a New Computing Era

Why the Unix philosophy still matters in a world of graphical applications, cloud platforms, and AI-assisted engineering.

The interface is not the philosophy

I have spent much of my career moving between programming, integration, security, architecture, and conversations with people who do not need to know how the underlying systems work. Across those roles, one idea has remained remarkably durable: complex work becomes more manageable when its parts are understandable, composable, and under our control.

That is why I remain terminal-first.

Not because a black screen is inherently better than a graphical interface. Not because every task deserves a shell script. And certainly not because modern applications have no place in my workflow. The terminal is simply the most direct expression of a philosophy I inherited from Unix: use small, purposeful components; connect them through clear interfaces; and preserve the ability to inspect and change what happens.

The Unix mindset: compose, observe, and preserve rather than depend on one opaque tool.
The Unix mindset: compose, observe, and preserve rather than depend on one opaque tool.

What Unix got right

Unix emerged in a very different computing environment, yet its ideas continue to scale beyond the machines and constraints that shaped it.

Do one thing well. A component with a clear responsibility is easier to understand, test, replace, and trust. Complexity belongs in the composition of parts, not in unnecessary complexity within every part.

Make programs work together. A tool becomes more valuable when its output can become another tool’s input. Interoperability should be a design property, not an afterthought.

Prefer text as a universal interface where it fits. Text can be read, searched, compared, transformed, versioned, and transmitted. It is not the right representation for everything, but it remains one of the most durable ways to express intent and exchange information.

Make behavior observable. A process that can be inspected is easier to diagnose. A process that can be repeated is easier to improve. Both matter when the work involves systems people depend on.

These principles are bigger than the shell. They apply to APIs, infrastructure, identity systems, software architecture, and even the way we organize our own knowledge.

Why it still works today

Today’s computers have enormous processing power, polished interfaces, and an application for almost every task. Yet abundance has created another kind of friction: context switching, hidden state, incompatible formats, and workflows that are difficult to reproduce.

The Unix mindset offers a counterweight. Instead of asking which application contains a task, I ask what the task actually requires: an input, a transformation, a decision, and an output. Once the work is expressed in those terms, the choice of interface becomes clearer.

On macOS, this does not require abandoning the desktop. Unix foundations coexist with excellent native applications. A terminal can initiate an action, a native application can provide the best surface for reviewing it, and automation can connect the two. The point is not to eliminate interfaces. It is to avoid being confined by them.

Text is an asset, not a nostalgia project

Text has an unusual longevity. A Markdown document can be opened years later without recreating the exact application that produced it. A command can be recorded alongside its result. A configuration can be reviewed as a change rather than remembered as a sequence of clicks.

That durability matters to me as a programmer and security practitioner. If an action changes a system, I want to understand what changed. If a process works, I want to be able to reproduce it. If something fails, I want evidence rather than guesswork.

Text is not automatically safe or correct. Scripts can be destructive, logs can expose secrets, and automation can amplify mistakes. But plain, inspectable artifacts give us a better starting point for review, version control, and controlled execution.

AI changes the speed, not the foundation

AI-assisted coding makes this philosophy more relevant, not less.

A model can help draft a script, explain an unfamiliar command, propose a refactor, or translate a requirement into a working starting point. It can reduce the cost of moving from an idea to an experiment. But generated output still needs a boundary between suggestion and execution.

I want AI to augment judgment, not replace it. A generated command should be understandable before it runs. A code change should be reviewable as a diff. A workflow should be testable and repeatable. Secrets, privileges, and production access still require deliberate controls.

The most useful AI workflow therefore remains grounded in text: describe the intent, inspect the proposed change, run bounded tests, observe the result, and retain the artifacts that matter. This is a modern extension of composability and observability, not a departure from them.

Terminal-first, not terminal-only

I still use graphical applications. Some work is genuinely better with visual context, rich layout, or direct manipulation. But I prefer to keep the control plane of my work close to the keyboard and the underlying artifacts close to open formats.

That is the distinction: terminal-first is a choice about where work begins, how it connects, and how much control we retain. It is not a rule that everything must end in a terminal window.

The Unix philosophy has survived because it is not really about old tools. It is about building systems and habits that remain useful when tools change.

The next article turns that philosophy into five personal principles: Terminal First: Five Principles Behind My Workflow.