The Unix Philosophy Still Wins

Every few years, someone announces the next big thing that’s going to change how we build software. Visual programming. Low-code platforms. AI-assisted everything.

And yet here we are in 2025, and the tools that actually get work done look remarkably similar to what Ken Thompson and Dennis Ritchie were building at Bell Labs in the 1970s. Small programs. Text streams. Pipes. Composition.

I find that kind of hilarious.

Three sentences, fifty years

Doug McIlroy, the inventor of Unix pipes, put it simply:

Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface.

That’s it. Three sentences. Fifty years of validation.

The philosophy isn’t really about Unix specifically. It’s about small, composable tools connected by simple interfaces. Each piece is easy to understand, easy to test, easy to replace. The complexity comes from composition, not from any single component.

Why it keeps winning

Text is universal. JSON, YAML, CSV, logs, configs—it’s all text. You can inspect it, edit it, pipe it, grep it. Binary protocols are faster, but text is debuggable. When something breaks at 3am, debuggable wins.

Small tools are replaceable. When grep isn’t fast enough, you switch to ripgrep. When find is too clunky, you use fd. The interface stays the same. Your scripts don’t break. Try doing that with a monolithic application.

And simple interfaces are stable. stdin, stdout, stderr, exit codes. That’s the contract. Hasn’t changed in fifty years. Meanwhile, your favorite framework’s API broke three times this year.

The monolith keeps trying

Every generation rediscovers the appeal of the integrated solution. One tool that does everything! No need to learn multiple programs! No need to glue things together!

IDEs that handle editing, compiling, debugging, deployment, and probably coffee soon. Platforms that promise you’ll never need to touch a terminal.

And they’re fine. Until they’re not.

Until you need to do something the designers didn’t anticipate. Until you need to automate a workflow they didn’t build a button for. Until the platform decides to pivot and your entire process breaks.

The Unix approach degrades gracefully. One tool doesn’t work? Swap it out. Workflow needs to change? Rewrite a script. The pieces are independent. What you learn transfers to the next project, the next company, the next decade.

Modern tools that get it

The best modern tools embrace the philosophy even when they don’t run on Unix.

Git is a collection of small tools. git add, git commit, git push—each does one thing. The porcelain commands are just wrappers around plumbing. You can script them, alias them, compose them however you want.

The modern CLI renaissance is explicitly Unix-flavored. ripgrep, fd, bat, jq, fzf—small tools that do one thing, accept text, produce text, and play nicely with pipes.

Even Docker took the idea and applied it to infrastructure. Small, single-purpose containers. Each one does one thing. Sound familiar?

What AI tools get wrong (for now)

Here’s where it gets interesting.

AI coding assistants are impressive. They can generate entire applications in seconds. But they tend toward monoliths. Ask an AI to solve a problem and you’ll often get a single script that does everything. One file. All the logic intertwined.

That’s not how robust systems get built.

The Unix way would be: break it into pieces. Small tool that fetches data. Another that transforms it. Another that validates. Connect them with pipes. Test each piece independently.

Harder to prompt for. But more maintainable. More testable. More composable. The developers who thrive with AI tools will be the ones who know how to take that monolith output and refactor it into pieces.

Still winning

Fifty years from now, we’ll probably still be piping text between small programs. The syntax might change. The tools will get faster. But the philosophy will remain.

Because it’s not really about Unix. It’s about managing complexity in a way humans can actually understand.

Every few years, someone announces the next big thing. And every few years, the Unix philosophy keeps winning.

What’s your favorite small tool that does one thing well? I’m always looking to add to my toolkit.