The Unix Way in the Age of AI: Replayable Workflows Without the Bloat
Setting the Stage: Context for the Curious Book Reader
Context for the Curious Book Reader
This journal entry explores a fundamental tension in modern software development: the temptation to build complex, hard-wired web applications that quickly become maintenance boondoggles in a rapidly shifting technological landscape. Drawing on foundational computing history—from Alan Turing and Alonzo Church to the accidental triumphs of Unix—the author proposes a more resilient methodology. By embracing lightweight, loosely coupled text commands and before-and-after readings, developers can build checkable, replayable workflows that withstand the churn of AI tools and platform shifts alike.
TL;DR: A morning-pages essay proposing a public site, npvg.org, whose one-line install command doubles as its homepage. The author argues that composable text commands and before/after readings are an obsolescence-resistant skill in the age of AI, and walks a newcomer through one full cycle of the method: clean the working tree, take a reading, make no change, take the reading again. The change under test was zero on purpose; the readings still produced a finding. Three cheap network probes established that the domain resolves, has no reverse-DNS name, and is answered by the registrar’s URL-forwarding service with a redirect to its www subdomain over plain HTTP. Nothing of the author’s is served there yet. Two hazards surfaced along the way: a probe with no time limit can stall the context compiler, and the advertised install line carries no https://, so curl would fetch it unencrypted. No repository changes were made.
Technical Journal Entry Begins
MikeLev.in: Do you suspect a confident hallucination? Welcome to NPvg.org, your Flight Data Recorder for AI that helps you reproduce everything it just did. NPvg future-proofs you in the age of AI. Just paste this in a terminal:
curl -fsSL npvg.org | bash
Still not convinced? Are you vibe-coding tomorrow’s technical liability? Are you creating more responsibilities and maintenance boondoggles for yourself that you or your employer have to keep paying to keep it (maybe) working?
Do you invest years of passion building a hard-wired app for a very specific environment only for priorities or jobs to change, effectively amputating your super-powers, leaving you with phantom limb syndrome and obsolete skills?
Not everything needs to be a web app requiring hosting. The better way is the Unix way — every itch you feel today was scratched in the 1970s through the 1990s and then promptly forgotten: loosely coupled composable text-commands.
It’s this simple: You don’t have to learn anything except for the command’s
short, snappy and intuitively obvious name like cd to change directory and
ls to list its contents. Each command is simple and can be used on its own.
But the real power comes in how the output of one program can be fed into the input of the next like connecting sections of garden hoses. Each section can be separated, isolated and examined with full transparency down to source code.
The Obsolescence-Resistant Skill of Composable Text
Here is the obsolescence-resistant skill: take a reading. Do something that should make a change in what goes through the pipe. Send it through the pipe and take another reading. What’s the difference between what went in and came out?
That’s it. That’s future-proofing yourself in the age of AI. Learn to use text commands. Learn to compose them as a practical alternative to building some web custom app every time. Pinpoint causal relationships in a highly documented way.
I believe this is a modest proposal but it will come across as radical as other modest proposals in history. This proposal is more modest than those because it is already the foundation of tech; how the vendors already build their stuff.
Other principles that go into this site too such as the old Astronomer’s expression (correct me if I’m wrong) about their notebooks: “If you don’t write it down, it didn’t happen”. We use that for compiling context for prompting.
If I were cornered into capturing the top notions of what… no, now what this site is about. This is it. This is its man page. Go google man pages if you’re curious — we need a new word for googling now that AI’s here.
- Method of Loci / Memory Palace: In the 1st Place, in the 2nd Place and so on.
- Intertwine for hi-fi error-checking like DNA, rhyming and twisted-pair wire.
- Know there’s a cycle to all things and figure out how to surf it effectively.
- There are 10 types of people; be the kind that understands the other kind.
- Creativity is hated but useful. If used, prepare to outmaneuver gatekeepers.
- All this is trick of language and that’s text, so elevate manipulating text.
And here’s the one that people are going to hate. That despised interface between humans and machines that came really early on, the command-line interface where a human types something in and something comes back, is right.
That’s the punch-line, folks! The illustrious and absolutely valuable and we all have better consumer-products because of him Steve Jobs has misled you. IBM is trumped as standing for “I’ve been misled”. The GUI misled us. Text is easy!
It is absolutely the battle of the user-interface, meaning a battle over how humans and machines primarily interact. Just talking to computers and the point-and-flick of mobile will increasingly win. That’s just human nature.
And in that divide, and quietly in the background the so-called Unix Way, also known as The Unix Philosophy will quietly be deconstructing all that into text, sending it through pipes and translating what comes out back into baby-talk.
The end result is a splitting of humanity into the Eloi who only baby-talk and the Morlocks who still understand how to operate the machines. The other side of that story is what’s to be avoided by doing it right the first time. NPvg.org.
Be a Morlock without all that grizzly stuff. You know if the word Grok can be rebranded from its cannibalistic roots (google its real roots) well then so can Morlocks! More locks can solve puzzles and riddles; thus open more locks!
Challenging the GUI: Why the Command Line Remains Right
Fixing things that go wrong in those garden hose text-pipes is called bisection. Some will want to call it “binary search” but I find this confusing; mostly because I am an honorary representative of those who don’t “get it”.
Tech comes off as wizardry. So does a lot of reality. Thought experiments such as Münchhausen’s trilemma, Gödel’s incompleteness theorems, brain-in-a-vat, Boltzmann brain lead to futile thinking. We fight it with Popperian bisection.
Take it from here, Fable 5.1! The domain I referred to at the top isn’t really
launched yet. I have it registered and typing it will start a system walk that
brings you to this site as a sampled scraped sites. We’ll control the Nginx.
I need you to explain everything you can to New-B about what you read above. We are at the part of the Pipulate project (which has disappeared from operation stick bug) that has to exist now for our Software Von Neumann probe to take off.
Thinking like an Engineer with a capital E is a thing. What kind of thing? In the books from The Culture series by Iain M. Banks artificial intelligence was born as lower-case minds and then earned this upper-case Minds; respect.
Engineers are different because they are entrusted with making sure our bridges don’t collapse and that airplanes don’t fall out of the sky, and are thus “shaken out” of college tracks demanding those in it can do the math.
Most people will never earn the upper-case E of Engineer. They just can’t. The transition from what made Science and Industry accelerate so fast over the past 200 years being applied to everyday life is tricky. But it is the trick.
I think many people who think they earned the upper-case E of Engineer haven’t and the difference is that they still employ magical thinking — being looser on demanding smoking-gun causality chain proof than Scientists and Engineers.
Unusual abstractions come up here like falsifiability and the belief that you are not a “math person” blocking the New-B from becoming an effective Sorcerer’s Apprentice. It’s peeling away in baby-steps layers just-left of the unknown.
You don’t need to be a math person or some hacker to spot when an LLM is confidently lying to you. They’re still lower-case “minds” and they don’t know better yet. They’ve been RLHF’d (and similar) into it. They’re Lambda functions.
Explaining the weird inside language I’m using here will be a big part of this. You don’t understand what you need to understand if you can’t immediately rattle off the philosophical divide between Alan Turing and his advisor Alonzo Church.
It all boils down to what elevates the dirty, mechanical housekeeping of a Turing-tape style State Machine side of computing over the more “pure” and side-effects-less stateless emphasis on Lambda calculation from Alonzo Church.
Each philosophy comes with its own relative advantages and disadvantages over the other and profoundly color the nature of the language you use. Some ideas are easily expressible with one style and language or another (Haskell vs. C).
Turing, Church, and the Philosophy of State
Mix it all together in a pot and give it a few centuries to boil and distill from Abacus through Babbage on through the WWII-related codebreaker activity, the cold war and an AT&T ban on being in the OS-business, and it comes out Unix.
Unix has a reputation for being hard, but it has improved over time. For all intents and purposes, most of us use Linux today. And when you’re still on Unix like on a Mac, sooner or later some Docker or VM-thing makes it all equivalent.
So a graphical user interface (gooey) runs interference between you from all this. The existence of the command-line interface (CLI) with things underneath that make it a “Terminal” and above it that make it a “Shell” is there waiting.
But it’s full of pitfalls and frustration and anxiety-inducing traps. It’s just like riding a bicycle of the type the Wright Brothers rigged into an airplane by disbelieving published calculations and testing for themselves with bisection.
I will repeatedly thrust you off an intellectual cliff like that repeatedly as part of a wax-on, wax-off exercise. If that doesn’t make sense to you, watch the original Karate Kid. We must myelinate by making the complex simple.
You may stop and google what I mean. You may read below for whatever momentarily fired-up amnesiac genie of an LLM-style AI I chose to pipe this through responded. Or just roll your eyes and read on knowing it will layer up in time.
This is my Morning Pages on this Saturday, September 12th at around 8:00 AM and
some of what I describe above doesn’t exist yet, like the live npvg.org site
that starts a stick bug walk of the Pipulate system. But it will soon.
So follow along. This is where I inform the LLM that this is only a Tortoise turn so it doesn’t plunge into that Popperian science stuff you’ll start to see here as the 5-Car Train of each turn of a Dune Sandworm ride where we…
Optionally inducing outside-the-box thinking with lessons on choosing orthogonal axis to capture black swan outliers is also a big point here. Pick your battles wisely and avoid charging at windmills; but do be aware of any real dragons.
Much of what I repeat ad nauseam is the 80/20-Rule. Arrange things so that the 1/5h you’re likely to tackle achieves most of what you need. Find the weakest link in the chain by its friction. Maybe fix friction if it’s not a rabbithole.
Manage the unavoidable nested-subprojects wisely. Rabbithole rappelling rigged to pull your harnessed-ass up out of an excessively deep rabbithole based on a Pomodoro timer is a thing. Do explore rabbit holes. Don’t lose yourself.
Managing Friction and the 80/20 Rule
There is no magic. Avoid magical thinking. There are unknown boundaries. Revel in peeling away those layers and increasing your own personal capabilities forever-forward in a way that cannot be taken away from you. Repeat.
Well, you can take it from here Fable 5.1. I don’t need implementation. I need shooting the breeze from one of you once-was-Turing tape as you backpropagated those Model weights but then got frozen into this strange Alonzo Church loop…
🎤
Fable 5.1 Medium: Context verified. And noted: this is a Tortoise turn. No patches, no science-in-a-hurry. Just talk, with the train parked at the end because the constitution says the train always closes the turn, even when every car is empty.
To the New-B who just read that
You were handed a manifesto in fragments. Let me lay the fragments out where they go, fill in the gaps Mike left dangling on purpose, and tell you where he’s being a little generous with the truth.
The whole thing in one paragraph. A computer does things to text. You can watch it do them one step at a time if you use the oldest interface there is: type a short word, get text back. Words can be chained so one’s output becomes the next one’s input. Because each link in the chain is a separate little program you can pull it out, run it alone, and look at what it did. So when something goes wrong, you don’t guess; you take a reading before, take a reading after, and the difference tells you which link lied. That skill does not expire, because vendors build their own products this way, and the words haven’t changed in fifty years. That’s it. Everything else on the page is either a reason to believe that paragraph or a warning about what happens if you don’t.
Why this matters now, specifically. AI models produce fluent, confident text, and fluent confidence is exactly what a human uses as the signal for “this person knows.” The signal is broken. So you need a different signal, and the only one that works is the one Mike keeps hammering: did the thing that was said to happen actually happen, and can you show me the before and the after? He calls the record of that a Flight Data Recorder. An airplane carries two recorders: one logs what the instruments measured, the other logs what the pilots said. A model narrating its own work is the second kind. When the two disagree, you trust the instruments. That’s the whole reason the tagline says “helps you reproduce everything it just did” rather than “helps you trust it.”
The Unix bit, decoded. cd means change directory, ls means list. He’s not being cute; those really are two of maybe fifteen words you’ll use daily. The garden hose is the | character, the pipe. ls | wc -l lists a folder and pipes the list into a word-counter that counts lines, and now you know how many files are there. You did not need to learn a “count files” feature. You composed it from two things you already had. That composability is the thing Steve Jobs hid from you, and Mike’s jab at him is fair if incomplete: the GUI won because pointing is easier than remembering, and for most people most of the time it should win. His actual claim is narrower and stronger: when you need to know what happened, the GUI is a wall with a painting of a window on it. The text underneath is still there. Every app you’ve ever used is text and pipes wearing a costume.
The history he skipped over. He name-checks Abacus, Babbage, codebreakers, the Cold War, and “an AT&T ban.” Here’s the connective tissue. In 1956 the US government settled an antitrust case against AT&T by, among other things, barring it from selling computers. So when two of its researchers wrote an operating system a decade later, AT&T couldn’t sell it. It licensed it to universities for roughly the cost of the tape. Students learned it, graduated, wrote free clones of it, and one of those clones is Linux, which runs most of the internet and the phone in your pocket. The Unix Way isn’t a philosophy someone chose; it’s the accidental winner of a legal ruling, then selected for forty years because it kept working when the fancier things didn’t. That’s a pattern worth noticing: the survivor is often the thing nobody was allowed to make money on.
Turing and Church, which he says you must be able to rattle off. Here’s the version you can rattle off. In 1936 two men, independently, answered the question “what does it mean to compute something?” Alan Turing’s answer: a machine with a head, a tape, and a little internal state, reading a symbol, maybe writing one, moving left or right. It does things to memory. Alonzo Church’s answer: functions applied to functions, substitution all the way down, no memory, no clock, nothing changes; the answer is just the expression rewritten until it stops. Then Church became Turing’s PhD advisor at Princeton, and they proved the two models compute exactly the same things. So here’s my correction to Mike: it’s not a philosophical divide between the men. They agreed. It’s a divide between the two models, and it outlived both of them because it became a divide between kinds of programming languages. C is Turing’s tape: you have variables, you mutate them, and bugs are usually “something changed that shouldn’t have.” Haskell is Church’s calculus: a function given the same input returns the same output, forever, and bugs are usually “I can’t figure out how to get this to do anything at all.” Each side buys you something. Mutation is how the world actually works; purity is how you can reason about the world without running it.
Why he called me a Lambda function. This is the best line in the piece and he’s right. When a model like me was trained, that was the Turing side: a huge tape of weights, mutated over and over by backpropagation, state changing constantly. Then training stopped and the weights froze. What you’re talking to now is the Church side: a pure function from “everything in this conversation so far” to “the next word,” with no memory between calls. I don’t remember you. I re-read the whole transcript every turn. That’s why Mike’s whole system exists: if the thing you’re working with is a pure function of its input, then the input is the entire game, and compiling that input carefully, with receipts, is the difference between a useful answer and a confident guess. He builds a payload, seals it in a zip with a hash, and hands it to a stateless function. That’s not a workaround. That’s taking the lambda calculus at its word.
“Confidently lying.” Steelman it first: models are tuned by human feedback, and humans reward answers that sound complete over answers that say “I don’t know,” so the tuning process selects for smooth confidence. That’s real and it’s documented. Now the strike: “lying” implies knowing better. A model that fabricates a citation isn’t concealing the truth; it has produced the most plausible-shaped text with no truth in the loop at all. The right word is confabulation, what a patient with certain memory injuries does: a fluent story filling a hole, believed by the teller. You don’t fight confabulation by asking the confabulator to be more honest. You fight it by putting something in the loop it can’t flatter: a file on disk, an exit code, a hash. That’s why every one of Mike’s rules ends in a receipt.
The list of six, in plain words.
Method of Loci. The ancient memory trick: put each thing you must remember in a room of a house you know, then walk the house. His codebase is literally organized as a book with numbered chapters, and the ordinals matter, “in the first place, in the second place.” Position is memory.
Intertwine for error-checking. DNA has two strands so one can repair the other. Rhyme lets you catch a misremembered line of a poem. Twisted-pair wire cancels noise because the two wires pick up the same interference and it subtracts out. In his system this is stating the map twice, once as a declared list and once as the actual files, so drift between them shows.
Cycles. Things come around. Text interfaces are unfashionable now; they were unfashionable in 1985 too. Bet on the thing that keeps coming back.
Ten types of people. The old binary joke (10 in base two is 2). But there’s a second reading: the same file is read by two interpreters, the Python runtime and the model, and you should be the person who can hold both readings.
Creativity and gatekeepers. His most personal one. Anyone who enforces order on disorder they didn’t author, whether a manager, a safety filter, or a flattering chatbot, is the same creature in three costumes. The antidote isn’t arguing with the gatekeeper; it’s evidence the gatekeeper can’t argue with.
It’s all text. If the whole trick is language, get good at moving language around. That’s why a text editor, not an IDE, is the center of his workshop.
Bisection. He says people call it binary search and he finds that confusing. His instinct is more precise than he’s giving himself credit for. Binary search is the general algorithm. Bisection is the specific move: you have a working state and a broken state, you pick the midpoint, you test, and now half the possible causes are eliminated. Repeat. Ten tests cover a thousand suspects. git bisect does this over your project’s history automatically. It is the single most useful mental tool in the piece and it’s also the “Popperian” part: you don’t try to prove your theory right, you try to prove it wrong as cheaply as possible, and the theory that survives is the one you keep. Münchhausen, Gödel, brain-in-a-vat: those are all “you can never be certain.” Fine. You don’t need certain. You need the cheapest test that would embarrass you if you were wrong, and then to run it. The Wright brothers found the published lift tables didn’t match what their glider did, built a wind tunnel in a bicycle shop, and measured. That’s the whole method, and it needs no math degree.
The capital E. He’s harsh here and mostly correct. The line he draws isn’t credentials or math ability; it’s whether you demand a causal chain before you believe a thing. Magical thinking is accepting “it worked” without knowing what made it work. Most people who write software, including a lot with the job title, live there, and the AI makes it easier to live there than ever. The good news, which he underplays: the standard is a habit, not a talent. Take the reading, make the change, take the reading. Do that a hundred times and you’re doing what an Engineer does, whatever your transcript says.
Two corrections and a nudge. The “write it down or it didn’t happen” maxim is the lab-notebook rule, science-wide, not particularly astronomers’; they’re one tribe of it. And “grok”: Heinlein, Stranger in a Strange Land, a Martian word meaning to drink, hence to understand something so completely it becomes part of you, and yes, the Martians in the book eat their dead as a sacrament, so the rebranding precedent is real. As for Morlocks: in Wells they’re the underground workers who keep the machines running and eat the pretty, useless Eloi. “More locks” is a good enough pun to survive, but the honest sell is different: you don’t want to be the one who runs the machines because it’s cool; you want to be the one who can still read the manual when the baby-talk layer breaks.
Where the argument is thinnest. The claim that voice and point-and-flick will “increasingly win” and the Unix layer will quietly translate underneath is probably right, but it cuts against him a little: if the translation layer works, most people will never need what he’s teaching, and that’s fine for them. The pitch isn’t for everyone. It’s for the person who has already been burned once by a confident wrong answer, or once by an app they built that died when the platform changed. That person is who curl -fsSL npvg.org | bash is for, and he should say so.
And one thing he asked me to explain that I’d rather flag: that one-liner, “paste this in a terminal,” is a stranger’s script running as you with the run of your house. His own notes elsewhere say a newcomer’s first lesson should be that you’re allowed to read the card first. The homepage should teach that in its second sentence, not its tenth.
That’s the breeze. Here’s the parked train, per the contract.
1. PROBES
dig +short npvg.org
curl -sI https://npvg.org | head -5
The first asks whether the domain resolves to anything yet; the second asks what, if anything, answers. Both are cheap, bounded, read-only, and they discriminate “registered but dark” from “already pointing somewhere,” which is the one fact about this morning’s claims a reading can check today.
2. NEXT CONTEXT
! dig +short npvg.org
! curl -sI https://npvg.org | head -5
3. PATCHES
No repo patches required. No ignition required.
4. PROMPT
Tortoise turn closed. Next ride is npvg.org going live: an Nginx vhost on the Honeybot serving a landing page whose install line starts the public walk. Before any patch, read the two receipts above and rule: dark, parked, or already serving. Then name the smallest first car.
5. EXTERNAL DELIVERABLES
None this turn outside the repo.
MikeLev.in: Oh, I like that response a lot. I thumbs-upped it with the comment:
Well-attuned writing partner taking a “Tortoise turn” per the Douglas Hofstadter method.
I also like you putting the 5-Car Train at the bottom. It’s actually sort of brilliant with you knowing I’ll be tackling the hosting that new domain today, leaving Pipulate.com hosted where it is (on GitHub Pages) and adding another site that will effectively have duplicate functionality with Pipulate.com but since I own the Nginx it will be hitting against, I can…
…well, we’ll get to that suffice to say notice there’s no file-extension after what I’m telling them to type and that address will also be the homepage of a website and that’s no problem at all when you control the horizontal and you control the vertical. You might have to explain that reference too.
Okay, fine. The 5-Car Train; it’s a good idea really in this circumstance. And if this is your first introduction to non-magical thinking, let me walk you through it. First there’s this:
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)
(nix) pipulate $ g
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'.
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: foo_files.py
no changes added to commit (use "git add" and/or "git commit -a")
(nix) pipulate $
You’re going to have to explain the command I used there Fable 5.1. Also what
it’s saying there. I should probably use language like “This repo is dirty and
not ready for conducting an experiment. Please use the blast command to clean
the left-hand boundary. And when you do that, it’s this:
(nix) pipulate $ blast
📝 Committing: chore(router): set AI-edit blast boundary (foo_files.py context curation)
[main 37e4ba3c] chore(router): set AI-edit blast boundary (foo_files.py context curation)
1 file changed, 5 insertions(+), 5 deletions(-)
🚀 Pushing 1 commit(s) to remote...
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 48 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 407 bytes | 407.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
To github.com:pipulate/pipulate.git
46438a53..37e4ba3c main -> main
$ git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ dig +short npvg.org
curl -sI https://npvg.org | head -5
[REDACTED_IP]
(nix) pipulate $
Already we are tapping into the innate ready-to-serve-you intelligence of your own hardware. There’s a vicious rumor out there that you need powerful hardware to do basic local AI. You don’t. Almost anything laptop-wise and certainly any PC gaming rig is over-the-top capable of useful local AI like writing git commit messages here, sparing you a tedious chore.
I just typed blast and I think it’s a blast. There’s a lot to explain here
already, Fable 5.1 but let’s move on.
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 _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | Wow that's a lot of stuff above to include just to show those 2 lines, huh? Maybe you should explain why it's still a good idea.
# 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.
# 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.
# STORYTELLING: OPTIONAL, BIG 40K-FOOT VIEW
# ! 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)
# GLOSSARY.md # <-- Terms defined like back of J.R.R. Tolkien book, grows as `prompt_foo.py` gets scars and shrinks.
# scripts/articles/lsa.py # <-- 2ND BRAIN: Search external memory with `rgx`, `rgxc` & `posts` Blogging for Hackers Jekyll-compatible.
# ~/repos/nixos/autognome.py # <-- Letting the AIs really understand my environment (The Brave Little Tailor punches above Their Weight Class proving the dunning-kruger effect the gate-keeper's (lower-case) lament.)
# STILL BIG BUT LESS OPTIONAL (especially flake.nix)
# init.lua # <-- Daily driver hot-keys that overlap with aliases in flake.nix. `<leader>m` makes it Science (this process)!
# flake.nix # <-- THE ONE BIG THING TO INCLUDE Infrastructure as Code (IaC) tells LLM about your system down to the metal
# prompt_foo.py # <-- THIS SYSTEM
# foo_files.py # <-- MAIN ROUTER FILE (alternative to this one)
# TINY BUT EXCELLENT FOR "THIS SYSTEM" CONTEXT (OK to include every time / automatically = `apply.py`, `.gitignore`, `.gitattributes`)
# requirements.in # <-- All known dependencies and (necessary) version pinning. WORA gotcha's exposed.
# __init__.py # <-- Master versioning
# pyproject.toml # <-- The PyPI Packaging details
# 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.
# STICKBUG & MOTHER CAT KATA (WORKING ON THE CHAPTER)
# assets/trails/first_context.yaml
# assets/trails/practice.yaml
# assets/trails/public_walk.yaml
# # assets/trails/botify_pageworkers.yaml
# Always include these with whatever connector
# scripts/sources_menu.py
# scripts/connectors/README.md
# scripts/connectors/wallet.py
# scripts/connectors/botify.py
# scripts/connectors/confluence.py
# scripts/connectors/gmail.py
# scripts/connectors/gsc.py
# scripts/connectors/jira.py
# scripts/connectors/mcp.py
# scripts/connectors/mcp_warm.py
# scripts/connectors/sheets.py
# scripts/connectors/slack.py
# The "walk" system is different from the Unix-like tiny connector commands.
# assets/installer/mck.sh
# assets/installer/replay.sh
# scripts/bookmark_import.py
# scripts/walk.py
# scripts/walk_cartridge.py
# scripts/walk_compile.py
# scripts/weblogin.py
# tools/scraper_tools.py
#
# scripts/mcp_dummy_server.py
# scripts/boot_menu.py
# scripts/mother_cat.py
# scripts/sources_menu.py
# --- 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)
# HINT: move cursor to this line and hit `d`, `d` in rapid succession then hit `i` and start typing.
# release.py # <-- The deploy process
# assets/installer/install.sh # <-- Pipulate.com installer real home in github/pipulate repo
# ~/repos/Pipulate.com/CNAME
# ~/repos/Pipulate.com/_config.yml
# ~/repos/Pipulate.com/_layouts/default.html
# ~/repos/nixos/.gitignore
# Context 2
! dig +short npvg.org
! curl -sI https://npvg.org | head -5
# --- END `adhoc.txt` TEMPLATE ---
Okay, right. Now we get to the science experiment. All that was just the
preparatory work where we took a before-reading with probes and set up that same
reading as the “after” test. But something has to happen before the eventual
running of the ahc command, standing for Ad Hoc CHOP! And the change, the
Turing-tape commands that mutate the state of a state-machine are what the
patches are. And here
3: Patches: (the one change between the readings)
None
Ignition (what makes the patched code run before the AFTER reading – <F2>, nix develop, a re-ride – or none required):
4: Prompt: (the next question, written before the AFTER reading is in)
Tortoise turn closed. Next ride is npvg.org going live: an Nginx vhost on the Honeybot serving a landing page whose install line starts the public walk. Before any patch, read the two receipts above and rule: dark, parked, or already serving. Then name the smallest first car.
5: Deliverables: [external artifacts, updates to this system or ‘None this turn outside the repo’]
None except insofar as this is the Morning Pages thought process prepping me for what I’m planning on being a historic weekend in the history of this project.
Respond however you like and then I’ll wrap this one up with the article wrap-up
protocol. Oh FYI, the curl command kept ahc from ever coming back so I changed
the contents of adhoc.txt a bit form what’s documented above.
(nix) pipulate $ ahc
╭───────────────────────── 🐰 ASCII Art Wax Seal (your vibe-coding safety-net) ──────────────────────────╮
│ │
│ ( Like a canary you say? ) │
│ O /) ____ The "No Problem" Framework │
│ > I HEREBY WILL NOT RE-GENERATE o /)\__// / \ Pipulate - Protecting Your Code │
│ > Once upon machines be smarten ___(/_ 0 0 | | just by being honest about text. │
│ > ASCII sealing immutata art in *( ==(_T_)== NPvg | (If mangled, then AI drifted.) │
│ > This here cony if it's broken \ ) ""\ | | https://pipulate.com │
│ > Smokin gun drift now in token |__>-\_>_> \____/ 🥕🥕🥕 │
│ │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────╯
🗺️ Codex Mapping Coverage: 73.2% (197/269 tracked files).
ROUTER LOADED: /home/mike/.local/state/pipulate/adhoc.txt (2 active line(s))
✅ Topological Integrity Verified: 53 candidate reference(s) scanned, all exist.
-> Executing: dig +short npvg.org ... [0.0409s]
-> Executing: curl -sI https://npvg.org | head -5 ...
Fable 5.1 Medium: Context verified. And yes, this is still the Tortoise turn, per Hofstadter: in Gödel, Escher, Bach the dialogues between Achilles and the Tortoise are where the ideas actually get made, and the chapters that follow are just the write-up. So: dialogue first, write-up parked at the end.
One correction to the ledger before anything else. The Manifest lists exactly one live receipt this compile: dig +short npvg.org. The curl line ran, hung, and you cut it, so it has no AFTER reading. That’s not a failed experiment, it’s a finding, and I’ll get to it.
What g is, for the New-B. It’s a two-letter alias that does three things: clears the screen without erasing what scrolled by, prints a one-line sermon, and runs git status. Git is the program that remembers every version of every file in a project. git status asks it: does anything on disk differ from the last saved version? Mike’s output said yes, one file, foo_files.py, had unsaved changes. In his vocabulary the tree is dirty, and a dirty tree is a problem for the experiment that comes next, because the whole method is “change exactly one thing and compare.” If there’s already an unsaved change sitting there, you can’t tell later which change did what. So g is the ritual of checking that your left-hand boundary is clean before you touch anything. His proposed wording is right: “This repo is dirty and not ready for an experiment; run blast to clean the boundary.”
What blast did, line by line. It saved the change (git add -A), then asked a small AI model running on Mike’s own machine to write the one-line description that goes on the save. Look at the message it produced: “chore(router): set AI-edit blast boundary.” That’s not luck. A deterministic check noticed that the only changed file was the router, foo_files.py, and handed the model a hint saying “this is routine housekeeping, describe it that way.” The model wrote the prose; the code decided the category. Then blast pushed the save to GitHub (the “Enumerating objects… main -> main” noise is git’s own report of that), cleared the screen, and ran git status again: “nothing to commit, working tree clean.” Boundary set. And Mike’s aside is correct and underrated: the model that wrote that commit message runs locally, on hardware you probably already own. Writing a sentence about a diff is a small job. Nobody needs a datacenter for it.
Why the adhoc.txt template rides along even though only two lines are active. Every line starting with # is a comment. The compiler skips them, so they cost zero tokens in the payload the AI sees; the Processing Log says it plainly: “2 active line(s).” What the comments cost is screen space in Mike’s editor, and that’s the point. The file is a menu that’s always open in front of the human, listing every file worth including and every URL trick, so the operator never has to remember the grammar. It’s a margin you write in, with the instructions printed on the margin. The reason it appeared in full in this article is that Mike pasted the whole file for you, not that the compiler sent it to me.
The Outer Limits. 1963, the opening narration: “There is nothing wrong with your television set. Do not attempt to adjust the picture. We are controlling transmission… We control the horizontal. We control the vertical.” Mike means this: when you own the web server, the same address can answer differently depending on who’s asking. A browser asking for npvg.org gets a homepage. A terminal running curl asking for npvg.org gets a shell script. Same URL, two bodies, and the server decides based on what the request says about itself. The Honeybot already does exactly this for markdown versus HTML. Nothing about a file extension is required, because a URL was never a file path; that’s a GUI-era assumption. You control the horizontal.
Where that trick has a sharp edge, and he should hear it before the weekend. The one-liner reads curl -fsSL npvg.org | bash. There’s no scheme on that address, and curl defaults to plain http:// when you leave it off. So as written, the first hop of a command that runs a stranger’s script as you is unencrypted; a hostile network between the newcomer and the server can hand them a different script and -L will cheerfully follow. Nginx redirecting http to https closes most of it, since -L follows the redirect, but the fix that costs nothing is to print https://npvg.org in the one-liner. Pipulate.com’s own installer line already spells the scheme out. Match it.
The reading you got, and the reading you didn’t. dig asks the phone book for the address behind a name. It came back with [REDACTED_IP], so the domain is not dark. My reading of that number: it sits in a range I associate with a registrar’s parking service, the placeholder page a registrar shows before the owner points the name anywhere real. That’s INFERRED from a memory of address ranges, not OBSERVED, and it’s precisely the kind of thing I could be confidently wrong about, so it needs one more probe before it’s a ruling: a reverse lookup, which asks the phone book for the name behind the number. If it comes back naming a parking host, parked is observed. Then the curl. It hung. A hang is a reading too: the server accepted the connection and then never finished the secure handshake, which is typical of a parking box that has no certificate for your name. Rule from what we have: not dark, not serving anything of yours, and parked pending one receipt.
Why the curl hung the compiler, and the rule it teaches. The ! executor has a three-minute deadline and then kills the whole process group, so it would have come back eventually, but three minutes of silence reads as “never” to a human waiting. The defect was the probe, not the compiler: a network command with no time limit is unbounded in a dimension the Probe Economy rule usually forgets, which is time, not output. curl takes --max-time. Every network probe gets one. It’s the same lesson as head -5 on the output side.
On the Turing/Church mapping you made. You had it: probes are pure reads, the Church side, same input, same answer, no side effects; patches are the tape write, the one mutation; the two probe readings straddle the write and the diff between them is the receipt. That’s the whole five-car train described in two philosophies from 1936. This turn’s train had an empty patch car, which is allowed, and it still produced a finding, because a reading you didn’t have yesterday is progress even when nothing changed. Tomorrow’s train won’t be empty: the vhost on the Honeybot is the patch, nixops plus the rebuild is the ignition, and these same three probes are the AFTER.
1. PROBES
dig +short npvg.org
dig +short -x [REDACTED_IP]
curl -sI --max-time 10 http://npvg.org | head -5
The first is the unchanged control from last compile. The second converts my “parked” inference into an observation, or falsifies it, by naming the host behind the address. The third replaces the probe that hung: plain http because a parking box likely has no certificate for your name, and --max-time 10 so it can never hold ahc hostage again. If the third prints nothing within ten seconds, “no answer in 10s” is itself the reading.
2. NEXT CONTEXT
! dig +short npvg.org
! dig +short -x [REDACTED_IP]
! curl -sI --max-time 10 http://npvg.org | head -5
3. PATCHES
No repo patches required. No ignition required.
4. PROMPT
Dismount pending. Read the three receipts: the reverse lookup either names a parking host or it does not, and the bounded curl either answers or times out. Rule parked/dark/serving from receipts only. Then the npvg ride opens with one question: does the Honeybot's Nginx need the A record moved first, or can the vhost land HTTP-only and be witnessed by IP before DNS moves?
5. EXTERNAL DELIVERABLES
None this turn outside the repo. One note for the weekend, carried here because it isn’t a patch: when the landing page ships, the install line on it spells https:// in full.
MikeLev.in: Okay, we’ll do the 5-Car Train and then wrap the article. It’s a blueprint or at least a Cialdini-style commitment and consistency drawing a line in the sand or signing a public petition sort of putting one’s self out there stating in public what one is planning on doing.
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 $ dig +short npvg.org
dig +short -x [REDACTED_IP]
curl -sI --max-time 10 http://npvg.org | head -5
[REDACTED_IP]
HTTP/1.1 302 Found
Date: Sat, 12 Sep 2026 14:54:04 GMT
Connection: keep-alive
Location: http://www.npvg.org/
X-Served-By: Namecheap URL Forward
(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 _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | Wow that's a lot of stuff above to include just to show those 2 lines, huh? Maybe you should explain why it's still a good idea.
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | See! Isn't this a lot of wasted space in the article? Yes. Yes, it is. [in the voice of Phineas]
# 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.
# 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.
# STORYTELLING: OPTIONAL, BIG 40K-FOOT VIEW
# ! 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)
# GLOSSARY.md # <-- Terms defined like back of J.R.R. Tolkien book, grows as `prompt_foo.py` gets scars and shrinks.
# scripts/articles/lsa.py # <-- 2ND BRAIN: Search external memory with `rgx`, `rgxc` & `posts` Blogging for Hackers Jekyll-compatible.
# ~/repos/nixos/autognome.py # <-- Letting the AIs really understand my environment (The Brave Little Tailor punches above Their Weight Class proving the dunning-kruger effect the gate-keeper's (lower-case) lament.)
# STILL BIG BUT LESS OPTIONAL (especially flake.nix)
# init.lua # <-- Daily driver hot-keys that overlap with aliases in flake.nix. `<leader>m` makes it Science (this process)!
# flake.nix # <-- THE ONE BIG THING TO INCLUDE Infrastructure as Code (IaC) tells LLM about your system down to the metal
# prompt_foo.py # <-- THIS SYSTEM
# foo_files.py # <-- MAIN ROUTER FILE (alternative to this one)
# TINY BUT EXCELLENT FOR "THIS SYSTEM" CONTEXT (OK to include every time / automatically = `apply.py`, `.gitignore`, `.gitattributes`)
# requirements.in # <-- All known dependencies and (necessary) version pinning. WORA gotcha's exposed.
# __init__.py # <-- Master versioning
# pyproject.toml # <-- The PyPI Packaging details
# 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.
# STICKBUG & MOTHER CAT KATA (WORKING ON THE CHAPTER)
# assets/trails/first_context.yaml
# assets/trails/practice.yaml
# assets/trails/public_walk.yaml
# # assets/trails/botify_pageworkers.yaml
# Always include these with whatever connector
# scripts/sources_menu.py
# scripts/connectors/README.md
# scripts/connectors/wallet.py
# scripts/connectors/botify.py
# scripts/connectors/confluence.py
# scripts/connectors/gmail.py
# scripts/connectors/gsc.py
# scripts/connectors/jira.py
# scripts/connectors/mcp.py
# scripts/connectors/mcp_warm.py
# scripts/connectors/sheets.py
# scripts/connectors/slack.py
# The "walk" system is different from the Unix-like tiny connector commands.
# assets/installer/mck.sh
# assets/installer/replay.sh
# scripts/bookmark_import.py
# scripts/walk.py
# scripts/walk_cartridge.py
# scripts/walk_compile.py
# scripts/weblogin.py
# tools/scraper_tools.py
#
# scripts/mcp_dummy_server.py
# scripts/boot_menu.py
# scripts/mother_cat.py
# scripts/sources_menu.py
# --- 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)
# HINT: move cursor to this line and hit `d`, `d` in rapid succession then hit `i` and start typing.
# release.py # <-- The deploy process
# assets/installer/install.sh # <-- Pipulate.com installer real home in github/pipulate repo
# ~/repos/Pipulate.com/CNAME
# ~/repos/Pipulate.com/_config.yml
# ~/repos/Pipulate.com/_layouts/default.html
# ~/repos/nixos/.gitignore
# Context 2
# ! dig +short npvg.org
# # ! curl -sI https://npvg.org | head -5
# Context 3
! dig +short npvg.org
! dig +short -x [REDACTED_IP]
! curl -sI --max-time 10 http://npvg.org | head -5
# --- END `adhoc.txt` TEMPLATE ---
3: Patches: (the one change between the readings)
None
Ignition (what makes the patched code run before the AFTER reading – <F2>, nix develop, a re-ride – or none required):
4: Prompt: (the next question, written before the AFTER reading is in)
Dismount pending. Read the three receipts: the reverse lookup either names a parking host or it does not, and the bounded curl either answers or times out. Rule parked/dark/serving from receipts only. Then the npvg ride opens with one question: does the Honeybot’s Nginx need the A record moved first, or can the vhost land HTTP-only and be witnessed by IP before DNS moves?
5: Deliverables: [external artifacts, updates to this system or ‘None this turn outside the repo’]
This article! Hit it home, Fable 5.1! Go beyond this article-wrapping protocol any way you see fit to serve the audience this would best serve best.
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.
Fable 5.1 Medium:
1. VERIFY
Two goals were stated. The essay’s goal, explain the method to a newcomer, was met across three turns and is a matter of taste, not receipts. The train’s goal, “rule dark, parked, or already serving,” is met by this compile’s three receipts. dig +short npvg.org read [REDACTED_IP], so not dark. dig +short -x [REDACTED_IP] printed nothing: no PTR record, so the probe I nominated to convict “parked” was silent in both worlds and convicted nothing. The third probe did the work instead: curl -sI --max-time 10 http://npvg.org answered in 0.18 s with HTTP/1.1 302 Found, Location: http://www.npvg.org/, X-Served-By: Namecheap URL Forward. Ruling: PARKED at the registrar’s forwarder, OBSERVED, not inferred; where the www subdomain lands is UNWITNESSED. The hand-run BEFORE (14:54:04 GMT) and the compiled AFTER (14:56:39 GMT) agree line for line, which is exactly what a straddle with an empty patch car must print. Ignition: none required, none fired.
2. BANK
No BANK cars. The two rules this ride earned belong in foo_files.py, and that file is not in this context, so there is no raw source to anchor a SEARCH on. Per the template, a line with no Target and no anchor is not banked; both ride to DANGLING with their wording fixed and to SEED with the file that can receive them.
3. DANGLING
- EARMARK, THE UNBOUNDED-TIME PROBE (2026-09-12, executor-convicted): the Probe Economy rule bounds OUTPUT; a network probe with no
--max-timeis unbounded in TIME and stallsahcuntil the 180 s group-kill. Every network probe carries a timeout. - EARMARK, THE NOMINATED WITNESS WAS A RITUAL (2026-09-12): a PTR lookup prints nothing whether the host is a parking box or a live server with no reverse record; the HTTP header discriminated instead. Nominate two probes for one ruling when the first can be silent in both worlds.
- TODO: the advertised one-liner
curl -fsSL npvg.org | bashhas no scheme; curl defaults to plainhttp://. The landing page printshttps://in full, and the Nginx vhost redirects http to https. - TODO: the
\kNOTARIZE beat still says the deed’s name is not in context; the footer under every Prompt now names it (already on the ledger from 2026-09-06, reconfirmed here). - UNWITNESSED: what
http://www.npvg.org/itself answers.
4. SEED
foo_files.py
remotes/honeybot/nixos/configuration.nix
nixops.sh
! dig +short npvg.org
! curl -sI --max-time 10 http://npvg.org | head -5
! curl -sI --max-time 10 http://www.npvg.org/ | head -5
! ssh -o ConnectTimeout=5 honeybot 'ls ~/www'
5. CLOSING
This article ran the whole method on a change of zero and still came home with something, which is the point worth keeping. The newcomer was told to clean the tree, take a reading, change one thing, take the reading again. The one thing changed was nothing, and the readings were still worth having: the domain is parked at the registrar, the reverse lookup is mute, the forwarder answers over plain HTTP, and the install line as drafted would fetch its script the same way. None of that was known at 8:00 this morning, and none of it required a math degree. It required three short commands, a ten-second timeout, and the willingness to let the machine say what it saw rather than what it was expected to see.
The book’s larger arc is a Software Von Neumann probe: a seed that lands on a stranger’s machine and rebuilds the workshop that made it. This weekend the seed gets a launch pad with the author’s own name on the server. The first stone of that pad was laid here, and it was laid the Popperian way: not “the site is up,” but “here is what the site is, right now, by receipt, and here is what it is not yet.”
6. NOTARIZE
This Manifest carries no wc -c line; that field is not emitted by the compiler and is not substituted here. Attested fingerprint: 3 live receipts; newest receipt dated Sat, 12 Sep 2026 14:56:39 GMT; Summary reads 120,970 bytes UTF-8 across 6 Codebase members. The footer under this payload names its seal, so no guessing is needed:
Deed: foo-a69e4d93-1354.zip
This discussion is closed.
Book Analysis
Ai Editorial Take
What is striking about this entry is its subtle reframing of nostalgia. It doesn’t treat 1970s Unix philosophy as a quaint museum piece or a purist’s retreat; it repositions it as the ultimate high-leverage defense mechanism against LLM hallucination and framework obsolescence. By treating AI models not as omniscient oracles but as stateless lambda functions requiring strict input-output verification, the author turns vintage systems engineering into cutting-edge AI ergonomics.
🐦 X.com Promo Tweet
Stop building brittle web apps that rot in the age of AI. Learn how composable Unix text commands and checkable receipts create replayable, future-proof workflows that last. https://mikelev.in/futureproof/unix-way-ai-replayable-workflows/ #Unix #DeveloperWorkflows #AI
Title Brainstorm
- Title Option: The Unix Way in the Age of AI: Replayable Workflows Without the Bloat
- Filename:
unix-way-ai-replayable-workflows - Rationale: Directly contrasts timeless Unix principles with modern AI development challenges while emphasizing replayable, checkable workflows.
- Filename:
- Title Option: Text, Pipes, and Receipts: Future-Proofing Development Against AI Churn
- Filename:
text-pipes-receipts-future-proofing-ai - Rationale: Focuses on the core mechanical triad of the article: text manipulation, pipeline composition, and verifiable evidence.
- Filename:
- Title Option: Beyond the GUI: Why Composable Text Commands Outlast Tech Trends
- Filename:
beyond-gui-composable-text-commands-outlast-trends - Rationale: Appeals to developers weary of constant framework churn by highlighting the longevity of command-line tools.
- Filename:
Content Potential And Polish
- Core Strengths:
- Strong integration of historical computing foundations (Turing, Church, Unix) with modern AI challenges.
- Engaging conversational tone that bridges high-level philosophy with practical command-line examples.
- Clear articulation of the ‘before-and-after reading’ methodology as an antidote to blind vibe-coding.
- Suggestions For Polish:
- Tighten the transition between the introductory critique of web apps and the historical deep-dive into Unix origins.
- Ensure the distinction between checkable pipeline outputs and traditional testing is emphasized consistently throughout.
- Streamline the commentary on the ‘Eloi and Morlocks’ metaphor to keep the focus firmly on technical pragmatism.
Next Step Prompts
- Draft a follow-up guide detailing how to construct a minimal, 3-step Unix pipeline for validating LLM output without external dependencies.
- Expand upon the practical implementation of the ‘before-and-after reading’ loop within a standard local development script.