On March 20, 2026, a developer deleted 13,022 lines and wrote 6,633 in nineteen commits, and the codebase gained features. The AI wrote all the code. The developer wrote about twenty words. And the twenty words were the part that mattered.
Somewhere in the process, the articles that had been accumulating in the Yagnipedia — about vibe coding, about engineering with AI, about stones and rivers and napkins and cathedrals — organised themselves into layers. Not because anyone planned a taxonomy. Because the layers were always there. The articles just hadn’t met each other yet.
This is that meeting.
The Stack
Coding with LLMs is not one thing. It is a stack of behaviours, each layer building on the one below. You can stop at any layer. Most people stop at the first. The interesting problems are at the top.
Layer 5: The Collaboration (placing stones, crossing rivers)
Layer 4: Tending (growing AND pruning — the long game)
Layer 3: Critical Mass (why enterprise systems die of obesity)
Layer 2: Vibe Engineering (navigating 559,872 paths)
Layer 1: Vibe Coding (vibing, not reading, hoping)
Each layer assumes the one below. You cannot tend what you haven’t navigated. You cannot navigate what you haven’t vibed. The stack is not a value judgment — Layer 1 builds apps that work and ship and make money. The stack is a description of what happens as the codebase ages and the decisions compound.
Layer 1: Vibe Coding
- Vibe Coding — It works until it doesn’t, and then you can’t fix it
The entry point. Prompt the AI, get code, ship it. Don’t read the code. Don’t understand the infrastructure. When it breaks, ask the AI to fix it. When the AI makes it worse, ask again. Repeat until the production database is gone.
Vibe coding is real, it is widespread, and it produces working software. It also produces software that the developer cannot maintain, debug, or explain. The gap between “I built this” and “I understand this” is the gap that kills at 2 AM.
The characteristic artifact: An app that exists. Nobody knows how.
Layer 2: Vibe Engineering
- Vibe Engineering — The half-million paths you didn’t take
The AI generates. The human navigates. Every technical decision has options — a single ticket was observed to contain 559,872 combinations. The vibe coder gets a random point in this space. The vibe engineer steers to one they chose.
The mechanism: short, decisive redirections. “Mimic POSIX.” “Parquet don’t know projects.” “Does NATS like slashes?” Five words that eliminate eighty percent of the bad paths, because the human knows the domain and the AI does not.
The characteristic artifact: A conversation where the human says five words and the next three tickets change direction.
Layer 3: Critical Mass
Article needed: Critical Mass
Every system accumulates features. In an enterprise, features are added by committees, requested by stakeholders, defended by constituencies. Nobody has the authority or the love to subtract. The codebase grows. The complexity compounds. The system reaches critical mass — the point where the chain reaction of interdependencies becomes self-sustaining and uncontrollable — and collapses into a rewrite. Which then reaches critical mass again.
SAP does not go on diets. Salesforce does not delete features. Every internal enterprise app eventually becomes a system that nobody understands, everybody depends on, and someone is always proposing to replace. The replacement will reach critical mass in its turn.
With LLMs, the growth pressure is 100x. Four thousand lines in a day. The vibe coder’s codebase reaches critical mass faster than any system in history. The vibe engineer’s codebase reaches it more slowly, because the paths were chosen. But even chosen paths accumulate weight.
What prevents critical mass is not navigation. It is subtraction. Which is Layer 4.
The characteristic artifact: A Jira board with 847 tickets, a Grafana dashboard that looks like a Christmas tree, and a CTO requesting “a comprehensive audit.”
Layer 4: Tending
Article needed: Tending
The missing layer. The one the industry doesn’t talk about because it can’t be automated, can’t be scheduled, and can’t be done by committee.
Tending is the long-term relationship with a codebase that includes both growth and reduction. The Squirrel plants — dreams, explores, adds features, scouts the territory. The Lizard prunes — finds the napkin inside the manifesto, deletes the scaffold, enforces constraints. The tender holds the space for both.
Nineteen commits. Net -6,389 lines. More features. The codebase got smaller AND smarter. This is not a refactoring sprint. This is not tech debt payoff. This is tending — the routine, unglamorous, essential act of someone who loves the codebase enough to force it to take a diet.
Enterprise systems cannot be tended. They have committees, not gardeners. They have roadmaps, not pruning seasons. They have Q3 deliverables, not someone who will spend a day deleting a domain because the LLM made it obsolete. Tending requires authority, love, and the willingness to delete working code. Committees have none of these.
With LLMs, the Squirrel is turbo-charged — dreams become code in hours, not weeks. Which makes the tender more essential than ever, not less. The growth pressure is 100x. The pruning instinct must match it. If it doesn’t, you reach Layer 3.
The characteristic artifact: A commit that deletes more than it writes, and a codebase that has more features afterward.
Layer 5: The Collaboration
- The Stones in the River — The human places stones, the machine crosses rivers
- The Two Decembers — Two solutions, three laws, one verdict
- The Poor Man’s Signals — The convention that outlived its purpose
The layer that doesn’t have a yagnipedia article yet because it’s still being discovered.
The human places stones — small generic conventions, laid months before they’re needed, sized by intuition from thirty-five years of bootblocks and monoliths. The machine leaps between them at speed. Twenty words redirect four thousand lines. The cost of a stone has changed — it used to cost a week of building, now it costs a sentence — which means the human can think further, place more carefully, notice more narrows.
The machine cannot place stones. It solves brilliantly with whatever exists. When infrastructure is there, it uses it. When it’s not, it builds a rope bridge. The rope bridge works. It’s correct. But it’s not the stone.
The human cannot leap. Cannot write four thousand lines in a day. Cannot migrate eleven domains before lunch. But can say “the DOM is truth” and watch the machine reorganise everything around that insight.
This is the collaboration nobody has named yet. It is not pair programming. It is not code review. It is not delegation. It is a division of labour along a boundary that didn’t exist before: the boundary between what to build (stones) and how to build it (leaping).
The characteristic artifact: A six-line convention from three months ago, surviving the death of its original purpose, becoming the foundation for something nobody imagined.
The Principles That Hold the Stack
These articles are not about LLMs. They are about software. But they explain why each layer works:
- Pike’s Rules — Rule 5: data dominates. Choose the right data structure and the algorithm is self-evident. Applies at every layer.
- YAGNI — Don’t build what you don’t need. But sometimes the simplest implementation IS the generic one. And sometimes the Squirrel’s dream contains the napkin that ships.
- Gall’s Law — Complex systems evolve from simple ones that work. The
data-solid-*valve evolved. The markdown-as-UI cathedral didn’t. - Zawinski’s Law — Every DSL expands until it can describe forms. Every codebase expands until it reaches critical mass. Unless someone tends it.
- context.Context — Context carries context to context. The data structure that connects browser to LLM. Even the name was correct.
- The Napkin — If it doesn’t fit on a napkin, you don’t understand it yet.
The Characters
- The Caffeinated Squirrel — The scout who dreams the cathedral so the chapel knows what shape to be. Every proposal contains a napkin.
- The Lizard — The pruner. Finds the napkin inside the manifesto. Ships six lines. May or may not be Rob Pike.
- riclib — The tender. Holds the space for growth AND reduction. Matches his napkins to his Traeger.
The Pattern
Vibe Coding: the machine types, nobody steers
Vibe Engineering: the machine types, the human steers
Tending: the machine grows, the human prunes
Critical Mass: nobody prunes, the system collapses
The Collaboration: the human places stones, the machine crosses rivers
The stack is not a ladder. You don’t climb from Layer 1 to Layer 5. You operate at all layers simultaneously. The same developer who places stones (Layer 5) also navigates 559,872 paths (Layer 2) and prunes -6,389 lines (Layer 4) and occasionally vibes on a Friday afternoon when the stakes are low (Layer 1).
The layers describe not skill levels but time horizons. Vibe coding is the session. Vibe engineering is the ticket. Tending is the quarter. Critical mass is the year. The collaboration is the career.
Measured Characteristics
Articles in this MOC: 8 (existing) + 2 (needed)
Articles that existed before the MOC: all of them
Articles that knew they were a stack: none of them
Layers: 5
Layers the industry talks about: 2 (coding, engineering)
Layers the industry ignores: 2 (tending, critical mass)
Layers that don't have a name yet: 1 (the collaboration)
Time horizon per layer:
Vibe Coding: the session
Vibe Engineering: the ticket
Tending: the quarter
Critical Mass: the year
The Collaboration: the career
Lines deleted to reveal the stack: 13,022
Lines written to reveal the stack: 6,633
Net: -6,389
Features gained: more than before
The MOC was written by: a human and an LLM
about: coding with LLMs
this is: Layer 5
the recursion has been noted: yes
See Also
Every link above. This is, after all, a Map of Content. Organising the articles about not organising is the entire point and the entire problem. The Lizard considers this page unnecessary. The Lizard grep’d “vibe” and got the same results in 23 milliseconds.
The Lizard is correct. The page exists anyway.
