Unix Philosophy, Named by the Document You Quote

The Unix philosophy is a software-design habit: small programs, plain text interfaces, and composition. McIlroy (M.D.), Pinson (E.N.), and Tague (B.A.) wrote four working rules in the July-August 1978 Bell System Technical Journal. The maxim list sits on pages 1902-1903 of a paper that runs pages 1899-1904.

Ken Thompson designed the original Unix at Bell Labs. The same foreword dates the UNIX story to his work on a cast-off PDP-7 in 1969. Dennis Ritchie, who co-created the system and C, died around 12 October 2011.

1969 dates the system. It does not date the written rules.

Quote the 1978 foreword when you want the working rules. A three-sentence slogan that mentions text streams shows up in a 1994 history, and those words are not in the 1978 list.

Key Takeaways

• The written rules are four sentences from 1978, with a joint byline. The text-stream slogan is a 1994 book. 1969 dates the system.
• Name the document before you quote it: the 1978 foreword, Peter Salus's 1994 book, Mike Gancarz's nine tenets, or Eric Raymond's 17 rules from 2003.
• The practical rule for agents is the fourth: use a program that already does the job, or build a small one you expect to throw out.
• Language models fail the slogan. They are not small, and they are not one-job tools.
• A custom protocol server is the exception (auth, no CLI, a stateful session, or a product that ships that way), not the default wrapper for a tool the model already knows.

What Is the Unix Philosophy?

The habit applies to programs. It is not the operating system, Unix time, or a school of academic philosophy.

A sysadmin still chains small filters. The earliest written formulation is the 1978 foreword. The authors introduce the lines as rules that "have gained currency among the builders and users of the UNIX system." That is a report on practice, not a manifesto Ken Thompson signed in 1969.

The slogan "do one thing and do it well" is McIlroy's sentence inside the Unix section, in the Salus compression below.

Which Document You Are Quoting

Pages that mash these lists into one slogan are why the attribution keeps slipping. Keep the documents apart.

The 1978 paper is volume 57, number 6, manuscript received 17 March 1978. The reprint confirms the initials Pinson (E.N.) and Tague (B.A.), not Pinson (E.W.).

Do not sign the text-stream sentence "Doug McIlroy (1978)." That sentence is not in the foreword, and the byline is not his alone.

Peter H. Salus, A Quarter Century of UNIX (Addison-Wesley, ISBN 0-201-54777-5), carries the three sentences readers now treat as the whole philosophy. The PDF mangles McIlroy's name and uses "that handle":

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

The wording that circulates on the web, including Eric Raymond's chapter, is "to handle." If you quote the book, use "that handle" and cite the PDF.

The PDF text does not show a page number next to the passage.

A TUHS precis of a McIlroy oral history places those three sentences in the Unix room, the morning after Thompson installed pipes.

The precis calls that morning an "orgy of one liners." The same recollection says the ideas were unformed before pipes and came together afterwards.

The Salus book reports his line as "Pipes created it." Treat that as recollection, not as the 1978 foreword.

Mike Gancarz's The UNIX Philosophy (ISBN 1555581234) is a different book. Google Books lists 151 pages. Shop dates and that record disagree on the year, and the title page was not available, so the year is not stated here.

Tenet titles visible in that record include Small is Beautiful, Make Each Program Do One Thing Well, Build a Prototype as Soon as Possible, Avoid Captive User Interfaces, and Make Every Program a Filter. The other titles were not in the visible contents.

Raymond (E.S.) wrote The Art of Unix Programming (Addison-Wesley, ISBN 0-13-142901-9). Wikipedia dates the book 17 September 2003. His revision history dates the text that went to the printers 19 September 2003.

The online text is his synthesis, not Bell Labs canon. Prefer catb.org over a course mirror of the same chapter.

