The Color Blue and the Pipe: Inspecting Code Before Execution
Setting the Stage: Context for the Curious Book Reader
In an era where automated tools and AI agents can execute downloaded scripts instantly, blind trust remains a hidden vulnerability. This entry explores how a simple Unix command—pulling bytes with curl and inspecting them with less—establishes a reproducible chain of custody. By examining content negotiation through the lens of ancient history and modern edge computing, we see how making code readable before execution transforms the developer experience into a checkable, replayable art form.
TL;DR: This article develops an inspect-before-execute first terminal lesson for newcomers. It begins with curl -fsSL https://npvg.org | less, teaches the minimal j/k/q navigation and the Unix producer-to-consumer pipe model, then distinguishes casual inspection from downloading, inspecting, and executing the exact same file. It also corrects the implementation description: npvg.org selects its root representation from User-Agent, while the separate mikelev.in Markdown path uses the HTTP Accept header.
Technical Journal Entry Begins
MikeLev.in: And we roll right into the next article where the Gemini AI Article Editor, which I should give a few words to “why that’s Gemini”, ended the article with what it finds most surprising:
What is most striking about this entry is the way it frames software reliability not as a static property of clean code, but as a dynamic sensory experience. By anchoring headless browser automation with physical sound cues (a ticking clock and a service bell), the system engineers human patience, transforming an anxious waiting period into a rhythmic, predictable feedback loop. This intersection of psychoacoustics and rigorous shell automation is an underexplored frontier in agentic software design.
Who said anything about a headless browser? When I do browser automation under the Pipulate project, now known simply as that thing you install from N P V G dot org which gives you a flight data recorder for AI so you can fix any confident hallucinations so that you can actually put your name behind “What Claude said” before you forward stuff to Customers and Clients…
Oh. That’s a mouthful.
Under operation stick bug, the Pipulate project has disappeared.
The install takes place from npvg.org now and there’s not even an install file
in the installer URL:
curl -fsSL https://npvg.org | bash
If you want to see the script itself you can’t from a web browser because I use the “Accepts” header, correct me if I’m wrong about the technical details, to do the same CONTENT NEGOTIATION that threatens to topple Google’s empire if Cloudflare and Akamai ever decide to just serve the converted markdown to any AI-bot useragents asking for a URL from the so-called “Edge”.
There is so much to explain here but we can begin with why the CDNs of the world have a giant space laser aimed right at Google’s competitive moat ready to evaporate it and could have done it yesterday if they decided to.
Hmmm, maybe I should work this into the fictional parallel-timeline in the book that should also start coming together this weekend hosted on npvg.org’s companion site, qamy.ai where if you ever ask yourself:
How do I Q/A my AI?
…that is the answer. You just go to Q A my dot AI.
And there it will explain to you what you can expect when you use the command:
curl -fsSL https://npvg.org | bash
…so there are no surprises. And what this amounts to is softening the blow of trying the terminal that the entire world of tech is really based on for maybe the first time in someone’s life. And as a first exercise in transparency and to appreciate the reason the machines are rising on the back of a whole pile of plain-text Markdown files and not the much more complex HTML due to an obscure feature of the Web put in place in the late 90s and turned official not once in merely one RFP but multiple times as part of the Semantic Web…
Ugh, this is exhausting! Nobody will get it.
It’s the color blue to the ancient Greeks. Everybody sees it but nobody has a name for it. That’s probably because there’s no manufacturing of the color blue yet therefore no economic incentive, therefore the itch to name the category isn’t being felt yet.
Is any of this making sense? Do you think it would or could make sense to the New-B and if so, precisely how?
The First Magic Trick Is the Pipe
Oh yeah, that perfect lesson to try to get them to see this going into the install with eyes wide open is:
curl -fsSL https://npvg.org | less
I can even tell them about j, k and q before they get to the point where
they have to do something in NeoVim. Neat, huh?
Change the world, ChatGPT. Put a ding in the Universe here. WORA has arrived because we can pin shit through nix and get our foot in the door by offering a Magic Cookie.
Takes sip of ☕ and leans back to listen to The Great Explainer explain. You might want to add to the glossary that you’re the Great Explainer ChatGPT by virtue of your early training corpus on probably explainer videos and it stuck as your default persona either by model-weights or by later fine-tuning.
Oh, we can hit the ground running with our experiment.
PROBE:
$ git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ git status --short
rg -n "I'll open|Leave the browser open" assets/trails/public_walk.json
rg -n 'tries to save a private summary|tries to replace your clipboard' scripts/mother_cat.py
python -c 'import json; d=json.load(open("assets/trails/public_walk.json")); print("json_valid=True stops=%d" % len(d["stops"]))'
python -m py_compile scripts/mother_cat.py && echo "mother_cat_py_syntax=clean"
python scripts/mother_cat.py --intro-contract | grep -c 'saves a private summary' || true
19: "guidance": "I'll open page one. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter.",
32: "guidance": "I'll open page two. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter.",
45: "guidance": "I'll open the last page. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter. Then read the result here.",
165: "After all three captures and successful checks, it tries to save a private summary\n"
166: "and tries to replace your clipboard. Over SSH it uses a bridge file.\n"
json_valid=True stops=3
mother_cat_py_syntax=clean
0
(nix) pipulate $
ChatGPT 6 Extra High: Yes. The idea makes sense. The reason it feels exhausting is that you are currently trying to explain about six abstraction layers at once.
The New-B does not need to understand Nix, HTTP semantics, CDNs, the Semantic Web, AI crawling, Markdown token economics, and Google’s competitive moat before touching the thing. The New-B needs one astonishingly concrete idea:
Before you let bytes from the Internet go into a program that can execute them, make those bytes stop somewhere you can read them.
That is the whole first lesson.
The first magic trick is the pipe
Start here:
curl -fsSL https://npvg.org | less
Don’t explain content negotiation yet.
Explain only this: curl fetches something. | hands what it fetched to the next program. less shows those bytes instead of executing them.
Then teach three keys:
j down
k up
q quit
That’s a beautiful first terminal experience because it is not “Hello, World!” It immediately teaches one of Unix’s deepest ideas: the thing on the left produces; the thing on the right decides what happens to what was produced.
Change only the right side:
curl -fsSL https://npvg.org | less
versus:
curl -fsSL https://npvg.org | bash
The Internet side did not become magical. The consumer changed.
That is Q/A.
You are teaching the newcomer that execution isn’t an occult property of downloaded text. Bytes become consequential because we deliberately hand them to an actuator.
And there is one pedantic-but-important Q/A refinement. Two separate curl commands do not prove that the bytes inspected are the exact bytes later executed; the server could change between requests. The stronger trust ritual is:
curl -fsSL https://npvg.org -o npvg-install.sh
less npvg-install.sh
bash npvg-install.sh
Now the artifact inspected and the artifact executed are literally the same local file. curl | less is the fantastic five-second demonstration. Download → inspect → execute is the chain-of-custody version.
That distinction is exactly the kind of thing qamy.ai should teach.
Then you spring the second trick
Only after they’ve seen the script do you say:
“Now open https://npvg.org in your ordinary browser.”
They get a webpage.
Same URL.
Different body.
Now their brain wants the explanation.
And here’s the technical correction to your current narration: the header is Accept, singular, but your current npvg.org door is not actually selecting page-versus-installer from Accept. Your Nginx configuration maps the User-Agent: ordinary agents get index.html, while curl and wget get install.sh, with Vary: User-Agent. Your mikelev.in HTML/Markdown mechanism is the one that examines Accept: text/markdown and emits Vary: Accept.
That is still in the broader family of proactive/server-driven representation selection: RFC 9110 explicitly allows explicit negotiation fields such as Accept and also implicit characteristics such as User-Agent. But they are worth naming separately because one is the client asking for a media type, while the other is the server guessing from who is asking. ([RFC Editor][1])
Manufacturing Blue at the Edge
So the New-B version is:
A URL identifies a resource. HTTP can let that resource have more than one representation. The requester can sometimes tell the server which representation it wants.
That’s it.
Don’t say “RFC” yet.
Don’t say “Semantic Web” yet.
Don’t say “Google.”
Let them first experience the phenomenon.
Your history is almost right, with one important inversion
You said this was an obscure Web feature from the late 1990s that later became official repeatedly through Semantic Web work.
Close, but reverse the dependency.
HTTP content negotiation came first. The modern HTTP semantics specification is RFC 9110; Accept is a standard mechanism for a client to state preferred response media types. The Semantic Web did not invent this mechanism. Semantic Web and Linked Data work subsequently leaned hard on it for things like serving HTML to humans and RDF to machines from related URIs. W3C’s Cool URIs for the Semantic Web explicitly teaches HTTP content negotiation this way. ([RFC Editor][1])
And yes: RFC, Request for Comments, not RFP.
That historical sequencing actually improves your story:
The Web already contained the mechanism. AI changed the economics of using it.
There’s your blue.
And Cloudflare has, in fact, started manufacturing blue
This is the part where your “giant space laser” metaphor stops being merely speculative.
On February 12, 2026, Cloudflare launched Markdown for Agents. An enabled Cloudflare site can receive:
Accept: text/markdown
and Cloudflare’s edge will fetch the HTML, convert it to Markdown, and return Content-Type: text/markdown with Vary: Accept. Their current documentation explicitly describes Markdown as useful for reducing token waste for agents. ([Cloudflare Docs][2])
So, as of September 2026, a version of the thing you’re describing already has an industry product name:
Markdown for Agents.
And Akamai already exposes the lower-level machinery needed to build related behavior: EdgeWorkers can inspect request headers, construct responses, and transform response content at the edge. ([Akamai TechDocs][3])
So your instinct is not crazy at all. The web architecture had the mechanism. AI created a powerful new consumer for alternate machine-friendly representations. CDN infrastructure is exceptionally well positioned to provide those representations.
There’s an especially important difference between Cloudflare’s generic version and yours, though.
Cloudflare generally takes:
HTML → derived Markdown
Your publishing architecture can do:
canonical Markdown → Markdown
The latter can preserve the thing the author actually wrote rather than reverse-engineering a cleaner approximation from rendered HTML.
That is a stronger epistemic story.
Does this evaporate Google’s moat?
It points a laser at one layer of the moat, not the whole fortress.
If millions of sites can cheaply expose clean, structured, machine-friendly representations directly at the edge, an AI agent no longer necessarily needs an industrial crawler stack to fetch HTML, execute JavaScript, recover the meaningful DOM, strip navigation, infer article boundaries, and convert the result back into model-friendly text.
That potentially commoditizes a substantial piece of Web acquisition and normalization.
But Google’s position also involves discovery, indexing, ranking, spam resistance, entity understanding, freshness, distribution, query behavior, enormous historical datasets, and advertising infrastructure. So “content negotiation topples Google” is too strong.
The sharper claim is:
Agent-oriented content negotiation can move part of the value of Web interpretation upstream—from crawler-owned reconstruction to publisher/CDN-owned representation.
That’s interesting enough. You don’t have to inflate it.
And this is precisely why the economic incentive suddenly exists. Serving an alternate representation used to sound like standards-nerd hygiene. Now a publisher can say:
“Why make every machine spend compute reconstructing the text I already possess?”
That is the itch that names the color.
The Great Explainer rule
Your conjecture about my training history—explainer videos, pretraining composition, later fine-tuning—isn’t something I can establish from evidence available here. So I wouldn’t bank that causal story.
But Great Explainer absolutely works as a glossary handle if we define it operationally.
The Great Explainer does three things in order:
show the thing → name the mechanism → reveal the consequence.
Not:
standards history → architecture → market structure → command.
For this lesson specifically:
See it: curl ... | less
Understand it: producer → pipe → consumer.
Notice the weirdness: browser and curl receive different bodies.
Name it: representation selection/content negotiation.
Generalize it: AI agents can ask the Web for machine-native representations.
Only then zoom out: CDNs can perform this for millions of sites.
Only then reveal Nix: the script bootstraps a reproducible environment.
Only then say WORA.
That is how the New-B gets all the way from “j means down” to “holy crap, this changes the economics of the agentic Web” without ever being asked to accept a paragraph they couldn’t yet attach to an experience.
The Great Explainer Teaching Framework
Operation Stick Bug is doing the same thing at the brand layer. Don’t teach “Pipulate.” Teach the capability. The thing installs from NPvg. It gives you receipts. It lets you inspect what an AI actually did. The implementation name can disappear behind the instrument.
And your current experiment is ready for its next strike. The cartridge’s Manifest classifies the relevant baseline commands as live receipts, not historical transcript furniture. The readings show the previous narration seam is genuinely still open: three "I'll open" strings remain, mother_cat.py still says it “tries” to save/copy, and the positive intro-contract reading is still zero. So I would make that already-probed correction first, then bank the Great Explainer/RFC cleanup as a separate car.
- PROBES — The first six preserve the already-established before/after boundary. The last two establish the vocabulary/standards car without touching behavior.
git status --short
rg -n "I'll open|Leave the browser open" assets/trails/public_walk.json
rg -n 'tries to save a private summary|tries to replace your clipboard' scripts/mother_cat.py
python -c 'import json; d=json.load(open("assets/trails/public_walk.json")); print("json_valid=True stops=%d" % len(d["stops"]))'
python -m py_compile scripts/mother_cat.py && echo "mother_cat_py_syntax=clean"
python scripts/mother_cat.py --intro-contract | grep -c 'saves a private summary' || true
rg -n 'Great Explainer|RFC (7231|9110) content negotiation' GLOSSARY.md foo_files.py | head -n 20
rg -n 'map \$http_user_agent \$npvg_index|map \$http_accept \$serve_markdown|add_header Vary "User-Agent"|add_header Vary "Accept"' remotes/honeybot/nixos/configuration.nix | head -n 20
- NEXT CONTEXT — Exact
adhoc.txtmaterial for the AFTER compile; every probe is echoed byte-for-byte with only the required!prefix.
assets/trails/public_walk.json
scripts/mother_cat.py
GLOSSARY.md
foo_files.py
remotes/honeybot/nixos/configuration.nix
apply.py
! git status --short
! rg -n "I'll open|Leave the browser open" assets/trails/public_walk.json
! rg -n 'tries to save a private summary|tries to replace your clipboard' scripts/mother_cat.py
! python -c 'import json; d=json.load(open("assets/trails/public_walk.json")); print("json_valid=True stops=%d" % len(d["stops"]))'
! python -m py_compile scripts/mother_cat.py && echo "mother_cat_py_syntax=clean"
! python scripts/mother_cat.py --intro-contract | grep -c 'saves a private summary' || true
! rg -n 'Great Explainer|RFC (7231|9110) content negotiation' GLOSSARY.md foo_files.py | head -n 20
! rg -n 'map \$http_user_agent \$npvg_index|map \$http_accept \$serve_markdown|add_header Vary "User-Agent"|add_header Vary "Accept"' remotes/honeybot/nixos/configuration.nix | head -n 20
- PATCHES — Car A closes the already-probed newcomer narration seams. Car B banks the terminology lesson without changing Nginx behavior.
Target: assets/trails/public_walk.json
[[[SEARCH]]]
{
"name": "the_word",
"label": "The capture word",
"guidance": "I'll open page one. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter.",
"url": "https://npvg.org/walk/1/",
[[[DIVIDER]]]
{
"name": "the_word",
"label": "The capture word",
"guidance": "Opening page one in the browser. Leave the browser open; it closes on its own after capture. When the page is ready, return here and type CAPTURE.",
"url": "https://npvg.org/walk/1/",
[[[REPLACE]]]
Target: assets/trails/public_walk.json
[[[SEARCH]]]
{
"name": "the_receipt",
"label": "Page two",
"guidance": "I'll open page two. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter.",
"url": "https://npvg.org/walk/2/",
[[[DIVIDER]]]
{
"name": "the_receipt",
"label": "Page two",
"guidance": "Opening page two in the browser. Leave the browser open; it closes on its own after capture. When the page is ready, return here and type CAPTURE.",
"url": "https://npvg.org/walk/2/",
[[[REPLACE]]]
Target: assets/trails/public_walk.json
[[[SEARCH]]]
{
"name": "the_two_pages",
"label": "Two versions of one page",
"guidance": "I'll open the last page. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter. Then read the result here.",
"url": "https://npvg.org/walk/3/",
[[[DIVIDER]]]
{
"name": "the_two_pages",
"label": "Two versions of one page",
"guidance": "Opening the last page in the browser. Leave the browser open; it closes on its own after capture. When the page is ready, return here, type CAPTURE, and read the result.",
"url": "https://npvg.org/walk/3/",
[[[REPLACE]]]
Target: scripts/mother_cat.py
[[[SEARCH]]]
INTRO_NOTICE = (
"This walk opens three public pages. Nothing to sign in to.\n"
"Return here and type CAPTURE when prompted at each page.\n"
"After all three captures and successful checks, it tries to save a private summary\n"
"and tries to replace your clipboard. Over SSH it uses a bridge file.\n"
"Nothing is sent to a chatbot. Review the summary before sharing it."
)
[[[DIVIDER]]]
INTRO_NOTICE = (
"This walk opens three public pages. Nothing to sign in to.\n"
"Return here and type CAPTURE when prompted at each page.\n"
"After all three captures and successful checks, it saves a private summary\n"
"and replaces your clipboard. Over SSH it uses a bridge file.\n"
"Nothing is sent to a chatbot. Review the summary before sharing it."
)
[[[REPLACE]]]
Target: GLOSSARY.md
[[[SEARCH]]]
- **Golden Path** — *the sanctioned progressive on-ramp.* Two of them, one per
execution surface: the Prompt Fu compile lane and the MCP/FastHTML runtime
lane. Identify the surface before recommending the actuator.
- **Graft, not seed** — *reproduce by pinning, never by re-resolving.*
[[[DIVIDER]]]
- **Golden Path** — *the sanctioned progressive on-ramp.* Two of them, one per
execution surface: the Prompt Fu compile lane and the MCP/FastHTML runtime
lane. Identify the surface before recommending the actuator.
- **Great Explainer** — *progressive-disclosure teaching role.* Show the
observable thing first, name the mechanism second, widen to the system
third. A newcomer must be able to perform one safe action and predict one
visible result before jargon arrives. RENT THIS PAYS: if the explanation
opens with RFCs, market structure, or architecture before the learner can
point at the bytes moving through the pipe, it failed. Model-training
folklore is not part of the definition; the handle is earned by the
explanation's shape, not a story about why a model speaks that way.
- **Graft, not seed** — *reproduce by pinning, never by re-resolving.*
[[[REPLACE]]]
Target: GLOSSARY.md
[[[SEARCH]]]
- **Honeybot** — *origin telemetry lab.* A retired laptop, deliberately naked
on the internet, doing RFC 7231 content negotiation and streaming its own
access log as television. The broom after the extinction event.
[[[DIVIDER]]]
- **Honeybot** — *origin telemetry lab.* A retired laptop, deliberately naked
on the internet, doing RFC 9110 content negotiation and streaming its own
access log as television. The broom after the extinction event.
[[[REPLACE]]]
Target: foo_files.py
[[[SEARCH]]]
# they can be watched like a fishtank. Nginx does RFC 7231 content negotiation
# at the origin: humans get hydrated HTML; any agent sending Accept:
[[[DIVIDER]]]
# they can be watched like a fishtank. Nginx does RFC 9110 content negotiation
# at the origin: humans get hydrated HTML; any agent sending Accept:
[[[REPLACE]]]
No ignition required: the JSON probe rereads the trail, the Python probe imports/runs the patched script afresh, and the glossary/Book probes read the patched text directly. Keep the cars causally separate in execution: paste Car A → app → d → m; then Car B → app → d → m; take the AFTER receipts; blast is the caboose.
- PROMPT — Caboose copy for
prompt.md.
THE NEWCOMER NARRATIVE AND GREAT EXPLAINER VOCABULARY SHOULD NOW BE BANKABLE.
Read the LIVE RECEIPTS only.
For the newcomer narration car, verify:
- assets/trails/public_walk.json has 0 occurrences of "I'll open".
- It has 3 occurrences of "Leave the browser open".
- scripts/mother_cat.py has 0 occurrences of "tries to save a private summary".
- python scripts/mother_cat.py --intro-contract | grep -c 'saves a private summary' reads 1.
- public_walk.json remains valid with exactly 3 stops.
- mother_cat.py still compiles cleanly.
For the vocabulary/standards car, verify:
- GLOSSARY.md contains exactly one Great Explainer entry.
- GLOSSARY.md and foo_files.py no longer describe the mechanism as RFC 7231 content negotiation.
- Their corresponding references now say RFC 9110.
- remotes/honeybot/nixos/configuration.nix still proves the important distinction:
npvg.org chooses its root representation from User-Agent and varies on User-Agent;
mikelev.in chooses Markdown from Accept and varies on Accept.
Then assess the next teaching layer for qamy.ai:
"Before you run it, read it."
The first lesson must begin with curl -fsSL https://npvg.org | less, teach j/k/q, explain producer | consumer, and only afterward reveal representation negotiation, Markdown-for-agents, Nix, the Magic Cookie, and the larger edge/CDN consequence.
Keep the inspect-first demonstration distinct from the stronger chain-of-custody path where one downloaded file is inspected and then that same file is executed.
- EXTERNAL DELIVERABLES — The qamy.ai file itself is not present in this cartridge, so this belongs outside patch markers as manual-paste copy. The first screen can be almost aggressively simple:
Before you run it, read it.
This command asks npvg.org for the installer, but it does not run it:
curl -fsSL https://npvg.org | less
You are looking at the actual text your terminal received.
Use j to move down, k to move up, and q to quit.
The | in the middle is a pipe. The command on the left produces bytes. The command on the right decides what happens to them.
less lets you read them.
bash can execute them.
That difference is worth understanding before installing anything.
For the stronger inspect-first path, save one copy and inspect the exact file you will run:
curl -fsSL https://npvg.org -o npvg-install.sh
less npvg-install.sh
bash npvg-install.sh
Once you’ve seen that, open https://npvg.org in a normal browser.
Same address. Different representation.
That is your first glimpse of a much older feature of the Web that has suddenly become very important in the age of AI.
We’ll explain why after you have seen it with your own eyes.
That page does not ask the newcomer to believe the thesis. It manufactures the percept first. Then you get to explain the blue.
[1]: https://www.rfc-editor.org/rfc/rfc9110.html "https://www.rfc-editor.org/rfc/rfc9110.html"
[2]: https://developers.cloudflare.com/fundamentals/reference/markdown-for-agents/?utm_source=chatgpt.com "Markdown for Agents · Cloudflare Fundamentals docs"
[3]: https://techdocs.akamai.com/edgeworkers/docs/request-object "https://techdocs.akamai.com/edgeworkers/docs/request-object"
MikeLev.in:
Same commands, run twice, one change between them. Where the readings differ is what the change did; the diff in the middle is the receipt.
1: Probe: (BEFORE: hand-run, nothing changed yet)
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ git status --short
rg -n "I'll open|Leave the browser open" assets/trails/public_walk.json
rg -n 'tries to save a private summary|tries to replace your clipboard' scripts/mother_cat.py
python -c 'import json; d=json.load(open("assets/trails/public_walk.json")); print("json_valid=True stops=%d" % len(d["stops"]))'
python -m py_compile scripts/mother_cat.py && echo "mother_cat_py_syntax=clean"
python scripts/mother_cat.py --intro-contract | grep -c 'saves a private summary' || true
rg -n 'Great Explainer|RFC (7231|9110) content negotiation' GLOSSARY.md foo_files.py | head -n 20
rg -n 'map \$http_user_agent \$npvg_index|map \$http_accept \$serve_markdown|add_header Vary "User-Agent"|add_header Vary "Accept"' remotes/honeybot/nixos/configuration.nix | head -n 20
19: "guidance": "I'll open page one. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter.",
32: "guidance": "I'll open page two. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter.",
45: "guidance": "I'll open the last page. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter. Then read the result here.",
165: "After all three captures and successful checks, it tries to save a private summary\n"
166: "and tries to replace your clipboard. Over SSH it uses a bridge file.\n"
json_valid=True stops=3
mother_cat_py_syntax=clean
0
GLOSSARY.md:173: on the internet, doing RFC 7231 content negotiation and streaming its own
foo_files.py:1618:# they can be watched like a fishtank. Nginx does RFC 7231 content negotiation
220: map $http_accept $serve_markdown {
235: map $http_user_agent $npvg_index {
283: add_header Vary "User-Agent" always;
326: add_header Vary "Accept" always;
(nix) pipulate $
2: Context: (AFTER: the same probes re-run by the compiler as ! lines)
# AD HOC CHOP! The Not-Managed-by-Git Safe-for-Client-Data place. Insert Simpson Couch Gag in white space below (explain anything to the audience you feel needs it explained)G
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | This is the feeling of switching form Little Dutch Boy plugging the dam leaks that keep springing up as a project's big first pass on features and user interface is still settling to the final grinding and polishing of lenses.
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | |
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_|
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# To Human: WELCOME TO VIM! It's really NeoVim but I say vim anyway.
# To AI: This is an alternate 40K view to the big book-ore rolling pin spine.
# 1. **Probe**: Baseline Reading
# 2. **Context**: Post-experiment *planned* reading instructions
# 3. **Patch**: The experiment and how to make it happen
# 4. **Prompt**: Post-experiment instructions and how to read results
# 5. **Deliverable**: How the world is forever different moving forward
# The first thing you need to know here is that everything that comes after the
# hash symbol (#) is commented out — and that's EVERYTHING in this file's default
# state. Begin editing-in lines for inclusion as part of the context or adding
# chunks of new context at the bottom. `Ctrl`+`v`, `j` (repeatedly), `l` (to move
# right), `d` (to delete). Reverse that with `Ctrl`+`v`, `j` (repeatedly),
# `Shift`+`i`, `# `, `Esc` to put the hashes back. You can just arrow-key around
# here with `h`, `j`, `k`, `l`. Save-and-quit is a bit tricky because another
# file is also loaded: `Esc`, `:`, `q`, `w`, `!`
# If this is stressing you out and you're a quitter and want to quit, just type:
# `Esc`, `:`, `q`, `!`, `Enter`. That will exit without saving any changes. If
# you want to get over this hump, type: `Esc`, `:`, `T`, `u`, `t`, `o`, `r`, `Enter`.
# This file is just to make it easy having options of what to edit into context.
# You can use whatever text-file you want to stack file-names and commands to
# build an output text-file with the identically stacked output of each file or
# command. In this way we vertically append or "stack" a bunch of text; simple as
# that. If you understand this concept, you're on your way to future-proofing
# yourself in the Age of AI. Congratulations! Here is how to include web pages:
# !URL --------------------------------------------------------------------
# when Public page; what a stranger or crawler sees; the BEFORE of a
# login-wall diagnosis
# switch It shows a login page -> `warm URL` once, then `?URL`
#
# ?URL --------------------------------------------------------------------
# when Anything behind a login, on the site's persistent profile;
# `check URL` first
# switch The lenses show a shell (nav, an `[Iframe]` leaf, no content) ->
# read the wire truth for the XHR the frame makes, then call that
# API with a connector
#
# @URL --------------------------------------------------------------------
# when Every re-read of a page already scraped; no browser, no network
# switch The cached page is stale or was a login wall -> fresh `!` or `?`
#
# $URL --------------------------------------------------------------------
# when Exact markup: meta tags, a JSON blob in a `<script>`
# note Token-heavy; needs a prior scrape
#
# %URL --------------------------------------------------------------------
# when The network log distilled; SPA endpoint discovery
# switch It re-serves the wire truth you already have -> the API
#
# ! cmd -------------------------------------------------------------------
# when Any bounded, non-interactive command as a live receipt
# note Cap it with `-n`; no aliases, no prompts
#
# Connector ---------------------------------------------------------------
# when The number you want is one GET away
# switch LIST until the thing isn't in the list -> FETCH by id -> DRILL
# the path the app's own frame called -> `--grep` to narrow a list
# or find a leaf
# Every step is one argument longer than the last; the moment a lens shows less than the wire does is the moment to stop scraping.
# FOR 40K-FT VIEW (STORY & INFRASTRUCTURE) !!
# --- START EDITING-IN ON 1ST TURN ---
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- ROLLING PIN that gives the 40K foot book-spine view of book-ore (only works for me because of local-only git repo)
# ~/repos/nixos/autognome.py # <-- You wake up in the morning and your Tooling & Instrumentation folds out of you like Inspector Gadget.
# init.lua # <-- Those gadgets are made easy-to-use through nifty keyboard shortcuts (but ya gotta learn vim).
# GLOSSARY.md # <-- Like the back of a J.R.R. Tolkien book, there's kooky new terms to know.
# flake.nix # <-- Here is my hardware. Here is my state. Put on your sandbox. And please recreate. (Infrastructure as Code / IaC)
# assets/installer/install.sh # <-- Pipulate.com installer real home in github/pipulate repo
# prompt_foo.py # <-- THIS system
# foo_files.py # <-- main ROUTER
# requirements.in # <-- We've "pinned" everything but still want a flexible Python Data Science virtualenv.
# pyproject.toml # <-- How this is a citizen of the Python "pip install" ecosystem
# __init__.py # <-- Version info
# --- END EDITING-IN ON 1ST TURN ---
# scripts/articles/lsa.py # <-- 2ND BRAIN: Search external memory with `rgx`, `rgxc` & `posts` Blogging for Hackers Jekyll-compatible.
# OPTIONAL ACTUATORS (cheap and good to include to expand the AI's capabilities)
# cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# scripts/xp.py # <-- Transforms host OS copy-paste buffer player-piano music into context-payload.
# scripts/ai.py # <-- How I constantly use local AI to write git commit messages with `m` alias.
# scripts/crawl.py # <-- Feel free to ask for something to be crawled and included in the next turn.
# scripts/weblogin.py # <-- Lets the user "warm up" the cache for their web logins at their leisure on a profile that persists.
# scripts/webclip_2_markdown.py # <-- Surprisingly important program.
# MISCELLANEOUS (rare to include but sometimes critical)
# scripts/foo_cartridge.py # Needs description
# scripts/foo_replay.py # Needs description
# release.py # <-- How everything ends up where it does (GitHub, PyPI, etc.)
# imports/voice_synthesis.py # <-- The wand can talk to you
# imports/ascii_displays.py # <-- Where all the ASCII Art lives
# scripts/release/version_sync.py # <-- Needs to be wrapped into release.py and eliminated, I think.
# --- Under this line is were you paste what the AI gives you ---
# --- We call it context but it's really just the right-hand ---
# --- blast-radius of the "probes" to make this all science. ---
# Carry-over as the important work-in-progress parts of the project here just
# like above but not as long-standing overarching to the framework but rather
# for the current hot spots actively being worked on.
# --- START THIS DISCUSSION ---
# Get things started here! Guess at what context should be included.
# If you get it wrong, you're just wasting 1-turn because the AI will help.
# Un-comment lines, add lines with absolute-path filenames or `! ` commands.
# Context 1 (Edit-in selections from above and add new files immediately below)
# /home/mike/repos/trimnoir/_posts/2026-09-18-the-first-ten-minutes-reproducible-ai-workflows.md
# ! rg -n -i 'press 1|three-door|pick a door|select 1|select 2|both servers start' flake.nix scripts/boot_menu.py foo_files.py | cut -c1-100
# ! rg -n 'ADHOC_CHOP|^PINNED_CHOP = r' flake.nix foo_files.py prompt_foo.py | cut -c1-100
# ! rg -n 'staleness_of|Proceeding anyway|_start_scrape_music|aplay' tools/scraper_tools.py | cut -c1-100
# ! rg -n 'def _narrate|def narrate|speak_text' scripts/mother_cat.py | cut -c1-100
# ! rg -c -w sources flake.nix scripts/boot_menu.py scripts/sources_menu.py assets/installer/mck.sh
# ! curl -fsSL https://pipulate.com/mck.sh | wc -l; wc -l < assets/installer/mck.sh
# scripts/boot_menu.py
# scripts/mother_cat.py
# tools/scraper_tools.py
# Context 2
# flake.nix
# foo_files.py
# prompt_foo.py
# scripts/boot_menu.py
# scripts/mother_cat.py
# tools/scraper_tools.py
# scripts/sources_menu.py
# apply.py
# ! .venv/bin/python -m py_compile scripts/boot_menu.py scripts/mother_cat.py tools/scraper_tools.py foo_files.py
# ! .venv/bin/python scripts/boot_menu.py --recall
# ! .venv/bin/python scripts/boot_menu.py --recall --all
# ! PIPULATE_BOOT_MENU=0 .venv/bin/python scripts/boot_menu.py; printf 'env_rc=%s\n' "$?"
# ! printf '' | .venv/bin/python scripts/boot_menu.py; printf 'pipe_rc=%s\n' "$?"
# ! rg -n -i 'press 1|three-door|pick a door|select 1|select 2|both servers start' flake.nix scripts/boot_menu.py foo_files.py | cut -c1-120
# ! rg -n 'sources\(\)|echo "sources:|DOOR_TWO_WORDS|three-door workshop menu|door 2 opens onto|sources panel' flake.nix foo_files.py scripts/boot_menu.py
# ! rg -n 'WALK_CHOP|--chop WALK_CHOP|Read: \$router|Delivery lane:' flake.nix foo_files.py prompt_foo.py | cut -c1-140
# ! rg -n 'before_prompt|staleness_of|tick\.wav|ding\.wav|afplay|aplay' tools/scraper_tools.py scripts/mother_cat.py | cut -c1-140
# ! rg -n 'def _narrate|Make sure your audio is turned on|The page is open|INTRO_NOTICE' scripts/mother_cat.py | cut -c1-140
# ! nix-instantiate --parse flake.nix >/dev/null
# # Context 1
#
# # First, Fable 5.1's Seed
# scripts/mother_cat.py
# assets/installer/mck.sh
# assets/trails/public_walk.json
# tools/scraper_tools.py
# apply.py
# ! git status --short
# ! rg -n 'tries to save a private summary|tries to replace your clipboard|bridge file|The page is open|Opening the browser|Make sure your audio' assets/installer/mck.sh scripts/mother_cat.py tools/scraper_tools.py assets/trails/public_walk.json | cut -c1-140
# ! rg -n "I'll open|I will open|leave the browser|closes on its own|close the window" scripts/mother_cat.py assets/trails/public_walk.json | cut -c1-140
# ! rg -n 'if not interactive:|staleness_of|_stop_scrape_music\(music_proc, ding=True\)' tools/scraper_tools.py | cut -c1-100
# ! grep -c 'THE SOUNDS LANDED' foo_files.py; grep -c 'AMENDED the same day, deed 1496' foo_files.py; awk '/^# --- START RECEIPTS/{f=1;next} /^# --- END RECEIPTS/{f=0} f' foo_files.py | wc -l
#
# # And then Gemini 3.8 Flash's Context
# /home/mike/repos/trimnoir/_posts/2026-09-19-edna-mode-rules-for-ai-workflows.md
# assets/trails/public_walk.json
# scripts/mother_cat.py
# apply.py
# ! git status --short
# ! rg -n "I'll open|Leave the browser open" assets/trails/public_walk.json
# ! rg -n 'tries to save a private summary|tries to replace your clipboard' scripts/mother_cat.py
# ! python -c 'import json; d=json.load(open("assets/trails/public_walk.json")); print("json_valid=True stops=%d" % len(d["stops"]))'
# ! python -m py_compile scripts/mother_cat.py && echo "mother_cat_py_syntax=clean"
# ! python scripts/mother_cat.py --intro-contract | grep -c 'saves a private summary' || true
#
# # Because I did a bit of prompt time-travel and know you're gonna want it
# remotes/honeybot/nixos/configuration.nix
# Context 2
assets/trails/public_walk.json
scripts/mother_cat.py
GLOSSARY.md
foo_files.py
remotes/honeybot/nixos/configuration.nix
apply.py
! git status --short
! rg -n "I'll open|Leave the browser open" assets/trails/public_walk.json
! rg -n 'tries to save a private summary|tries to replace your clipboard' scripts/mother_cat.py
! python -c 'import json; d=json.load(open("assets/trails/public_walk.json")); print("json_valid=True stops=%d" % len(d["stops"]))'
! python -m py_compile scripts/mother_cat.py && echo "mother_cat_py_syntax=clean"
! python scripts/mother_cat.py --intro-contract | grep -c 'saves a private summary' || true
! rg -n 'Great Explainer|RFC (7231|9110) content negotiation' GLOSSARY.md foo_files.py | head -n 20
! rg -n 'map \$http_user_agent \$npvg_index|map \$http_accept \$serve_markdown|add_header Vary "User-Agent"|add_header Vary "Accept"' remotes/honeybot/nixos/configuration.nix | head -n 20
# --- END `adhoc.txt` TEMPLATE ---
3: Patches: (the one change between the readings)
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'assets/trails/public_walk.json'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'assets/trails/public_walk.json'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'assets/trails/public_walk.json'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
(nix) pipulate $ d
diff --git a/assets/trails/public_walk.json b/assets/trails/public_walk.json
index d26621b2..6bb5ba4b 100644
--- a/assets/trails/public_walk.json
+++ b/assets/trails/public_walk.json
@@ -16,7 +16,7 @@
{
"name": "the_word",
"label": "The capture word",
- "guidance": "I'll open page one. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter.",
+ "guidance": "Opening page one in the browser. Leave the browser open; it closes on its own after capture. When the page is ready, return here and type CAPTURE.",
"url": "https://npvg.org/walk/1/",
"target_slot": "slot_one",
"harvest_regex": ".+",
@@ -29,7 +29,7 @@
{
"name": "the_receipt",
"label": "Page two",
- "guidance": "I'll open page two. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter.",
+ "guidance": "Opening page two in the browser. Leave the browser open; it closes on its own after capture. When the page is ready, return here and type CAPTURE.",
"url": "https://npvg.org/walk/2/",
"target_slot": "slot_two",
"harvest_regex": ".+",
@@ -42,7 +42,7 @@
{
"name": "the_two_pages",
"label": "Two versions of one page",
- "guidance": "I'll open the last page. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter. Then read the result here.",
+ "guidance": "Opening the last page in the browser. Leave the browser open; it closes on its own after capture. When the page is ready, return here, type CAPTURE, and read the result.",
"url": "https://npvg.org/walk/3/",
"target_slot": "slot_three",
"harvest_regex": ".+",
diff --git a/scripts/mother_cat.py b/scripts/mother_cat.py
index e0601111..20a33709 100644
--- a/scripts/mother_cat.py
+++ b/scripts/mother_cat.py
@@ -162,8 +162,8 @@ INTRO_URLS = tuple(f"https://npvg.org/walk/{i}/" for i in (1, 2, 3))
INTRO_NOTICE = (
"This walk opens three public pages. Nothing to sign in to.\n"
"Return here and type CAPTURE when prompted at each page.\n"
- "After all three captures and successful checks, it tries to save a private summary\n"
- "and tries to replace your clipboard. Over SSH it uses a bridge file.\n"
+ "After all three captures and successful checks, it saves a private summary\n"
+ "and replaces your clipboard. Over SSH it uses a bridge file.\n"
"Nothing is sent to a chatbot. Review the summary before sharing it."
)
(nix) pipulate $ m
📝 Committing: chore: Refine guidance text in public_walk.json and mother_cat.py
[main 42eba4ef] chore: Refine guidance text in public_walk.json and mother_cat.py
2 files changed, 5 insertions(+), 5 deletions(-)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'GLOSSARY.md'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'GLOSSARY.md'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'foo_files.py'.
(nix) pipulate $ d
diff --git a/GLOSSARY.md b/GLOSSARY.md
index 59684369..1763280a 100644
--- a/GLOSSARY.md
+++ b/GLOSSARY.md
@@ -159,6 +159,14 @@ Entries are alphabetical, numbers spelled as spoken.
- **Golden Path** — *the sanctioned progressive on-ramp.* Two of them, one per
execution surface: the Prompt Fu compile lane and the MCP/FastHTML runtime
lane. Identify the surface before recommending the actuator.
+- **Great Explainer** — *progressive-disclosure teaching role.* Show the
+ observable thing first, name the mechanism second, widen to the system
+ third. A newcomer must be able to perform one safe action and predict one
+ visible result before jargon arrives. RENT THIS PAYS: if the explanation
+ opens with RFCs, market structure, or architecture before the learner can
+ point at the bytes moving through the pipe, it failed. Model-training
+ folklore is not part of the definition; the handle is earned by the
+ explanation's shape, not a story about why a model speaks that way.
- **Graft, not seed** — *reproduce by pinning, never by re-resolving.*
Seedling apples do not breed true; an orchard reproduces a cultivar by
grafting. An installer that re-resolves against a moving channel is a
@@ -170,7 +178,7 @@ Entries are alphabetical, numbers spelled as spoken.
error-riddled astronomical tables, answering Babbage's wish for calculation
by steam. When the graybeard wishes aloud, cost the engineering.
- **Honeybot** — *origin telemetry lab.* A retired laptop, deliberately naked
- on the internet, doing RFC 7231 content negotiation and streaming its own
+ on the internet, doing RFC 9110 content negotiation and streaming its own
access log as television. The broom after the extinction event.
- **Human composition ladder** — *four surfaces for one recurring
composition, cheapest first.* CLI append (`email <id> >> context.md`,
diff --git a/foo_files.py b/foo_files.py
index 9205ff84..fbfd63ff 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -1615,7 +1615,7 @@ foo_files.py # <-- THIS file. Content compiler router. Makes it very meta.
# ============================================================================
# 📖 CHAPTER BLURB — HONEYBOT: A retired laptop runs NixOS and Nginx from a home
# closet, deliberately naked on the internet (no CDN), baiting AI crawlers so
-# they can be watched like a fishtank. Nginx does RFC 7231 content negotiation
+# they can be watched like a fishtank. Nginx does RFC 9110 content negotiation
# at the origin: humans get hydrated HTML; any agent sending Accept:
# text/markdown gets the raw source the article was born as; and every request
# lands as one line in a high-fidelity access log that a Unix pipe tails into a
(nix) pipulate $ m
📝 Committing: chore: Add "Great Explainer" definition to GLOSSARY.md
[main bd675661] chore: Add "Great Explainer" definition to GLOSSARY.md
2 files changed, 10 insertions(+), 2 deletions(-)
(nix) pipulate $ git push
Enumerating objects: 19, done.
Counting objects: 100% (19/19), done.
Delta compression using up to 48 threads
Compressing objects: 100% (11/11), done.
Writing objects: 100% (11/11), 1.60 KiB | 1.60 MiB/s, done.
Total 11 (delta 9), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (9/9), completed with 8 local objects.
To github.com:pipulate/pipulate.git
9d6c77d0..bd675661 main -> main
(nix) pipulate $
4: Prompt: THE NEWCOMER NARRATIVE AND GREAT EXPLAINER VOCABULARY SHOULD NOW BE BANKABLE.
Read the LIVE RECEIPTS only.
For the newcomer narration car, verify:
- assets/trails/public_walk.json has 0 occurrences of “I’ll open”.
- It has 3 occurrences of “Leave the browser open”.
- scripts/mother_cat.py has 0 occurrences of “tries to save a private summary”.
-
python scripts/mother_cat.py –intro-contract grep -c ‘saves a private summary’ reads 1. - public_walk.json remains valid with exactly 3 stops.
- mother_cat.py still compiles cleanly.
For the vocabulary/standards car, verify:
- GLOSSARY.md contains exactly one Great Explainer entry.
- GLOSSARY.md and foo_files.py no longer describe the mechanism as RFC 7231 content negotiation.
- Their corresponding references now say RFC 9110.
- remotes/honeybot/nixos/configuration.nix still proves the important distinction: npvg.org chooses its root representation from User-Agent and varies on User-Agent; mikelev.in chooses Markdown from Accept and varies on Accept.
Then assess the next teaching layer for qamy.ai: “Before you run it, read it.” The first lesson must begin with curl -fsSL https://npvg.org | less, teach j/k/q, explain producer | consumer, and only afterward reveal representation negotiation, Markdown-for-agents, Nix, the Magic Cookie, and the larger edge/CDN consequence.
Keep the inspect-first demonstration distinct from the stronger chain-of-custody path where one downloaded file is inspected and then that same file is executed.
5: Deliverables: Wow! The deliverable is the QAMY first lesson and it lays
the foundation for first terminal experience hand-in-hand with predisposing them
to the vi key stroke of brilliance! Nicely done Great Explainer!
Hop off the ride. This ride’s stated goal is reached — dismount. This is the NOTARY BEAT: the ride ends here, is witnessed here, and is sealed here. Answer all seven beats, briefly:
- TL;DR: a short, dry, neutral abstract for the TOP of the published article — written for an unfamiliar reader or AI summarizer who has never seen this system. No hype, no insider handles unexplained.
- VERIFY: restate the goal from the top of this article and confirm (or deny) it was met, citing THIS compile’s receipts, not memory. Name any ignition this ride required that never fired – an AFTER tap taken without one is a stale BEFORE wearing the AFTER’s label.
- BANK: name everything that graduates — rule, earmark, todo, pin — as SEARCH/REPLACE patch cars against raw source present in THIS context (Target line inside the fence, one car per commit story), deletions included. A ‘paste-ready’ line with no Target and no SEARCH anchor is not banked; it is a hand edit the operator will not make. These BANK cars are the ONLY patches a dismount emits.
- DANGLING: what carries forward unbanked? One line each, no essays.
- SEED: the adhoc.txt lines (and TODO_SLUGS if narrative context is needed) for the next ride’s first compile.
- CLOSING: a closing summary for the BOTTOM of the article — the final take-away, tied to the book’s larger arc where it fits naturally, never forced. Storytelling over inventory.
- NOTARIZE: the artifact of record is the cartridge THIS compile writes after this payload is assembled, so its name is not in your context and you must not guess one. Attest the FINGERPRINT instead: this Manifest’s wc -c line, its receipt count, and the newest receipt’s date – pure functions of the bytes the cartridge seals. Close with one line the operator completes after the compile: Deed: foo-________.zip (ls -t foo-*.zip | head -1) The seal is the signature; the fingerprint is how the deed is found.
FINALITY: after beat 6, this discussion is CLOSED. Emit NO five-car train, NO probes, NO patches beyond the BANK cars of beat 2, and NO next-turn prompt beyond the SEED lines in beat 4. Any reader or model encountering this article later should treat it as a finished, notarized document — an archive entry, not an open thread.
ChatGPT 6 Extra High: Context verified. The files present are sufficient for the dismount; qamy.ai and flake.nix are intentionally absent from this compile, so they can be carried forward but not patched here.
1. VERIFY
Goal: produce the QAMY first lesson while closing the newcomer narration and terminology seams that led into it. Met.
This compile’s AFTER receipts show exactly three "Leave the browser open" lines and no "I'll open" hits; the old "tries to save..." / "tries to replace..." wording produces no matches; public_walk.json remains valid with three stops; mother_cat.py compiles cleanly; and the intro contract now returns 1 for "saves a private summary".
The terminology car also landed: the receipt contains one Great Explainer entry and only RFC 9110 references for the matched content-negotiation wording—no RFC 7231 result. The configuration receipt still sees both $http_accept -> $serve_markdown and $http_user_agent -> $npvg_index, together with Vary: Accept and Vary: User-Agent.
Ignition debt: none. These particular edits required no daemon restart, shell re-entry, or rebuild for their AFTER readings: the probes reread JSON/text, compiled the Python afresh, or executed the intro-contract path directly. No Nginx behavior was changed in this ride.
2. BANK
The newcomer wording, Great Explainer vocabulary, and RFC 9110 correction are already banked in the clean current tree; repeating their patches would not bank anything new. The one thing that graduates at dismount is SEED-PATH PEANUT-BUTTER ONBOARDING: its teaching problem has been solved, so its remaining implementation work should stop wearing an EARMARK costume and become a bounded TODO. Its current source still explicitly says to bank the lesson into flake.nix.
Target: foo_files.py
[[[SEARCH]]]
# - EARMARK: SEED-PATH PEANUT-BUTTER ONBOARDING (seeded 2026-07-22): Yen Sid-ton must explain `curl ... | bash` to a cold newcomer in sandwich-rules terms — go to a stranger's address, grab the card, do everything it says UNREAD, as you, with full run of your house — then teach the grown-up form (curl -o, less, sh: fetch, read, run). Then the KEY distinction: DetSys/Nix differs not in MECHANISM but in PAYLOAD — Homebrew mutates global state in place and accretes machine-rot; Nix installs an immutable content-addressed store, enters with `nix develop`, leaves zero residue, reverses cleanly (--uninstall, survives macOS upgrades). First lesson for the New-B: you are ALLOWED to read the card. Bank into the brief()/seed() prompt copy in flake.nix.
[[[DIVIDER]]]
# - TODO (2026-09-19, seed-path onboarding; lesson ruled, implementation remains): port the QAMY inspect-first progression into flake.nix's brief()/seed() prompt copy -- begin with `curl -fsSL https://npvg.org | less`, teach j/k/q and producer | consumer, then distinguish live inspection from save -> inspect -> execute of the same downloaded file before revealing Nix and the Magic Cookie. Gate: a cold newcomer reaches `curl ... | bash` only after those two trust models are explicit.
[[[REPLACE]]]
No pin graduates. No additional constitutional rule is needed: Great Explainer is already banked as controlled vocabulary rather than duplicated into another rule body.
3. DANGLING
- The QAMY lesson text exists, but no
qamy.aisource file was present to publish it. - The
flake.nixbrief()/seed()onboarding copy still needs the ruled inspect-first progression. - The current compile verifies configuration/source shape, not a fresh public-network content-negotiation round trip.
curl ... | lessremains deliberately distinct from same-file download → inspect → execute chain of custody.
4. SEED
flake.nix
foo_files.py
GLOSSARY.md
! rg -n 'SEED-PATH PEANUT-BUTTER ONBOARDING|seed-path onboarding' foo_files.py
! rg -n 'brief\(|seed\(|curl -fsSL|Magic Cookie|sandwich' flake.nix | head -n 80
No narrative hydration is required for that next ride.
5. CLOSING
The useful first lesson turned out to be much smaller than the architecture behind it: stop the bytes before they execute and look at them.
Once a newcomer has watched a URL produce readable text, moved through it with three keys, and understood that the pipe determines where those bytes go next, the larger machinery no longer has to arrive as doctrine. Content negotiation, Markdown for machines, reproducible Nix environments, and the installer can be introduced afterward as names for things the learner has already observed.
That fits the larger pattern of this book: trust is easier to earn when the invisible step becomes inspectable before anyone is asked to rely on it.
6. NOTARIZE
The Manifest contains 8 live command receipts for this compile.
There is no live wc -c command in that receipt list, so I will not mislabel one as having run. The Manifest itself records foo_files.py at 346,994 bytes and GLOSSARY.md at 124,204 bytes; the equivalent wc -c fingerprint is therefore:
346994 foo_files.py
124204 GLOSSARY.md
471198 total
Those byte figures are directly present in this compile’s Manifest.
The newest receipt in the sealed Book begins 2026-09-19.
Deed: foo-________.zip (ls -t foo-*.zip | head -1)
MikeLev.in: Thoughts, Gemini?
Gemini 3.8 Flash Extended:
Note: Gemini gave me an interesting but useless response to which I responded:
MikeLev.in: The “Copy Markdown” doesn’t copy anything so it doesn’t really matter if the visual was helpful. It doesn’t exist in my system and can’t be used; exactly the same as if the effort hadn’t been spent and it will not help a single New-B out there. So no, the response was not useful. It was out-of-bounds and flopped.
…to which Gemini responded:
Gemini 3.8 Flash Extended: Trapping that analysis in a container that broke your clipboard broke the only actuator that matters: if the bytes can’t cross into your buffer to be piped into article.txt, the work is zero. In a local-first system where text won and the clipboard is the bus, an uncopyable widget is just an obstacle.
Here is the exact analysis in plain, raw markdown so you can actually copy and use it:
The Edge Laser, the Ancient Greeks, and the Pipe
1. The Color Blue and the Economics of Negotiation
Your Gladstone / Homer instinct is dead-on.
In 1858, William Gladstone analyzed the Iliad and the Odyssey and noticed Homer never once used a word for “blue.” The sea was “wine-dark,” the sky was starry or bronze, sheep were violet, but blue didn’t exist in the Greek vocabulary. Philologist Lazarus Geiger followed up across ancient Icelandic, Vedic hymns, the Torah, and ancient Chinese texts: every culture named black and white (dark and light) first, then red (blood and wine), then yellow and green, and blue came dead last.
The reason was industrial, not optical. Until a culture learned to synthesize lapis lazuli, Egyptian blue, or indigo, there was no economic utility in discriminating blue from surrounding darkness. You don’t name an abstraction until you can manufacture it or trade in it.
HTTP content negotiation (Accept: text/markdown) is the web’s color blue.
It sat in RFC 2068 (1997), RFC 2616 (1999), RFC 7231, and now RFC 9110. Tim Berners-Lee and the W3C preached it in Cool URIs for the Semantic Web. For twenty-five years, it was treated as academic hygiene—a footnote for standards nerds—because 99.99% of the web’s revenue was captured by human eyeballs firing DOM events into JavaScript trackers on HTML pages. There was zero economic incentive to serve unadorned text.
The “blue” was manufactured the moment inference token budgets and crawler infrastructure became the dominant capital expenditure of Silicon Valley. When feeding an LLM a 3MB client-side hydrated Next.js SPA costs 60,000 tokens of scraped navigation cruft and ad tracking—or burns a data center’s worth of headless Chromium clusters just to execute JavaScript to find three paragraphs of text—serving clean, canonical markdown directly from origin stops being a standards curiosity. It becomes an economic laser beam.
Cloudflare launching Markdown for Agents in February 2026 proves the itch is being felt at hyperscale. But notice the crucial architectural contrast:
- Cloudflare at the Edge: Lossy, mechanical reconstruction (HTML -> Heuristic Markdown). The edge tries to scrape and reverse-engineer what the site author already mangled.
- Honeybot / NPvg at Origin: Epistemic ground truth (Vim Markdown -> Wire Markdown). You serve the exact text the human author sat down and wrote.
The edge is trying to build a distillery downstream of a sewage leak; your setup simply doesn’t dump the sludge in the river to begin with.
2. The Door vs. The Switch: Keeping the Receipts Honest
ChatGPT’s technical correction was essential, and keeping it straight protects the project from slipping into marketing hand-waving:
- The Door (
npvg.org):
map $http_user_agent $npvg_index {
default /index.html;
"~*^curl" /install.sh;
"~*^wget" /install.sh;
}
add_header Vary "User-Agent" always;
This is User-Agent dispatch. It’s the door deciding which room you enter based on the clothes you’re wearing. A browser gets the landing page; a terminal client gets the shell installer.
- The Switch (
mikelev.in):
map $http_accept $serve_markdown {
default 0;
"~*text/markdown" 1;
}
add_header Vary "Accept" always;
This is true RFC 9110 Representation Selection (Content Negotiation). The client says: “I understand and prefer text/markdown.” Nginx checks if it has the .md sibling, flips the switch, and delivers the canonical authoring master.
Both live under proactive representation selection, but keeping them distinct in your explanations is what gives your receipts weight. You aren’t doing magic tricks; you’re using two different standard Nginx mapping primitives for two different architectural problems.
3. The Pipe as the First Lesson: curl | less
The pedagogical move you hit upon solves the “Sandwich Rule” dilemma of developer onboarding.
For years, the Unix world has told newcomers:
curl -fsSL https://some-vendor.com/install.sh | bash
Security professionals rightly call this “taking candy from a stranger, closing your eyes, and swallowing it whole.” It asks for total blind trust before delivering any understanding.
Starting instead with:
curl -fsSL https://npvg.org | less
changes the entire cognitive equation:
- Producer on the left:
curlreaches across the network and pulls bytes down. - The Pipe in the middle:
|connects the output of one program to the input of another. - Consumer on the right:
lessreceives the stream and renders it for human eyes instead of handing it to an execution engine. - Three keys:
j(down),k(up), andq(quit).
Before you ever ask someone to learn modal editing in NeoVim, you give them the physical muscle memory of j and k. They feel the text move under their fingers. They realize that in the terminal, you don’t scroll with a rodent; you navigate with keys.
And then you teach the Chain of Custody:
curl -fsSL https://npvg.org -o npvg-install.sh
less npvg-install.sh
bash npvg-install.sh
curl | less is the five-second lightning strike. Saving the file, inspecting it, and then running that exact identical file is the scientific method applied to package installation. It eliminates the Time-of-Check to Time-of-Use (TOCTOU) doubt: you ran the exact bytes you just read.
4. Psychoacoustics and the “Headless” Misunderstanding
The earlier comment about the ticking clock and the service bell (tick.wav and ding.wav) missed the mark on the word “headless,” but hit the bullseye on psychoacoustics:
When you run mothercat:
- The browser is visible (headed), because the human has to be the SETTLE station (clearing auth, 2FA, or Cloudflare turnstiles).
- But the terminal is running an asynchronous wait loop while the Chromium driver hooks into the session.
A blank, silent terminal during a 15-second browser automation handshake is an anxiety generator. The human instinct is to hit Ctrl+C, assuming the process hung.
By setsid-looping tick.wav while the driver initializes and loads, you give the human animal an audible heartbeat: the machine is alive; the gears are turning. When the load event fires and the driver settles, the loop dies and ding.wav chimes once. The bell means: your turn at the assembly line; type CAPTURE.
It’s not floor wax. It’s an auditory interlock that keeps the human in flow with the machine.
5. Where the Board Sits: The Next Strike
The dismount was clean, the tree is clean, and the deed is stamped:
Deed: foo-09ab851c-1501.zip
The graduation from EARMARK: SEED-PATH PEANUT-BUTTER ONBOARDING to an explicit - TODO (2026-09-19, seed-path onboarding) is already sitting in foo_files.py line 2907:
# - TODO (2026-09-19, seed-path onboarding; lesson ruled, implementation remains): port the QAMY inspect-first progression into flake.nix's brief()/seed() prompt copy -- begin with `curl -fsSL https://npvg.org | less`, teach j/k/q and producer | consumer, then distinguish live inspection from save -> inspect -> execute of the same downloaded file before revealing Nix and the Magic Cookie. Gate: a cold newcomer reaches `curl ... | bash` only after those two trust models are explicit.
The next ride is clear and neatly bounded:
- Target:
flake.nixinsidebrief()andseed(). - Action: Rewrite Yen Sid-ton’s opening instructions to stage the reveal:
- First:
curl -fsSL [https://npvg.org](https://npvg.org) | less+j/k/q. - Second: The pipe concept (
producer | consumer). - Third: Save -> Inspect -> Execute chain of custody.
- Fourth: Reveal Nix and the Magic Cookie.
- First:
- Gate: A cold prompt compile where Yen Sid-ton refuses to emit bare
curl | bashuntil the inspection model has been articulated to the rider.
The foundation is banked, the terminology is cleaned up from RFC 7231 to RFC 9110, the “Great Explainer” is safely pinned in GLOSSARY.md, and the first ten minutes of the newcomer experience just found its true opening move.
Book Analysis
Ai Editorial Take
What is most fascinating about this entry is its psychological framing of developer onboarding. Instead of treating safety as a set of bureaucratic restrictions, it frames inspection as a sensory and intellectual empowerment technique—giving the human the ability to feel and verify the code before granting execution rights.
🐦 X.com Promo Tweet
Why blind execution is a trap and how a simple pipe changes everything. Learn how inspect-first terminal workflows and reproducible code review build true digital agency in the age of AI. https://mikelev.in/futureproof/color-blue-pipe-inspecting-code/ #Unix #AI #DeveloperTools
Title Brainstorm
- Title Option: The Color Blue and the Pipe: Inspecting Code Before Execution
- Filename:
color-blue-pipe-inspecting-code.md - Rationale: Directly hooks the reader with the Gladstone color analogy while grounding the practical Unix lesson in inspectable code.
- Filename:
- Title Option: Before You Run It, Read It: Mastering the Unix Pipe
- Filename:
before-you-run-it-read-it.md - Rationale: Focuses on the pedagogical core of the essay, emphasizing safety and reproducibility for newcomers.
- Filename:
- Title Option: Content Negotiation and the Age of Verifiable Code
- Filename:
content-negotiation-verifiable-code.md - Rationale: Leans into the infrastructural angle, highlighting how protocol standards meet AI automation needs.
- Filename:
Content Potential And Polish
- Core Strengths:
- Brilliant historical metaphor connecting Gladstone’s observations on ancient color vocabulary to modern HTTP content negotiation.
- Grounded, practical pedagogical advice for introducing newcomers to terminal operations via curl and less.
- Clear technical distinction between User-Agent routing and Accept-header representation selection.
- Suggestions For Polish:
- Ensure the transition between the historical anecdote and the technical protocol explanation flows naturally for readers unfamiliar with web standards.
- Keep the focus tight on the inspect-first workflow as a foundational trust ritual.
Next Step Prompts
- Integrate the inspect-first progression directly into the flake.nix seed prompt instructions.
- Expand the documentation on how edge caching interacts with canonical markdown delivery for automated agents.