esc
Anthology / Yagnipedia / The Napkin

The Napkin

The Correct Unit of Documentation, Architecture, and Grease Management
Artifact · First observed Antiquity (for grease); 1989 (for programming rules); 2024 (for matching Traeger highlights) · Severity: Foundational

The Napkin is a disposable paper product that serves as the correct unit of documentation for both programming philosophies and barbecue grease, which turn out to be more similar than the software industry is comfortable admitting.

A napkin has exactly the right amount of space. Not enough for a framework. Not enough for a comprehensive guide. Not enough for a 47-slide deck. Exactly enough for the thing that matters, written in the handwriting of someone who understands it well enough to say it once.

“If it doesn’t fit on a napkin, you don’t understand it yet.”
— Attributed to everyone, confirmed by no one, true regardless

The Programming Napkin

Rob Pike wrote five rules of programming in 1989. They fit on a napkin. Five rules, approximately two hundred words, that have been confirmed by every profiler trace, every post-mortem, and every 3 AM debugging session in the history of computing. The industry read them, applauded them, printed them on mugs, and ignored them. See Pike’s Rules.

The napkin was not a limitation. The napkin was the format. The rules fit on a napkin because the rules are simple. If Pike had needed forty-seven slides, the rules would have been wrong — not because brevity equals correctness, but because correct ideas about programming are simple ideas about programming, and simple ideas fit on napkins.

The Lizard’s scrolls are napkins. Short. Compressed. All-caps couplets that say the thing once and leave. The Lizard does not produce 47-slide decks. The Lizard does not produce documentation that requires a table of contents. The Lizard produces napkins.

The Caffeinated Squirrel produces 827-line manifestos at 2 AM. These are napkins that have been over-engineered into dissertations. The information density is the same — a napkin’s worth of insight surrounded by seven hundred lines of enthusiasm. The editing process is finding the napkin inside the manifesto. See The Framework That Wasn’t — The Night the Squirrel’s Manifesto Shipped as Six Lines of HTMX ….

The Architecture Napkin

The most expensive napkin in documented history was drawn in a London boardroom by a consultant in a slightly-too-casual blazer. It contained a single box labeled “Monolith.” The company had forty-seven microservices, a 2.3-second response time, and a Grafana dashboard that looked like a Christmas tree. The monolith had served twelve hundred users at 47 milliseconds.

The consultant drew the box. Drew a small lizard next to it. Said “Gall’s Law.” Left.

Three weeks later, the forty-seven microservices were gone. Response times dropped to 47 milliseconds. The Grafana dashboard turned green. The 47-slide architecture deck was used as kindling. The napkin was photographed and circulated on Slack.

The napkin replaced forty-seven microservices and a 47-slide deck. The napkin was correct. The napkin was always correct. The 47-slide deck was never correct, because if you need forty-seven slides to explain your architecture, your architecture has forty-six problems.

THE LIZARD DOES NOT PRODUCE DECKS
THE LIZARD PRODUCES NAPKINS

A DECK IS A NAPKIN
THAT HAS LOST ITS CONFIDENCE

— The Lizard

The Go Napkin

Pike did not merely write his rules on a napkin. He co-created a programming language that is a napkin.

Go has no operator overloading because operator overloading doesn’t fit on a napkin. Go had no generics for fifteen years because generics don’t fit on a napkin (and when they arrived, they fit on one page, which is the digital napkin). Go’s [context.Context](/wiki/contextcontext) interface has four methods, which fits on a napkin. Go’s entire error handling philosophy is if err != nil, which fits on a napkin and is repeated ten thousand times because the napkin is always the same.

Pike designed context.Context — a key-value bag that carries context through programs. In 2026, it carries context to context: DOM context to HTTP context to Go context to LLM context. Even the name fits on a napkin. See context.Context.

The Culinary Napkin

riclib’s Traeger pellet grill has a paper napkin roll mounted on its side. This is not incidental. This is curated.

The napkins were selected among vendors through a process that the Squirrel would call “obsessive” and the Lizard would call “correct.” The selection criteria:

Robustness. A barbecue napkin must survive grease. Not dabbing-at-the-corner-of-your-mouth grease — brisket grease, pulled pork grease, the fond drippings of a twelve-hour smoke that coat your hands and the cutting board and the tongs and the knife and the surface the knife was resting on. A napkin that disintegrates on contact with rendered fat is not a napkin. It is a suggestion.

Colour. The napkins are deep orange. Not because orange napkins are functionally superior — they are identical in absorbency to white napkins. The napkins are deep orange because the Traeger’s accent colour is deep orange, and riclib selected napkins that match the grill’s highlights.

This is either attention to detail or insanity. In the lifelog universe, the distinction is academic.

The result: a barbecue station where the napkin roll, the Traeger’s control panel highlights, the pellet hopper accent, and the drip tray handle are all the same shade of deep orange. The brisket does not match. The brisket is mahogany. The brisket has its own colour scheme and does not answer to accessories.

“The napkin matches the grill.”
“Why does the napkin match the grill?”
“Because the napkin is always visible and the grill is always visible and things that are always visible should not clash.”
“That’s not a reason.”
“It’s the only reason.”
— riclib, defending a purchase that needed no defence

The Napkin Test

The Napkin Test is the informal litmus test applied to ideas, architectures, APIs, and recipes:

Does it fit on a napkin?

The test is not rigorous. The test does not need to be rigorous. If your idea needs more than a napkin to explain, the idea is not ready — not because napkins are magic, but because the act of compressing an idea to napkin-size is the act of understanding it.

Measured Characteristics

Pike's Rules word count:                      ~200 (fits on a napkin)
Squirrel's manifesto word count:              ~4,000 (does not fit on a napkin)
  Useful content in manifesto:                ~200 words (one napkin)
Architecture slides replaced by one napkin:   47
Microservices replaced by one napkin:         47
  (same number — coincidence or pattern?)

Culinary napkin criteria:
  Robustness (grease survival):               required
  Colour match to Traeger accents:            required
  Vendor selection process:                   exhaustive
  Colour:                                     deep orange
  Defence needed for colour-matching:         none (but provided anyway)

context.Context methods:                      4 (fits on a napkin)
data-solid-* convention steps:                2 (fits on a napkin)
  Step 3:                                     does not exist
Lines deleted when napkin-thinking applied:   -6,389

The Lizard's output format:                   napkins (all-caps, compressed)
The Squirrel's output format:                 dissertations (caffeinated, expansive)
  After editing:                              napkins

See Also

See Also