Rule names in that chapter include Modularity, Clarity, Composition, Separation, Simplicity, Parsimony, Transparency, Robustness, Representation, Least Surprise, Silence, Repair, Economy, Generation, Optimization, Diversity, and Extensibility. Read them as his 2003 map, not as a second set of 1978 maxims.

Rob Pike's notes are optimization and data-structure rules for C. A five-rules card collects the same list. Quote them as Pike on C, not as the 1978 maxims.

Why the Unix Philosophy Mattered

Composition got cheap enough to try. Brian Kernighan, in a Book Overflow talk (auto-captions, not a checked transcript, 28:48), puts the order in plain sequence: redirect of standard output and standard input came first, and pipes came later. "Notation changes the way you do things."

"Over 300" UNIX systems were in use in the Bell System. The first system "had only about 5 man-years' work in it" when it began to be used for Bell System projects. Both figures are a 1978 count inside one company.

The same foreword says elaborate computing tasks are composed from loosely coupled small parts, often software tools taken off the shelf. UNIX compilers produce no listings, because printing can be done better by a separate program. That is the 1978 version of a rule you will meet again: do not ask one component to format what another component already prints.

"To many, the UNIX systems embody Schumacher's dictum, 'Small is beautiful.'" The foreword says that.

Gancarz later uses the phrase. He did not coin it, and it is not one of the four maxims. If you use the phrase, you mean the software rule in that sentence, not a separate economics essay.

Pike and Kernighan, in "Program Design in the UNIX Environment" (October 1984, AT&T Bell Laboratories Technical Journal 63(8) part 2), locate the power in programs that are easy to combine, not in internal cleverness.

Their worked contrast is cat. The paper's figure is the 1st Edition manual, dated November 1971, and it shows cat copying input to output. PIP, the file-system command beside it, carried its own language.

How the Unix Philosophy Works: The Four Rules

The working rules are the foreword's four sentences. Nine tenets, or seventeen rules, are a later map.

Make Each Program Do One Thing Well

Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new "features."

The second sentence is the part people drop. u/gordonmessmer in r/linux (May 2026) gives the test that still travels: reuse in a new context is the evidence the tool was cut small enough.

Expect Output to Become the Next Input

Expect the output of every program to become the input to another, as yet unknown, program. Don't clutter output with extraneous information. Avoid stringently columnar or binary input formats. Don't insist on interactive input.

"Text streams" and "universal interface" are not in this paragraph. Those words arrive in the Salus compression.

Maxim (ii) is stricter and duller. Another program you have not met yet will read this output.

Robert Ross on LinkedIn (May 2026) restates the idea as "treat every output as an input." His wording is a compression, not the 1978 sentence.

People used to be the copy-paste step between tools. An agent loop can pass one tool's output into the next call.

Rory McCune on LinkedIn (March 2026) sees new command-line tools aimed at agents, with minimal outputs, because context is the constraint. That is maxim (ii) applied to a window size.

Try Early, and Throw the Clumsy Parts Out

Design and build software, even operating systems, to be tried early, ideally within weeks. Don't hesitate to throw away the clumsy parts and rebuild them.

"Within weeks" is the foreword's clock. You should have something a colleague can run before the design hardens.

Matt Rickard rewrote this maxim on 10 May 2023 as a test you run on a model in days, then discard. That post is a 2023 marker.

Use a Tool, or Build a Small One

Use tools in preference to unskilled help to lighten a programming task, even if you have to detour to build the tools and expect to throw some of them out after you've finished using them.

When a program already counts, sorts, or formats, call the program.

Text, Files, and Pipes

Pipes made the trial cheap. Kernighan's caption, above, keeps the sequence: redirection first, pipes later.

"Everything is a file" is not one of the four maxims. A Stack Exchange question filed 6 April 2026 asks whether the slogan contradicts "do one thing and do it well."

The highest-scored answer there says everything exposes an interface that works as if it were a file, while the tools still do one job. A lower-scored answer calls both slogans guidelines.

A file is not a program. That sentence is a reading of the thread, not a line the thread states.

