On March 20, 2026 — in a single night — the Yagnipedia editors-and-shells section reached critical mass. Twenty-two articles about the tools developers use to type, to command, and to create. From ed (1969, implied) to Claude Code (2025, present). From the VT100’s 4 KB to VS Code’s 1.5 GB. From $ to intent.
The articles organised themselves — as articles do when there are enough of them — into a shape. The shape is an evolutionary tree. The tree has two branches (editors and shells), a root (text), and a canopy (intelligence). The Lizard sits at the root and has not climbed.
“I have read all twenty-two articles. They describe a fifty-year journey from typing commands to describing intent. I could have told you the destination in 1979. The destination was always: stop typing and start thinking. The shells got there last.”
— The Lizard, who has been at the destination since the beginning
The Editor Branch
The editors, in evolutionary order:
1976 vi ─────────────────────────────────────────────────────────┐
│ │ (riclib returns here)
1989 CygnusEd (Amiga) ── extinct, fondly remembered │
│ │
1991 Vim ─── "vi Improved, and Improved, and Improved..." │
│ │
2014 Neovim ── "The Fork That Replaced One Bad Language │
│ With a Language for Children" │
│ │
2015 VS Code ── "The Electron App That Won by Being │
│ Good Enough at Everything" │
│ │
2017 GoLand ── "The IDE That Was Worth Paying For │
│ Until It Wasn't" │
│ │
2022 Zed ── "The Editor That Remembered Software Should Be Fast" │
│ │
└──────────────────────────────────────────────────────────┘
The vi lineage: vi (1976) → Vim (1991) → Neovim (2014) → back to vi. The journey took decades. The destination was where it started. The only thing kept from the journey was the knowledge that the destination was right.
The IDE arc: GoLand (2017) proved that specialised refactoring tools justified a subscription. VS Code (2015) proved that “good enough + free” beats “excellent + annual.” Claude Code (2025) made the refactoring tools available in any editor, killing GoLand’s moat.
The speed arc: CygnusEd (1989) was instant on 7 MHz. Zed (2022) is instant on 4 GHz. The bar hasn’t moved. The hardware has. VS Code forgot that software should be fast. Zed remembered.
The Amiga branch: CygnusEd is the extinct ancestor that was ahead of its time. ARexx ports. Scriptable automation. Inter-process communication. In 1989. On a home computer. For 1000 escudos per slide.
The holy war: vi vs Emacs, ongoing since 1976. vi won. Emacs doesn’t know yet.
| Article | Year | The One-Line Summary |
|---|---|---|
| vi | 1976 | The editor that was already finished |
| Emacs | 1976 | The operating system that happens to edit text |
| CygnusEd | 1989 | ARexx + Deluxe Paint = a year of university |
| sed | 1974 | The Lizard’s favourite — no screen required |
| Vim | 1991 | The plugin language is horrible |
| Neovim | 2014 | Lua feels like it is for kids |
| VS Code | 2015 | The Electron tax is accepted but not forgiven |
| GoLand | 2017 | The refactors were great. Then Claude arrived. |
| Zed | 2022 | Just need backlinks and it replaces everything |
The Shell Branch
The shells, in evolutionary order:
1974 sed ── (the Lizard's favourite, technically an editor)
│
1977 DCL ── "That was a horrible shell" (VAX/VMS)
│
1979 sh ── $ (the standard, the law, the floor)
│
1985 AmigaDOS CLI ── commands on the floppy disk
│ │
│ KingCON ── the console handler that fixed what Commodore forgot
│
1987 cmd ── the cockroach of shells (cannot be killed)
│
1989 Bash ── the default (not a compliment)
│
1990 zsh ── the prompt is why people switch
│
2005 fish ── friendly, interactive, incompatible
│
2006 PowerShell ── technically correct (the worst kind of correct)
│
2019 Nushell ── what if the pipe knew what it was carrying?
│
2022 Warp ── what if the shell could think?
│
2025 Claude Code ── the shell IS the intelligence
The Unix lineage: sh (1979) → Bash (1989) → zsh (1990). Text in, text out. The paradigm unchanged for forty-six years.
The innovation arc: fish (2005) broke POSIX for a better interactive experience. Nushell (2019) broke POSIX for structured data. Claude Code (2025) broke the paradigm entirely — intent in, results out.
The Windows branch: cmd (1987, descended from 1981) cannot be killed. PowerShell (2006) had objects in pipes thirteen years before Nushell but the aesthetics were wrong. Both still exist. Nothing ever dies on Windows.
The Amiga branch: AmigaDOS CLI stored commands on the floppy disk. KingCON added arrow keys and tab completion that should have been default. The Amiga had multitasking CLIs in 1985 while DOS had COMMAND.COM.
The intelligence arc: Warp (2022) added LLM suggestions to the terminal. Claude Code (2025) replaced the terminal with the LLM. The progression: assist → replace.
| Article | Year | The One-Line Summary |
|---|---|---|
| sed | 1974 | Why bother with cursors and screens? |
| DCL | 1977 | A mansion can have a terrible front door |
| sh | 1979 | Dollar sign. Cursor. Everything else is decoration. |
| AmigaDOS CLI | 1985 | If the disk isn’t in the drive, the command doesn’t exist |
| KingCON | late 1980s | Arrow keys should not require a third-party install |
| cmd | 1987 | It’s still here. It will always be here. Nothing kills cmd. |
| Bash | 1989 | The default shell. Not the best shell. The default. |
| zsh | 1990 | oh-my-zsh uses git to update itself |
| fish | 2005 | Friendly. Interactive. Incompatible. |
| PowerShell | 2006 | Get-ChildItem instead of ls. Fourteen characters instead of two. |
| Nushell | 2019 | The pipe knows what it’s carrying |
| Warp | 2022 | The terminal that proved the command line could absorb intelligence |
| Claude Code | 2025 | The final shell is not a shell. It is a conversation. |
The Convergence
The editor branch and the shell branch converge at Claude Code.
Claude Code is not an editor — but it edits files. It is not a shell — but it runs commands. It is not an IDE — but it refactors code. It is not a scripting language — but it executes workflows described in English.
The tools didn’t merge. The tools became implementation details. vi still runs inside Claude Code. sh still runs inside Claude Code. grep and sed and awk still run inside Claude Code. The difference is that the human doesn’t invoke them. The human describes what should happen, and the agent decides which tools to use.
The fifty-year progression:
1974 sed — the human IS the intelligence
1979 sh — the human types commands
1989 Bash — the human types commands with history
1990 zsh — the human types commands with a pretty prompt
2005 fish — the human types fewer commands (autosuggestions)
2019 Nushell — the human types queries instead of commands
2022 Warp — the human asks, the terminal suggests
2025 Claude Code — the human describes intent, the agent executes
The bottleneck was never the shell. The bottleneck was the human typing into the shell. The tools finally noticed.
“sh didn’t die. sh became an implementation detail. The scripts still run. The pipes still flow. The text still streams. But the human is no longer the one typing the commands. The human is the one who knows what should happen. That was always the human’s real job. It just took fifty years for the tools to figure it out.”
— riclib, reviewing twenty-two articles at 8 AM after the tools wrote them overnight