Plan 9 (Thompson, Pike, Presotto, Winterbottom, late 1980s) speaks the 9P file protocol. It is a successor system, not a fifth rule.

Kernighan names the hole in the same talk, at about 56:30, from auto-captions. JSON arrives. Line boundaries stop meaning what they meant.

"You need something different." He does not name the replacement. A host aside mentions jq. That aside is the host's, not his.

Médéric Hurier on LinkedIn (September 2026) writes that "everything is a file, meaning it can be seamlessly edited by agents." Files can be a substrate an agent edits. That sentence is not maxim (i), and a blob is still not a text file.

How to Use the Unix Philosophy With Agents

These are arguments, not a study. The agent is the operator. The program is the tool.

Scott Hanselman on LinkedIn (December 2025) puts the build order in one post:

"This is not the year of writing an AI agent. This is the year of writing small command line utilities that do a thing really really well and then telling an agent about them."

Karun Japhet, an engineering leader, wrote the matching procedure on 5 March 2026. The page was updated 7 October 2026.

He names Prettier, Ruff, Black, and ESLint. If none exists, build a small deterministic script and let the agent orchestrate.

His line: "don't let AI make decisions it doesn't need to make." He excepts exploratory work, prototyping, and novel problems.

Kobi Kadosh (15 March 2026), a staff software engineer at Checkfront, makes the fourth rule concrete. The agent should not become the log parser. It should notice that find, grep, sort, uniq, and head already solve the job.

A skill then points at a tool the model already knows. jq is a warm prior.

A wrapper with a novel name, a novel schema, and a daemon is a cold start.

What You Do on a Real Task

1. Name the job in one sentence: "Count error lines in this log," not "Understand the incident."
2. If a program already does that job, call the program. Do not ask the model to reimplement grep.
3. If no program exists, write a small one you expect to throw out. A deterministic script beats instructions the model re-reads on every run.
4. Tell the agent the tool exists. Point at --help; specs and evals belong with Prompt engineering.
5. Check the output before the next step treats it as fact. Kelsey Hightower on LinkedIn (9 October 2025) warns that nondeterministic agents fall back to shell scripts; traces and scores belong with LLM observability.
6. Refuse the thorough version. LinuxToaster (March 2026) says AI should be a pipe, not a platform, with no stopping condition; Parsimony, in the 2003 chapter, allows a big program only when nothing else will do.

u/MorroHsu in r/LocalLLaMA (March 2026) describes discovery on his runtime, not in a published eval. With a command-line shape, the agent can run --help and learn what exists. Hand it a Python eval and you either stuff the docs into context or invent a discovery mechanism.

Skills, a Shell, or a Protocol Server

Model Context Protocol is a connection standard, not one of the four 1978 rules. Anthropic announced it on 25 November 2024. On 9 December 2025 Anthropic, Block, and OpenAI donated it to the Agentic AI Foundation, under the Linux Foundation.

After that date, "Anthropic's protocol" overclaims ownership.

Kadosh's exceptions, not a ban: authenticated APIs, systems with no CLI, stateful sessions that are not shell commands, and a product that distributes via the protocol. He calls those real, and a small fraction of the servers he sees. In the common case, use a shell or a skill.

Armin Ronacher argued in June 2025 that, if you use Claude Code, most of those servers could be a shell script.

His July 2025 post says agentic loops work best with codegen, and the protocol is not composable for that job.

Geoffrey Huntley, in June 2025, asked why you would use a GitHub protocol server when the model already knows the CLI. The wink is his jab, not a finding.

Simon Willison wrote in October 2025 that Claude Skills might be a bigger deal than the protocol. That is a post, not a vote.

Adam Swiderski (2 September 2025) writes about composable tools. He names three access methods: STDIO, SSE, and HTTP Stream.

STDIO is a subprocess on stdin and stdout. That is the method that behaves like a pipe.

Pradeep Padala on LinkedIn (March 2026) writes that "stdin/stdout is the original MCP." That is his framing. The announcement date above is the history.

Two Ways the Agent Calls the Tool

One camp keeps many tools and spends the skill on which one, and on what you refuse: Kadosh, Hanselman, and Huntley.

One run(command) tool, with composition inside the call. u/MorroHsu in r/LocalLLaMA (March 2026) writes that a single run(command="...") tool with Unix-style commands outperforms a catalog of typed function calls. The employment line in that post is his account: backend lead at Manus, then a Meta acquisition, then his own runtime.

In a follow-up the same month:

"Many people read "CLI" and assumed I meant "give the LLM a Linux terminal." That's not what I'm saying. CLI is an interface protocol: text command in, text result out."

Most of those commands, he says in a comment, never touch the OS.

They are in-process functions wearing command-line syntax. Agent Patterns describes the same shape in an undated lesson. It is a description, not a named authority.

u/complyue in r/LocalLLaMA (13 March 2026) wants the typed side when the payload is a blob. He leans toward functions with structured arguments, even BSON over JSON.

A Pipe, a Preprint, and a Sandbox

Simon Willison, the Datasette creator, published the exhibit on 18 May 2023.

curl | strip-tags | ttok | llm

That line is the shape, not the published command. The post adds flags, a page URL, and a prompt.

Earlier stages are programs. The model is the filter at the end.

Current docs use llm keys set on the llm site. The 2023 install notes are stale.

The CLI announcement is 4 April 2023.

Yew Jin Lim on 12 November 2025 uses the same shape:

cat README.md | llm "Summarize this file"
git diff --staged | llm "Write a commit message for these changes"

Kornelis Sietsma (11 July 2025) records a colleague asking why Claude Code runs find instead of an IDE semantic model. His answer: small commands are the point.

His about page names no current employer. The story is an anecdote, not a benchmark.

Files as a substrate show up in a preprint. Deepak Babu Piskala, arXiv:2601.11672v1 (16 January 2026), is a single author, with a Seattle dateline, no lab, and no peer review.

The paper labels this the Unix principle: expose diverse resources through a uniform interface, and encapsulate complexity rather than eliminate it.

He quotes Jerry Liu that an agent with a filesystem and about 5-10 tools is "just as general, if not more general," than an agent with 100+ MCP tools. That quotation is not a measurement.

Jerry Liu restates the same line on the LlamaIndex blog, dated 15 January 2026.

A real shell is sometimes the wrong tool. just-bash, from Vercel Labs, is a simulated bash with an in-memory filesystem.

The repository was created on 23 December 2025 and is Apache-2.0. It is a sandbox, not evidence the rules won.

unixphilosophy.com labels four proposals as its own analysis, not as Thompson's or McIlroy's: load context on demand, let CLIs be the interface, make skills discoverable, and distribute as files. The author is unnamed. The page for retrieval pipelines is RAG.

New notes land in the newsletter.

When the Rules Do Not Fit

A five-year-old r/linux thread argues that small tools fit the 1970s and 1980s, and that modern software does not.

The hole is real. The 1978 sentences still stand.

Bastian Rieck (20 August 2026) writes that the analogy "has holes so big you can easily ride a horse through." He also writes that language models are neither small nor do they do one thing.

Kelsey Hightower on LinkedIn (9 October 2025) names the production version of that hole.

A nondeterministic step in the middle of a pipe is not a filter. Filters, given the same input, return the same output. A model does not.

Lauri Palokangas argues for an extra layer of checks before the next agent treats that output as valid.

Kernighan's JSON remark, above, is the data hole.

Daniel Pokusa, in a Devoxx Poland talk (auto-captions, not a checked transcript, 37:01), warns that taking "do one thing" out to a thousand services charges you for networking, disks, and routers.

He does not mention agents. Unbounded decomposition was already expensive before anyone wrapped a model around it. He also treats Raymond's 2003 book as the moment the rules were "established finally."

John D. Cook (byline 25 May 2012) makes the internal objection.

Unix does not follow the slogan. The BSD ls man page, as he cites it, says the relationships between the many options are quite complex. A tool can be celebrated for composition and still ship a surface that fails "one thing."

A May 2026 r/linux thread has no shared definition.

u/gordonmessmer in r/linux holds reuse as the test. Another camp limits the slogan to core utilities, not kernels, Emacs, web servers, or browsers. A third calls text-as-a-universal-interface a bad rule.

"Linux follows these rules" is not a settled fact.

On r/LocalLLaMA, the live builder problem in that March 2026 thread is a growing catalog of typed tools. Incidents MorroHsu describes, not rates: stderr was discarded on a failed install, so the model guessed through package managers; an image read with cat turned into garbage tokens.

In the follow-up he calls sed a trap because the match string must be exact, and models often get it wrong. He treats a container sandbox as a boundary, not as an escape that already happened. Keep a presentation layer in front of binary output, and a human approval step on actions outside the agent's authority.

How This Differs From SOLID, KISS, and Worse Is Better

SOLID, and the single-responsibility idea inside it, is the object-oriented cousin of "one thing." The cousin stops at a class boundary and a reason to change. Maxim (i) stops at a program boundary and a new job. Leave the SOLID tutorial on its own page.

KISS is one sentence. Raymond's one-lesson page boils the 2003 book down toward that sentence.

Read it for the short form. The four 1978 rules are the cut you apply to a tool.

YAGNI says you do not build it yet. It rhymes with maxim (iii) and with LinuxToaster's refusal. It is not another name for the four rules.

"Worse is better" is Richard Gabriel. His dedicated page dates the porch joke to spring 1989 and a Cambridge telling to March 1990. Use 1989 for the idea's origin.

Gabriel argues about which virtues you sacrifice under pressure. The 1978 foreword argues about how programs should be cut so the next program can use them.

Microservices were the previous wave of this analogy. Pokusa's thousand-services bill is the caution from that wave.

"Software composition" now collides with security scanning for third-party libraries.

Pike's notes are a different list, already separated above. A talk that reads them as a continuation of McIlroy is mixing two documents.

Where to Read the Source, and Where to Stop

The working rules are the 1978 PDF, pages 1902-1903. The item record is the scan.

The Wiley record is the volume metadata. It does not replace the PDF for the sentences.

The three-sentence slogan is the Salus PDF. Use "that handle." The PDF shows no page number beside the passage.

Raymond's map is chapter 1.6. Seventeen names, his voice, 2003.

Gancarz is the Google Books record until you have the title page. The year stays unstated.

McIlroy's Dartmouth page still titles him Adjunct Professor, with no end date on the page.

Common Unix Philosophy Mistakes to Avoid

Signing the Slogan "Doug McIlroy (1978)"

The three sentences live in Salus's 1994 book. The 1978 foreword has four different sentences and three authors.

Quote the foreword, or quote the book, and say which.

Calling It the 1969 Rule

1969 is Thompson's system on a leftover PDP-7. The written rules are 1978. A page that calls the slogan "the 1969 rule" has skipped the document.

Folding Pike, or "Everything Is a File," into the Four Rules

Pike's notes are about C. "Everything is a file" is a related slogan about interfaces, and a separate page exists for it.

Hurier's September 2026 line welds the slogan to agents. A file is not a program. An agent editing a file is not maxim (i).

Asking the Model to Do a Program's Job

Kadosh's log parser is the concrete miss. The model decides that grep should run.

The model does not become grep. A catalog of typed wrappers for tools the model already knows spends the window on names and schemas, except where his exceptions apply.

Keeping Every Clumsy Part the Demo Produced

Maxim (iii) is a deletion rule. LinuxToaster's "no stopping condition" is what you get if you skip it. Throw out the tool you wrote for a task that is over.

Japhet's exception still stands for novel work. It does not stand for a log count.