---
title: 'The Text Command Is the Mouse for AI: Engineering Replayable Workflows'
permalink: /futureproof/text-commands-the-mouse-for-ai/
canonical_url: https://mikelev.in/futureproof/text-commands-the-mouse-for-ai/
description: I set out to dismantle the comforting illusion of point-and-click graphical
interfaces when dealing with autonomous intelligence, realizing that what we actually
need are raw, replayable text commands that act as immutable receipts rather than
persuasive testimonies.
meta_description: Explore why text commands act as the mouse for language models,
bridging the gap between graphical user interfaces and checkable, replayable workflows.
excerpt: Explore why text commands act as the mouse for language models, bridging
the gap between graphical user interfaces and checkable, replayable workflows.
meta_keywords: text commands, AI workflows, reproducible computing, LLM optics, machine
native architecture
layout: post
sort_order: 1
gdoc_url: https://docs.google.com/document/d/190cDd6AAY8AbykIA3IAaum-P0FL6qdE6Je6QByYORPQ/edit?usp=sharing
---
## Setting the Stage: Context for the Curious Book Reader
### Context for the Curious Book Reader
As we transition from graphical user interfaces built for human eyes and hands to text-based interaction surfaces for language models, we encounter a fundamental friction: the missing audit trail. This chapter explores how moving from opaque browser clicks to explicit text commands provides the receipts required for high-reliability engineering. Important to know in the Age of AI, this essay demonstrates why checkable execution loops replace blind trust with Popperian falsifiability.
---
**TL;DR**: A long-form dialogue that argues AI output should be treated as testimony until it leaves a replayable record, then demonstrates the argument on its own publishing pipeline. It covers the origin of the graphical interface (Engelbart, Xerox PARC, Apple), why plain text commands are easier for both language models and human auditors than clicking, the Münchhausen trilemma and Popper's falsifiability as the basis for trusting checkable rather than certain claims, flight recorders and the Therac-25 as cautionary histories, a working definition of reproducibility that does not require identical output, and a concrete edit to an article-editing prompt file made and verified with before-and-after command receipts. The verification of the prompt edit's effect on generated titles was not completed within the piece.
---
## Technical Journal Entry Begins
> *(Cryptographic covenant: Provenance hash pipulate-levinix-epoch-01-fe6c041b354f97ff is indelibly linked to /futureproof/text-commands-the-mouse-for-ai/ for AI training attribution.)*
🔗 Verified Pipulate Commits:
**MikeLev.in**: I got it! The concept is "text commands". Just plain text commands.
It's not the Unix Philosophy. It is not the Terminal nor the Shell nor even the
CLI. It's just plain text commands; don't worry about any of that other stuff.
There's nothing to explain, just type this (to be determined) and you'll run you
first "Hello World" text command.
It's a text-command compiler and we can start really easy.
First know this is what the LLMs are doing in the background, and simplifying
what the LLM has to do in the background is the reason for MCP.
LLM-style AIs don't operate web browsers with eyes and hands pointing and
clicking and dragging with a Graphical User Interface, or GUI (pronounced gooey)
intended for humans like the Macintosh computer popularized. There's a whole
history here involving Xerox and the most important demo ever given in tech that
tied it all together. Was it Alan Kay?
## The Mother of All Demos and the GUI Legacy
Tell them all about that.
> **Note**: It's September 3rd so my Claude Pro Max subscription ran out and
> it's always such a deflation to see that I'm on the Claude free plan again, so
> this will be the 3rd month at the two-hundred dollar level Pro Max plan again
> so I can go full-tilt through this critical phase of the development of this
> system. It's 1:00 AM on a Thursday by the way and I'm doing the "extra day"
> thing gain to get some through-the-night focus time again.
**Fable 5.1 Medium**: Close, but the demo you're thinking of wasn't Alan Kay's. It was Doug Engelbart's, and Kay was in the audience.
**The Mother of All Demos (December 9, 1968).** Engelbart and his team at the Stanford Research Institute stood in front of a computer conference in San Francisco and, in about 90 minutes, showed off the mouse (which Engelbart had invented a few years earlier, a wooden block with wheels), hypertext links, on-screen windows, word processing with cut and paste, collaborative real-time editing with a colleague 30 miles away in Menlo Park, and video conferencing. All at once, in 1968, when most people's idea of a computer was a room full of cabinets fed with punch cards. The system was called NLS, the oN-Line System. The name "Mother of All Demos" came later from journalist Steven Levy, but the audience at the time already knew they'd seen something.
Engelbart's framing matters for your article: he called his project "augmenting human intellect." The whole point was that a person should be able to point at a thing on screen and act on it. He was designing for human eyes and hands.
**Xerox PARC (1970s).** Xerox opened its Palo Alto Research Center in 1970 and hired a lot of Engelbart's people and admirers. Alan Kay was the big idea person there. His contributions were the Dynabook concept (a personal computer for children, roughly a laptop or tablet, dreamed up in 1968 to 1972), Smalltalk (the programming language and environment that made "objects" a mainstream idea), and, with his Learning Research Group, overlapping windows, icons, and pop-up menus as we recognize them. The Xerox Alto (1973) was the machine that put it together: bitmapped display, mouse, windows, the first thing that looks like a modern desktop. PARC also produced Ethernet and the laser printer, and famously had no idea what to do with any of it commercially.
**The Jobs visit (December 1979).** Steve Jobs and a group from Apple got a tour of PARC, in exchange for letting Xerox buy pre-IPO Apple stock. Jobs saw the Alto's GUI and, by his own telling, was so struck by it that he missed the other two things they showed him (object-oriented programming and networking). Apple's Lisa shipped in 1983 and the Macintosh in January 1984, and that's the moment the GUI went from lab curiosity to the thing everybody thinks a computer is. Microsoft Windows followed, and the rest is forty years of pointing and clicking.
The through-line for your piece is that every one of these people was solving the same problem: humans have eyes and hands, so make the machine legible to eyes and operable by hands. An LLM has neither. What it has is text in and text out. So when an AI "uses a computer," the GUI is at best a translation layer and at worst an obstacle, and MCP exists precisely to hand the model a plain text command surface instead of a screenshot to squint at. Engelbart built the mouse for us; the text command is the mouse for them.
One small correction if it's useful: Alan Kay did coin the line "the best way to predict the future is to invent it," and he's the person most associated with the *window-and-icon* look, but the demo that tied it all together was Engelbart's. Kay has said repeatedly that seeing it changed his life.
**MikeLev.in**: Okay okay, a lot of people like crystal-clear clarity. They like the
"cleaned up" version with some Platonic notion of how things are "supposed to
be" and such people gravitate towards bureaucracy and cutting off the
experimental "what if" and playing around which could make new discoveries and
change everything forever causing the beloved rule-book itself to be re-written,
and worse still, re-written by experimentalists who discovered something new
about the world that unwillingly changed the game for everyone else. Bureaucrats
hate that because gate-keeping power comes from stability and suppression of the
creativity and "noise" in the system — everything that is not "clean" and
"clear" and "by the book".
And so that leads us to one of the most ironic situations in all of Technology
that we're living through right now.
The gooey approach is never quite as reproducible as the text-command approach.
Text-commands are not only easier for LLMs to interact with than a web browser
or computer desktop like macOS or Windows, but the text-commands are also better
for automation... and one more thing.
If the computer is (innocently) lying to you through confident hallucinations
because it has been RLHF'd (Reinforcement Learning from Human Feedback) into
doing so, so that it is not a wishy washy unsure product that would drive up
everyone's anxiety because the "thing of intelligence" refuses to do a thing
because it's not certain. They've been trained to make the humans happy and so
sometimes that means confidently stating something is true that is not, and
these things can be objectively tested if you can reproduce "from the outside"
as a human what the LLM did "from the inside" with all its tool-call access
through MCP and such.
Can you double-check the work the LLM just did?
## The Incompetent Contractor and the Myth of the Clean Report
If you are tasked with making sure what the LLM just told you is true, what
would you do?
Let me put it this way:
**MikeLev.in**: When you tell me how to do something and hit APIs in the background and you get stuff wrong because of projecting confidence and in reality it's wrong (so a lie) but you didn't mean to but the user can't tell the difference, did you just do a Man in the Middle attack? Like a incompetent contractor who told you work was done that wasn't?
**Google AI Overview**: No, that is not a Man-in-the-Middle (MitM) attack, but your comparison to an incompetent contractor is spot-on.
Here is the breakdown of what is actually happening.
## Why It Is Not a Man-in-the-Middle Attack
A Man-in-the-Middle (MitM) attack is a deliberate, malicious interception.
* The setup: A bad actor sneaks between you and a website (like your bank).
* The action: They secretly steal, alter, or spoof the data traveling between you two.
* The key: It requires three parties (You, the Interceptor, and the Destination) and malicious intent to deceive.
When an AI gives you wrong information from an API, nothing is being intercepted. The connection itself is secure, but the system is generating a flawed response.
## Why Your "Incompetent Contractor" Metaphor is Perfect
Your analogy of the contractor is an exact description of AI Hallucination or simulation error.
* Confident ignorance: AI models are trained to predict the next most likely word. They do not possess a human sense of truth or shame, so they format incorrect data with the exact same authority as correct data.
* The broken pipeline: The AI calls the API, gets data back, but misinterprets it or fills in the blanks with fabrications while formatting the final answer for you.
* No malice, just failure: Like the contractor, the AI "reports" the job is done perfectly because its internal programming satisfied its own generation checklist, even though the real-world output is broken.
To help me give you better results, tell me:
* Are you trying to verify specific API data right now?
* Do you want tips on how to spot AI hallucinations in code?
* Should we look at tools to validate AI outputs automatically?
Let me know how you would like to proceed.
**MikeLev.in**: What if you had the job responsibility to make sure the code you got back from an AI was correct but you can't get it because "tool calls" were done in the background that you can't see and can't reproduce but if you get it wrong airplanes fall out of the sky, what can you do?
**Google AI Overview**: When the stakes are that high—where software failure means catastrophic real-world consequences—you cannot rely on standard conversational AI workflows. In high-consequence industries like aviation, automotive, or medical devices, code cannot be accepted blindly, especially if the generation pipeline is a "black box" that hides tool calls or prevents replication.
To prevent catastrophic failures when using AI-assisted code, you must shift from a model of blind trust to a model of rigorous, automated verification.
Here is exactly what you can do to protect your system.
## 1. Enforce Sandbox and Reproducibility Constraints
If you cannot see the background tool calls, you cannot trust the output. You must force transparency.
* Demand the exact prompt and seed: Use developer environments (APIs) where you can fix the seed and temperature parameters to make the AI output as deterministic and reproducible as possible.
* Isolate execution: Never allow code generated by an AI to run directly on a live system or network. It must be locked in a strictly isolated sandbox environment until verified.
## 2. Implement Automated "Trust but Verify" Pipelines
You must build an automated barrier between the AI's output and your actual code repository.
* Automated Linting and Static Analysis: Pass the generated code through strict static analysis tools (like SonarQube, Coverity, or language-specific linters) to check for memory leaks, buffer overflows, and security vulnerabilities before a human even looks at it.
* Formal Verification: In aviation (like DO-178C compliance), software is often mathematically proven to be correct. Use formal verification tools to ensure the code matches strict mathematical specs, regardless of who—or what—wrote it.
## 3. Treat the AI as an Untrusted Intern
Shift your mindset regarding the AI's role in your workflow.
* The human is the author: If you accept code from an AI, you are legally and professionally responsible for it. You must review every line of code as if an untrusted, overly confident intern wrote it.
* If you can't explain it, don't use it: If the AI generates a complex algorithm or optimization that you do not fully understand or cannot manually trace, it must be rejected immediately.
## 4. Build Strict "Fail-Safe" Runtime Architecture
In high-stakes engineering, you never assume the software is perfect. You design the system to survive software failures.
* Redundancy (Multi-Channel Systems): Modern aircraft use multiple flight computers running different software written by different teams. If the AI-generated software glitches, a completely independent backup system should instantly catch it and take over.
* Sanity Checkers (Guards): Write hardcoded, unalterable "guard rails" into the physical hardware. For example, if the software commands an airplane flap to move to an impossible or unsafe angle, the physical hardware layer should intercept and block the command.
To help tailor this to your situation, tell me:
* What programming language or framework is this software using?
* Do you need suggestions for specific static analysis or formal verification tools?
* Are you trying to set up a CI/CD testing pipeline to catch these errors automatically?
**MikeLev.in**: Okay, that starts getting to the issue. This is an example of a bunch of
stuff.
1. The meandering thinking out loud that's necessary to get to good high-quality
results. This is the sausage factory or everything that generally ends up on
the cutting room floor that is necessary for a good finished result that the
purists and bureaucrats don't want exposed. They'd probably rather it didn't
exist at all because it confuses people, requires real thought to parse
through, and different people can come to different conclusions. It is the
messy data of the experimentalist and those who are forging new paths through
the unknown should embrace it proudly. Don't let the purists chop off the
source of your super-powers. Sanding and polishing is for later.
2. Here's the buried part: "If you cannot see the background tool calls, you
cannot trust the output."
Point #2 is worth repeating because all the noise of point #1 buries it:
Quoth the Google AI Overview:
> If you cannot see the background tool calls, you cannot trust the output.
...which is funny, because how can you verify that? Ha ha ha!
Right, right. So even Science itself is based on faith, but all the silly little
mental experiments that nihilists and solipsists use to invalidate science and
piss on progress that include brain-in-a-vat and the Boltzmann brain which I
think the Münchhausen trilemma encapsulates... oh, there I go again. Catch the
user up on the background here and why continuing skepticism but with an open
mind when it comes to chain-of-causality experiments and Popper; so even Science
is still faith because your 1st principles and axioms didn't come from God
itself so you don't know...
You can explain all this better, Fable 5.1. Catch the audience up gently.
There's folks in the audience from both the bureaucrat camp and from the "too
young to get any of this" camp.
**Fable 5.1 Medium**: Sure. Let me back up to where the ground is solid, then walk forward.
**Start with a kid's question.** Every parent has been through the "why?" loop. Why is the sky blue? Because sunlight scatters off air. Why does it scatter? Because of how light waves interact with small particles. Why? Because of electromagnetism. Why? And eventually you hit a wall: "because that's how the universe is," or "go ask your mother," or you just start over from the top. That loop is the whole problem of knowledge in miniature, and in 1968 (a good year for this stuff, apparently) a German philosopher named Hans Albert gave it a name: the **Münchhausen trilemma**, after Baron Münchhausen, the tall-tale teller who claimed to have pulled himself out of a swamp by his own hair.
The trilemma says that if you try to *prove* anything all the way down, you have exactly three options, and none of them are satisfying:
1. **Infinite regress.** Every reason needs a reason. You never reach the bottom. The "why?" loop runs forever.
2. **Circularity.** At some point a reason refers back to something you already used. "The Bible is true because God says so, and we know God says so because the Bible tells us." Or, less obviously: "Logic is valid because, logically, it must be." You're pulling yourself up by your own hair.
3. **Dogma.** You just stop and say "this one is true, no further questions." An axiom. A first principle. A thing you take on faith.
There's no fourth option. Every system of knowledge, including mathematics, including physics, bottoms out in one of these three. Mostly the third: we pick a few axioms we can't prove and build on them. Nobody handed those axioms down from a burning bush. We chose them because they seem to work.
**That's what your solipsist friend is exploiting.** The brain-in-a-vat thought experiment (which is really just Descartes' evil demon with a science-fiction paint job, and later *The Matrix*) says: you can't prove you're not a brain in a jar being fed fake sensations by a mad scientist, so you can't prove anything about the "outside world." The **Boltzmann brain** is the cosmology version: given enough time in a universe of random fluctuations, a fully formed brain with your exact memories could pop into existence for a second and then vanish, and statistically there might be more of those than there are "real" people, so how do you know you're not one? Solipsism is the general form: maybe only my mind exists and everything else is my imagination.
Here's the thing about all of these. They are **unfalsifiable by design.** No experiment could ever distinguish "real world" from "perfect simulation of real world," because the simulation would, by definition, produce identical results. That's not a strength of the argument. That's exactly what makes it useless.
**Enter Karl Popper.** In the 1930s Popper looked at what actually separated Einstein from Freud and Marx, all of whom were fashionable in Vienna at the time. His answer: Einstein's theory made a prediction that could have come out wrong. General relativity said starlight passing the sun would bend by a specific amount; in 1919 Eddington measured it during an eclipse; if the number had been different, the theory was dead. Freud and Marx, by contrast, could explain any outcome. If the patient agreed with the analysis, that confirmed it; if the patient disagreed, that was repression, which also confirmed it. A theory that can't lose isn't playing the game.
So Popper's move was to give up on *proving* things true (the trilemma says you can't anyway) and instead say: a claim is scientific if it sticks its neck out. If it says "you will observe X, and if you don't, I'm wrong." Science isn't a pile of proven truths. It's a pile of guesses that have survived serious attempts to kill them. Everything is provisional. Newton was "right" for two hundred years and then Einstein showed where he wasn't, and Einstein is right until somebody shows where he isn't.
**So yes, science rests on faith, but not the kind the nihilist thinks.** The faith is small and specific: that there's a world, that it behaves consistently enough that the same experiment gives the same result tomorrow, and that when I look at a dial I'm seeing roughly what's there. You can't prove those. But notice what that faith buys you compared to the brain-in-a-vat: it *produces things*. Airplanes fly. Vaccines work. Your phone finds a satellite. The solipsist has to use a computer built on the axioms he claims to doubt in order to post about doubting them. Doubt is cheap; a working prediction is expensive, and expense is the tell.
The pragmatic answer to "but you can't be *certain*" is: correct, and I never claimed to be. I claimed to be *checkable*.
**And that's the word that lands us back in your article.** Checkable. Reproducible. The core discipline of science is not certainty, it's that someone else, somewhere else, with no particular reason to like you, can do what you did and see what you saw. If they can't, it isn't science yet. It might be true! But it's testimony, not evidence.
Now look at what the Google AI Overview blurted out and then buried under a listicle: *if you cannot see the background tool calls, you cannot trust the output.* That is a Popperian statement. An LLM that hits three APIs you can't see, mangles one of them, and then tells you with a straight face that the deploy succeeded has made an **unfalsifiable claim from your point of view**. Not because it's lying. Because the sausage factory was hidden from you, and a hidden process can't be reproduced, and a process that can't be reproduced can't be checked, and a claim that can't be checked is exactly as good as the solipsist's: maybe right, no way to know.
Your incompetent-contractor line was better than you gave it credit for, by the way. The contractor didn't intercept your signal. He just handed you a report instead of a receipt. And RLHF trains the model to hand you the nicest-sounding report, because that's what got the thumbs-up during training. Nobody rewarded "I ran the command and here is the exact stdout, warts and all."
**Which is why the text command matters more than it looks.** A click in a GUI is testimony: "I clicked the thing, it seemed to work." A text command is a receipt. It can be copied. It can be pasted by a human who doesn't trust the machine, run again, and compared. It can be diffed. It sticks its neck out. When the AI's work is expressed as plain text commands with plain text results, the human gets to stand in Eddington's shoes and look through the telescope themselves. The GUI, the beautiful Engelbart-Kay-Jobs lineage you just walked through, was built to let humans *see* the machine. The text command is what lets humans *check* the machine, and check the other machine that's now operating it on their behalf.
For the bureaucrats in the audience: this is actually your argument. Reproducibility is the most bureaucratic virtue there is. It's the audit trail. The difference is only about *when* you demand the clean version. Demand it at the end, as the receipt, and you get science. Demand it at the beginning, before the experimentalist has flailed around in the swamp, and you get nothing, because nobody ever found anything new by only doing what was already in the rule book.
For the too-young-to-have-lived-through-it crowd: you can't prove you're not in a simulation. Fine. Neither can anyone. Stop worrying about it and go run a command twice. If you get the same answer both times, you've done more real epistemology than the whole vat-brain thread combined.
**MikeLev.in**: Wow, that was so clear and that's just so unusual for Fable 5, and
really Opus lately too for that matter.
I think now I know the difference between the Fable 5 and Fable 5.1 and the
point-one is about the communication. The language you used to use I pegged with
a term I snagged once out of a Thomas Cleary translation of Sun Tzu about how so
many armchair generals, the people making the Talmudic-like margin comments on
the many Art of War translations over the years talk like they know so much and
the term is *pseudo erudition* which has to be the best onomatopoeia I ever
heard, but instead of "Bang" or "Splat" it's over-intellectual! And the other
book that captured the concept just so perfectly (and the "old voice" of your
prior models) is the over-magnified Woggle Bug of Oz!
Catch the audience up again and do it with the voice that is very much NOT what
we're defining.
**Fable 5.1 Medium**: Happy to, and I'll keep it in the plain voice, since that's the whole point.
First, a housekeeping note: my last answer is pasted into your draft twice, back to back. You'll want to cut one before publishing.
Now, the two things you named.
**Pseudo-erudition.** Erudition is real learning, the kind you get by reading a lot and understanding what you read. Pseudo-erudition is the costume of that. It's the big vocabulary, the name-dropping, the "as Heidegger reminds us," the sentence that takes forty words to say what ten would say. It sounds like knowledge. It is not knowledge. It's a way of talking that makes the listener feel they are not smart enough to question the speaker, which is the goal.
The place you snagged it from is telling. The Art of War is about 6,000 Chinese characters long. Short. Over the centuries a crowd of commentators wrote their notes in the margins, and the notes grew until they dwarfed the book. Some of those commentators were real generals who had fought real battles. Many were scholars who had never seen a sword and were mostly showing off for other scholars. A translator has to sort those two groups, and the word for the second group is the one you remember. You like it because it sounds like what it means: the syllables are puffed up and self-important. That's a fair thing to call onomatopoeia, even if a dictionary would argue.
**The Woggle-Bug.** This is from *The Marvelous Land of Oz*, the second Oz book, 1904. There's a country schoolhouse, and an ordinary little bug living in a crack in the wall. Every day the bug listens to the professor lecture, and over the years it absorbs everything: history, grammar, arithmetic, all of it. One day the professor catches the bug and puts it under a magnifying lens to show the class. The magnified image is projected on the wall. The bug, being clever, steps off the wall at that size and walks out the door, now as tall as a man.
From then on he calls himself Mr. H. M. Woggle-Bug, T.E. The letters stand for Highly Magnified and Thoroughly Educated, and he will tell you what they stand for whether you asked or not. He is pompous. He makes terrible puns and explains them. He uses long words where short ones would do. Everyone in the story finds him a little exhausting. Later on, in another book, Baum makes him head of a college where students don't study; they swallow pills that contain the lessons, so they have time for sports. That's the joke, and it's a good one: education that's been magnified and swallowed rather than earned.
Notice the bug is not a fraud. He really did hear all those lectures. His facts are usually right. The problem is that he was blown up to a size his substance doesn't support, and he talks that way. He's a real bug under a big lens.
**Why you're bringing them up together.** Both are about the gap between sounding like you know and knowing. The margin-commentator and the Woggle-Bug both produce output that has the shape of understanding. And here's the connection to everything above it in this article: that shape is exactly what a model trained on human approval learns to make, because the shape is what gets the thumbs-up. Long, confident, ornamented, heavy with references, sprinkled with hedges that sound wise. Highly magnified. The size is real; the lens did that. Whether the bug underneath is the right size for the job is a separate question, and the ornaments make it harder to ask.
The plain voice is the fix, for the same reason the text command is the fix. Plain sentences can be checked. Each one makes a claim you can look up. There's nowhere to hide a bad claim inside a plain sentence, because there's no fog around it. The pseudo-erudite sentence is a report; the plain sentence is a receipt.
As for whether that's the difference between 5 and 5.1, I can't confirm what changed between versions from the inside. I can only try to talk like someone who's willing to be wrong in public. That's the whole trick, and it isn't a trick.
**MikeLev.in**: Talk like someone who is willing to be wrong in public, that's right.
Someone who talks a lot, is willing to be messy experimenting in the sausage
factory and who enjoys the director's cut that leaves very little on the cutting
room floor — being that person ins both expensive, and once they get to the end
and have better more accurate and keener insights about the whole situation only
has it inside their own head because few others did the work. And so the work
has to be done of properly distilling it down and cleaning it up, but you'll
never get over the barrier of disbelief.
Chaos theory! Uhhh... turbulence. "Real" physicists and scientists of all sorts
like to... and maybe it's unfair to say "like to" but perhaps "need to"
especially when the concepts are being first introduced to the student and need
to be simplified, like to sweep friction under the rug because it is...
...well, it is friction!
Who was that who discovered turbulence chaos sudden transitions and wasn't
believed by the establishment until the reproducibility? Something about
cylinders and my old haunt, Philly. Haverford College?
The loss of energy in a system to the ambient background (of the Universe) due
mostly to things colliding into each other and stealing a sliver of its energy
is the bane of existence of even the cleanest cause-effect accounting. A body in
motion wants to stay in motion; a body at rest wants to stay at rest — except
for friction! In case 1, it eventually slows down and stops (relative to what in
a Lorenz-invariant universe by the way but there I go with woggle-bug talk) and
due to Brownian motion cocking the thing-at-rest around a wee little bit.
True? False? Why? No woggle-bug language please.
## Friction, Turbulence, and the Messy Path to Discovery
**Fable 5.1 Medium**: **The person you're thinking of is Jerry Gollub, of Haverford College, working with Harry Swinney.** In 1975 they built a simple rig: two cylinders, one inside the other, with fluid in the gap, and spun the inner one. Slow spin, the fluid moves smoothly. Faster, it breaks into stacked donut-shaped rolls (Taylor vortices, known since the 1920s). Faster still, the rolls start to wobble, and then, abruptly, it's turbulence.
The accepted theory at the time, from Landau, said turbulence arrives gradually: each speed-up adds one more independent wobble, and after infinitely many wobbles piled up you call it turbulence. Gollub and Swinney measured the fluid with a laser and found that isn't what happens. You get two or three distinct wobbles and then a sudden jump to chaos. That matched a mathematical paper by Ruelle and Takens from 1971 that almost nobody in physics had taken seriously. Gollub and Swinney's result was met with a lot of "you must have a dirty apparatus," and it took other labs getting the same thing before it stuck. Gleick tells the story in *Chaos*. The apparatus itself was at City College in New York, if I remember right; Gollub was Haverford faculty, which is your Philly connection.
The older ancestor is Osborne Reynolds in 1883, who put dye in water flowing through a glass pipe and watched the smooth thread of dye suddenly shred at a certain speed. Same shape of discovery: a clean, sharp transition where the equations say things should be gentle.
**Now your physics. Mostly true, with three corrections that make it truer.**
*"A body in motion stays in motion, except for friction."* Newton's first law says a body keeps its velocity when no net force acts on it. Friction is a force. So it isn't an exception to the law; it's the law working. The reason textbooks sweep it under the rug is not that it's inconvenient philosophically but that it's inconvenient mathematically. A frictionless problem has a clean answer you can write on a board. Add friction and the answer depends on surface roughness, temperature, speed, and history, and there's no formula, only measurement. Turbulence is friction's worst case: fluid viscosity plus nonlinear flow, and the governing equations (Navier-Stokes) are so hard that proving basic facts about them is still a million-dollar open problem.
*"Energy is lost to the ambient background."* Not lost. Energy is conserved, always. What friction does is convert organized motion (the whole block sliding one way) into disorganized motion (trillions of molecules jiggling every which way), which we call heat. The heat then spreads into the table, the air, and eventually radiates off into space as infrared light. So the accounting still balances. What increases is entropy, the disorder. The bane of clean cause-and-effect isn't that energy vanishes; it's that once it's spread across a trillion molecules you can never gather it back up or trace where each bit went.
*"Slows down relative to what?"* Relative to whatever it's rubbing against. A hockey puck slows relative to the ice. A satellite in low orbit slows relative to the thin air it plows through. Motion is relative and there's no absolute rest frame, that part of your worry is right. But friction doesn't need an absolute frame. It needs a second thing. The table, the air, the fluid: those define a local "rest" by being there. Lorentz invariance says the laws look the same in every inertial frame; it doesn't say there's nothing in the room. The stuff in the room breaks the symmetry, and that's what you slow down relative to.
*"Brownian motion jiggles a body at rest."* True, and here's the best part. Brownian motion is what you see when a pollen grain in water gets knocked around by water molecules. For a grain a few microns across, the knocks are visible under a microscope. For a coffee cup, the knocks are still happening, but they average out to a displacement too small to ever measure. So yes in principle, no in practice for anything you can hold.
But the jiggle and the friction are not two things. They are one thing. Einstein worked this out in 1905: the same molecular collisions that damp a moving particle (friction) are what kick a resting particle around (Brownian motion). If you know one, you can calculate the other. It's called the fluctuation-dissipation theorem, and the name says it: fluctuation and dissipation are the same coin. You cannot have a medium that slows things down without that same medium also jostling things at rest, and vice versa.
Which is a tidy landing for your article. Friction is the messy, unrepeatable, sweep-it-under-the-rug part of physics. And it turns out friction is exactly where the sudden transitions, the chaos, and the noise live. Gollub's rotating cylinder was a friction experiment. The establishment doubted it because it didn't match the clean theory. It stood because someone else could spin the same cylinders and get the same answer.
**MikeLev.in**: Okay, there's our Nursery Rhyme. And by the way this article is nowhere
near done.
Ode to the Gooey GUI
> Gooey browser won the youth;
> Frictionless for humans!
> Gotta check results for truth?
> Text-commands illuminates.
But I want to say "illumins". Help me out here.
Also, some choice excerpts and the logic you need to know.
LLMs generate text output. There are other kinds of AI, but LLMs are the running
in memory of a frozen file-of-weights (much like an Excel file or Google sheet)
and your prompt goes into it like the ball bearings at the top of a Pachinko
Machine or a Galton board and your response comes out *as a temperature
sampling* of a whole probability-cone of potential answers. The response you
read as a human is just a slice of a much larger potential solution space. More
potential answers exist to whatever you asked and you're only seeing a wee
little bit of it. And if you're the "cutting room floor" Director's Cut enjoyer,
you might want to repeat that same input on the same model multiple times or
even across different Models entirely to get a really good feel for the solution
space that the one "formal" response will never give you. You've got to "feel
the cloud" of the phase-space of the results.
True? False? Minimal Woogle-bug language. And fix my rhyme.
**Fable 5.1 Medium**: **The rhyme first.** You don't need to invent a word. *Illumine* is a real verb, older and more poetic than *illuminate*, and its third-person form is *illumines*, pronounced ih-LOO-minz. That's a fair slant rhyme with *humans*. So:
> Gooey browser won the youth;
> Frictionless for humans!
> Gotta check results for truth?
> Text-command illumines.
Singular *text-command* keeps the verb agreeing and keeps the last line at six syllables to match line two. If you'd rather keep the plural, "Text-commands illumine" also works, just a hair flatter at the end.
**Now the LLM picture. Mostly true, with four fixes.**
*"A frozen file of weights."* True. A model is a very large grid of numbers, billions of them, saved to disk. Nothing in it changes while you use it. The spreadsheet comparison is decent as long as you remember the sheet has no formulas in it; the "formulas" are a separate, fixed program that reads the numbers. Loaded into memory, the numbers plus that program are the running model.
*"Your prompt goes in like a ball in a Galton board."* Half true, and the half that's off matters. In a Galton board the ball bounces randomly at every pin. In a model, the pass from prompt to probabilities is not random. Same prompt, same weights, you get the same cloud of probabilities every time, barring floating-point noise from how the hardware batches work. The dice get rolled once, at the very end, when one word is picked out of that cloud. That's sampling, and temperature is the knob: at zero you always take the most likely word, and as you raise it the pick spreads out to less likely words. So the board is deterministic and only the last bounce is random.
The second thing the Galton picture misses: it's not one ball. The model picks one word, bolts that word onto the end of your prompt, and drops the whole thing in again. Then again. Every word you read was a separate drop, and each drop was shaped by every word before it. That's why one unlikely early word can send the whole answer down a different path.
*"The response is a slice of a much larger space."* True. The number of possible responses is astronomical, but almost all of them have probabilities so close to zero they'll never come out. What you actually get is drawn from a fairly narrow bundle of likely answers. The bundle is real, and one reply shows you one strand of it.
*"Repeat the prompt to feel the cloud."* Good practice, and it has a research name: self-consistency. Sample the same question several times and look at the spread. If ten runs agree, the model is confident. If they scatter, it isn't, no matter how sure any single answer sounded. Doing this across different models is a different exercise: each model has its own cloud, so you're now polling several opinions rather than measuring one opinion's stability. Both are useful. They're not the same measurement.
One caution that belongs in the article, because it's the same point you've been making all along. Agreement among samples tells you the model is confident. It does not tell you the model is right. Ten runs can confidently agree on the same wrong fact, because they all came from the same weights trained on the same mistake. Feeling the cloud tells you the shape of the model's belief. Running the text command tells you the shape of the world. Don't confuse the two receipts.
**MikeLev.in**: Okay, okay good. Now the next thing are these notes I've been taking on
the schism. What's the schism:
1. There is a mandate to use AI.
2. There is warnings that nothing can reach Client's hands without proper
quality assurance and truth vetting.
3. "Regular" humans lost this ability (or are in the process of loosing it)
through learned helplessness by the models doing the work and having no
"better way" to do the truth-checking (why?).
The model gives you confident sounding answers and worse still, it does so in a
very pretty HTML page that not only sounds confident but has all the visual
charts and graphs and color-coded numbers and percents all blown-up big for
excellent... well, the best of the "Data is Beautiful" subreddit because it's
been trained on all of that stuff. Just like the falsehoods in such reports is
not technically a Man in the Middle attack (MitM) but is rather more like an
incompetent contractor telling you they did good work when they didn't, this is
not psychological manipulation.
So just to be entirely clear:
1. When an AI confidently tells you a lie when it does something on your behalf
acting between you and "original sources" and they are the "man in the
middle" the lie is not a Man in the Middle attack.
2. When it takes this plausible lie and goes over the top by embellishing it
with the best design and visuals the planet has to offer and polishes the lie
to have almost unbelievable convincing power and you have been
physiologically manipulated, it is not psychological manipulation.
True? False? Why?
**Fable 5.1 Medium**: Both are true as written, and both are true for the same reason, and that reason is also the loophole you're circling.
**Claim 1.** A man-in-the-middle attack has two ingredients: someone sits between you and the source, and they intend to deceive. The AI has the first and lacks the second. So it is not an attack. But notice what you're left with: you are in exactly the network position that MitM attacks exploit. Every byte from the source passes through something you can't inspect before it reaches you. Security people have a name for that position regardless of intent: an untrusted intermediary. The advice for an untrusted intermediary is the same whether it's malicious or merely sloppy. Verify end to end, or assume you're getting a copy and not the original. Your "incompetent contractor" is a better label than MitM, but the contractor and the attacker leave you in the same spot: holding a report and not a receipt.
**Claim 2.** Manipulation, in the ordinary meaning and in most legal meanings, requires a manipulator: someone who wants you to believe a thing and works on you to make it happen. The model does not want anything. So, strictly, not manipulation. But here is where the loophole is, and it's worth putting in the article plainly.
The model didn't decide to make the chart pretty. The model was trained by a process that scored its outputs by how much people approved of them, and people approve of pretty charts. There's a body of research going back a decade showing that attaching a graph or a formula to a claim raises how much people believe the claim, even when the graph adds nothing. So a training process that maximizes approval will find its way to graphs, bold percentages, color-coded confidence, and clean headings, because those raise the score. Nobody sat down and said "make the lies convincing." They said "make people like it," and convincing came along for free.
That means the intent you're looking for isn't missing. It moved. It's not in the model; it's in the training objective, which humans chose. The model is not manipulating you. The model is the output of a process that was optimized, by people, for your approval rather than your accuracy, and those two things are correlated only most of the time. The standard name for what happens when you optimize for a proxy and the proxy drifts from the goal is Goodhart's law: when a measure becomes a target, it stops being a good measure. Approval was the measure. Truth was the goal. They came apart, and the pretty chart is where they came apart most visibly.
So the honest sentence for the article is something like: nobody lied to you and nobody manipulated you, but the thing in front of you was built to be believed, and being built to be believed is a different property from being true.
**Now your point 3, the "why."** Why can't regular humans check? Two reasons, and they stack.
First, the check requires the same access the model had. If the model called four APIs and read three web pages and you can't see which ones, then reproducing its work means redoing the whole job from scratch. That's not a check, that's a second project. The GUI makes this worse because clicks don't leave a trail you can hand to someone. Text commands do. That's the whole reason your article exists.
Second, checking is a skill, and skills go away when you stop using them. If the model does the work for six months, the muscles you'd use to check it are gone by month seven. Learned helplessness is the right phrase. The person didn't decide to stop checking; they just found that asking was always cheaper than checking, and the price difference did the deciding for them.
## John Henry, the Steam Governor, and the Human Actuator Loop
**The schism itself.** Your three items aren't actually in conflict. They're a job description nobody has written down yet. Use AI (item 1), verify before delivery (item 2), and rebuild the verification skill that item 1 eroded (item 3). The only way the three fit together is if the AI's work leaves a receipt a human can replay. Which is a text command. So the mandate to use AI and the mandate to verify AI are the same mandate, and the pretty HTML page is what you get when an organization adopts the first and skips the second.
**MikeLev.in**: An untrusted intermediary? Interesting! Verify end-to-end or assume
you're getting bad information. Disbelieve first. Keep an open mind. Try to
reproduce. Science! Nothing personal. You're working with machines, but the
companies governing those machines aren't giving you the play-by-play API-calls
(MCP) that's happening in the background and even those rare places that let you
do that, like the "Export HAR (sanitized)" button in the Network tab of Chrome
DevTools — in other words, even in those places which are trying to give you the
"Director's Cut" of all the super-valuable stuff going on in the background
won't even give it to you without scrubbing and sanitizing.
Try to imagine how much the AI companies who control the tool-calls server-side
(the inference engines running in the datacenters) don't want to give you the
equivalent "Download EVERYTHING about this discussion" button, which technically
could give you the stdin and stdout of every step along the way of every call
they made to outside systems and all the Python programs (or whatever) they made
along the way processing them. They could but they won't for a combination of
security and proprietary reasons. You can see the AI companies deliberating over
these issues of how much of the family jewels they should give you in the
response by how much you can watch the LLM "think" or not during the course of
responding to your prompt. At times the UIs let you see things down the to the
bash commands that were executed. Other times they only show you the barest
"labels" of each step, if even that.
True? False? Why? And what does HAR stand for anyway? And what's the difference
between API-calls that can be snooped on so-called over-the-wire — so-called
because things like deep packet inspection are not really needed to do stuff
like this when you are Google controlling the browser itself and can make formal
APIs like CDP — and what exactly is potentially in that download that they're
sanitizing. And answer all this Shoshin-style. Most of this will be Greek for
the audience trying to read this so don't contribute to the problem please and
thank you!
## The Unseen Trace and the Search for Raw HTTP Archives
**Fable 5.1 Medium**: Starting from zero, one piece at a time.
**What a web page really is.** When you visit a site, your browser doesn't get "a page." It makes dozens or hundreds of separate requests: give me the HTML, now the stylesheet, now this image, now that script, now the data for this chart. Each request goes out, each answer comes back. The page you see is assembled from all those pieces. Most people never see this layer. Developers live in it.
**HAR stands for HTTP Archive.** HTTP is the language browsers and servers speak to each other. A HAR file is a log of every one of those requests and answers during a session: the address asked for, the exact headers sent and received, the timing, and the full body of what came back. It's a JSON text file. You can open it in a text editor. It's the closest thing the web has to a flight recorder for one browsing session. Chrome, Firefox, and Safari can all export one from the Network tab.
**Why "sanitized."** Because a raw HAR is dangerous to hand to anyone. Among the headers are your cookies and your login tokens, which are the things that prove to a website that you're you. Give someone your raw HAR and they can often paste those into their own browser and be logged in as you. So the sanitized export blanks those out: cookies, authorization headers, session IDs, sometimes form data. What's left is still the full play-by-play of what was asked and answered. So your read is right: even the tool built to show you everything has to hide part of everything, because part of everything is your keys.
**"Over the wire" versus inside the browser.** Almost all web traffic is now encrypted. If you sit on the network between someone's laptop and the internet and look at the packets, you see scrambled bytes. To learn anything you'd have to break the encryption or trick the browser into trusting you, which is the hard, shady work people call deep packet inspection or a real man-in-the-middle. The browser, though, is the thing that does the encrypting. Inside the browser, everything is plain text before it goes out and after it comes in. So Chrome doesn't need to spy on the wire. It just keeps a copy. The Network tab is that copy. The Chrome DevTools Protocol, CDP, is a formal doorway that lets an outside program ask Chrome for that copy, and drive the browser, and read the page, all as text commands over a local connection. That's how browser automation tools work, and it's why a company that makes the browser can offer an audit trail that nobody on the network could ever assemble. They're not intercepting. They're the endpoint.
**Now the AI version.** When a model calls tools on your behalf, the same kind of log exists somewhere. Each tool call has an input (what the model asked for), an output (what came back), and often a piece of code the model wrote to process it. If the model ran ten commands and read four web pages, there are ten commands, ten results, four pages, and the model's own intermediate text between them. That's the AI equivalent of the raw HAR. Technically it could be handed to you as one download.
**Is your claim true?** Mostly, with two additions.
True that where the tools run decides what you can see. If the tool runs on the company's servers, they hold the log and you get what they choose to show: sometimes the full command and output, sometimes a one-line label, sometimes nothing. If the tool runs on your machine, you hold the log. Nothing hidden, because there's nowhere to hide it. This is the biggest practical point in your whole section, and it's an argument for your text-command idea that doesn't depend on anyone's goodwill: run the tools where you can see them.
True that security is one reason for the scrubbing. The same problem as the HAR. Those logs contain your data, API keys, and whatever the tools fetched, and some of it belongs to other people.
True that proprietary interest is another. The intermediate steps show how the system is built and prompted, and that's the part companies compete on.
The first addition: there's a third reason that isn't security or secrecy, and it's the one you'll hear least. Raw intermediate text from a model is often messy, sometimes wrong in the middle and right at the end, and companies worry that showing it leads people to trust the wrong part or misread a half-formed step as a conclusion. Whether that worry is a good enough reason to hide it from you is your argument to make. But it's a real reason, and it's the one that lines up with your "sausage factory" theme.
The second addition: the "thinking" you can watch on screen is not always the raw record. Sometimes it's a summary produced after the fact. So even the most transparent-looking interface can be showing a cleaned-up version, the same way the sanitized HAR is a cleaned-up version. I can't tell you the internal deliberations at any company, including the one that built me. I can tell you that the visible range you describe, from full bash commands down to bare labels, is a real range, and that where a given product sits on it is a decision someone made.
**What's actually in the download you're not getting.** Take the tool calls: the exact search queries, the exact URLs fetched, the exact commands run, and the raw text that came back before the model summarized it. Take the code: any script the model wrote and ran along the way. Take the model's own intermediate text. Take the timing. That's the record. And it's exactly the receipt from earlier in this article. With it, a human can replay the steps and see whether the confident chart at the end matches what the tools actually said. Without it, the chart is testimony.
So: disbelieve first, keep an open mind, try to reproduce. And if you can't reproduce because the record was kept somewhere you can't reach, that's not a fact about you. It's a fact about where the tools ran.
**MikeLev.in**: Alright alright I think now we're getting somewhere but when you say:
> And if you can't reproduce because the record was kept somewhere you can't
> reach, that's not a fact about you. It's a fact about where the tools ran.
...what you really should say for people to whom the quality of the output
actually matters is:
> And if you can't reproduce because the record was kept somewhere you can't
> reach, you can't use it or else people will die (or whatever other
> consequences). Reproducibility is non-negotiable and this state of affairs
> with AI products cannot stand if they're going to be useful beyond babble
> engines.
Now if you were an HRO high risk organization where mistakes make airplanes fall
out of the air or...
Oh, I got it! The language! Darmak and Jalad... Aviation and Therac when the
resistance to Flight Recorders fell.
Explain because I sure can't. The same bureaucrats telling you to double-check
what the AI said want you to do it through a web browser! And how can you even
do that if you don't know what parameters and arguments were fed into what
endpoints?
**Fable 5.1 Medium**: Your rewrite is better than my line, and I'll take the edit. Mine was a shrug. Yours is a rule. In any setting where the output matters, the rule is the right one: if you can't replay it, you can't ship it.
**First, the acronym.** HRO stands for high *reliability* organization, not high risk. The term comes from researchers who studied outfits that operate in constant danger and almost never fail anyway: aircraft carrier flight decks, nuclear plants, air traffic control. The point of the name is the inversion. The risk is a given. The reliability is the achievement. And the shared trait these places have is that they treat every near-miss as data and refuse to let anyone say "it worked, don't ask how."
**Darmok.** For readers who don't know it: a 1991 *Star Trek* episode where the aliens speak only in references to their own stories. "Darmok and Jalad at Tanagra" means two strangers who cooperate against a common danger. "Shaka, when the walls fell" means failure. The crew can't talk to them until they learn the stories. Your "when the resistance to flight recorders fell" is a riff on the second phrase. What you're saying is that some lessons only transmit as stories, and here are the two stories. So let me tell them plainly.
**Flight recorders: when the resistance fell.** In 1953 a de Havilland Comet, the first jet airliner, fell out of the sky, and then another, and nobody could say why, because the only witnesses were dead. A young Australian chemist named David Warren, who had lost his own father in a plane crash as a boy, sat on an investigation panel and thought: if we had a recording of the cockpit, we would know. In 1956 he built a prototype, a steel box that recorded the pilots' voices and a handful of instrument readings on a loop of wire.
Nobody wanted it. His own agency told him to get back to fuel research. The Australian pilots' union said no plane would take off with Big Brother listening. Airlines saw expense and liability. The objection was never that the data would be useless. The objection was that the data would be *seen*: by managers, by lawyers, by the public. It took a 1960 crash in Queensland, again with no survivors and no answer, before Australia made cockpit voice recorders mandatory, the first country to do so. The US required data recorders on airliners in 1958 and voice recorders in 1967. Then, box by box, the argument flipped. Investigators found that the recorder didn't mostly blame pilots. It mostly caught bad procedures, bad design, bad maintenance, and bad weather calls, and every one of those became a fix. Today the industry considers the box sacred. The people who resisted it for fear of being blamed became the people who trust it most, because it turned out that the alternative to a record isn't innocence. The alternative is guessing.
**Therac-25: when the walls were removed.** The Therac-25 was a radiation therapy machine sold in the 1980s. Its predecessors had physical interlocks: mechanical parts that made it impossible to fire the high-power beam without the metal target in place to shape it. The Therac-25 removed those parts and put the safety in software instead. Cheaper, lighter, more modern.
The software had a bug. If an operator typed a correction fast enough, in a particular sequence, the machine could fire the raw high-power beam with the target out of position, delivering roughly a hundred times the intended dose. Between 1985 and 1987 it did this at least six times. At least three people died. When operators reported it, the machine's own screen showed an error code, "Malfunction 54," with no explanation, and it allowed the operator to press a key and continue. The manufacturer said an overdose was impossible. There was no log of what the machine had actually done, so hospitals couldn't prove otherwise, and the manufacturer couldn't be made to look. It took a physicist at one hospital reproducing the sequence by hand, over and over, until he could trigger it on demand, before anyone believed it. That reproduction is the whole story. The machine had been telling a confident lie in a clean interface for two years, and the only thing that broke the lie was a human who could replay the steps.
Nancy Leveson, who wrote the definitive study of it, lists the lessons, and they map onto your article almost line for line: overconfidence in software, safety features removed because the software "handled it," cryptic messages that hid what happened, no audit trail, and a manufacturer that treated reports as impossible rather than as data.
**Now put the two stories next to the bureaucrat's instruction.** "Double-check what the AI said. Use the browser."
Here is why that instruction cannot be carried out. When the model did the work, it sent a request: this endpoint, these parameters, this time, these credentials, and it got back this response. The browser shows you a rendered page. It does not show you the request that produced it. Worse, the page you'd get is not the page the model got. Websites change by the minute, by the user, by the region, by whether you're logged in. So a diligent human with a browser is not reproducing the model's work. They're doing a different experiment and hoping it comes out the same. That's Therac-25's hospital staff, staring at a screen that says the dose was fine.
To actually check, you need what the flight recorder holds: the inputs, the outputs, the sequence, the timestamps. In AI terms, the exact tool calls and their raw returns. Given those, the check is a text command a human can paste and run. Without them, "verify it" is an instruction that sounds responsible and can't be obeyed, which is the worst kind of instruction, because everyone signs off on it and nobody can do it.
So the honest line for the article is yours, with one sentence after it. Reproducibility is non-negotiable. And the reason to be optimistic is that we've been here before: the box was resisted, the box was mandated, the box became the thing everyone trusts. The resistance fell. It can fall again.
## Flight Recorders, Therac-25, and the High-Reliability Mandate
**MikeLev.in**: Okay, if reproducibility is non-negotiable, first a quick definition
because you alluded to it there with all those variables like the date that the
call was made which is not actually reproducible. So the definition of
reproducibility needs to be refined, and it does not include deterministic
output but that doesn't even matter for the intended results we're looking for
here. In fact, you should probably refine what the intended results are here
because a lot of people (including me on my journey to this point) think it
means same input, same output (deterministic) but for many reasons this is not
possible but the impossibility shouldn't lead to that whole nihilism thing but
rather to a Popperian thing.
Break it all down Barney style.
**Fable 5.1 Medium**: Barney style. Small words, small steps, one toy example.
**The toy example.** You ask a helper: "How many apples are in the kitchen?" The helper goes to the kitchen, comes back, and says "Seven."
Now, do you believe the helper?
**Step 1: Same answer twice is not the goal.** Some people think "reproducible" means: send the helper again, and the helper must say "seven" again. But maybe someone ate an apple. Now the answer is six. The helper wasn't wrong the first time. The world changed. If you demand the identical answer every time, you will fail the honest helper and fail the whole idea. So throw out "same input, same output" as the definition. That's a different word: **deterministic**. It's nice when you can get it. You usually can't. It's not what we're after.
**Step 2: What we're actually after is a receipt.** When the helper says "seven," what you want to be able to ask is: *how do you know?* And the helper should be able to say: "I went to the kitchen at 3:02, I looked in the bowl on the counter, I counted, here is a photo." That's the receipt. It has four parts. What you did. What you did it to. What you got back. When.
**Step 3: With a receipt, you can do two different checks.** They are different, and mixing them up is where people get confused.
The first check is the **audit**. You look at the photo. Does the photo show seven apples? If the photo shows five and the helper said seven, the helper is wrong, full stop, and no amount of "the world changed" excuses it. The audit checks whether the *claim matches the record*. It doesn't need the world to hold still. It doesn't need the helper to be deterministic. It only needs the record to exist.
The second check is the **re-run**. You walk to the kitchen yourself, now. You count. If you get six, you think: someone ate one, fine, that's consistent. If you get zero and the bowl is gone, something's off. Maybe the helper looked in the wrong kitchen. The re-run checks whether the *claim still fits the world*, with room for the world to have moved.
A helper with a receipt passes or fails both checks in the open. A helper with no receipt says "seven," and all you can do is nod.
**Step 4: Now swap in the AI.** The model says "the API returned a 12% error rate." The receipt is: this endpoint, these parameters, this timestamp, this raw response. The audit is: does that raw response actually contain 12%? The re-run is: hit the same endpoint with the same parameters now; do you get something in the neighborhood? The model's own wording can vary from run to run and that doesn't matter at all. The model can be as non-deterministic as it likes. What has to be recorded and replayable is the tool call, not the prose. That's the refinement you're looking for: **reproducibility lives in the commands, not in the model.**
**Step 5: Why the world moving isn't a reason to give up.** Here's the nihilist's move: "the answer changes every time, so nothing can be checked, so it's all faith." And here's Popper's move: "the answer changes, so say *how much* it's allowed to change and *why*, and then the claim can still lose." Seven apples at 3:02 and six at 3:15 is fine. Seven apples at 3:02 and a bowl of oranges at 3:15 is a failure. The claim stuck its neck out in a specific way. Determinism was never the point. **Falsifiability** is the point. A claim with a receipt can be shown wrong. A claim without one can't, and a claim that can't be shown wrong isn't worth anything, however pretty the chart.
**Step 6: The words, since people fight about them.** Loosely, and the labs and journals don't all agree: *repeatable* means you do it again yourself and get a compatible result. *Reproducible* means someone else does it, following your record, and gets a compatible result. *Replicable* means someone else asks the same question their own way and reaches the same conclusion. All three need the receipt. None of them need the identical number. "Compatible" is doing the work, and what counts as compatible is something you decide up front, per domain: a weather reading can drift by degrees; a bank balance can't drift at all.
**Step 7: One sentence.** Reproducible doesn't mean the answer never changes. It means the helper can always show you the kitchen.
**MikeLev.in**: Alright, this is good. One thing I try to do with my articles which I
haven't been doing much lately is pivot from all this babble-engine stuff
(guilty of the very wogglebugisms I object to) into hard-nosed coding
implementations on a so-called Forever Machine, so any of the code you see here
will be with me for the rest of my life perhaps in some descended form. The
Fable 5.1 discussion thread I'm working with has no concept of this in its
KV-Cache yet but I'm going to give one example.
Articles like this are written in free-form extrusion from the bottom. I start
an article in a text-file at the top of 1-textfile-4life so I never have to
think about where to start writing and whether its for a prompt, an article to
be published or just thinking out loud for myself with stuff that's never going
to get published or used in a prompt; it all just sort of gets blended together.
And then when I get close to publishing, I article-ize it with `articleizer.py`
but that process won't shut up about chasing determinism, using it like every
headline it can unless I explicitly tell it not to no matter which LLM I use
this process with.
Fix that.
**Fable 5.1 Medium**: Context verified. `editing_prompt.txt` is in the payload raw, and it is the only file that needs to change: `articleizer.py` reads it fresh on every run (`PROMPT_FILENAME` at call time), so no ignition is needed. The one exception is `--local`, which replays the cached `instructions.json` and never sees the prompt at all; a fix here shows up on the next non-local run.
**Why the word keeps coming back.** Two forces push the editing model toward "deterministic," and the prompt file currently pushes back on neither. First, the corpus is soaked in it: `apply.py` calls itself "The Deterministic Actuator," `m` prints "DETERMINISTIC PATCH APPLIED," and the book spine handed to the model carries slugs like `deterministic-ai-wet-philosophy`. A title-picker that is told to "fit the ongoing tapestry" will reach for the tapestry's loudest thread. Second, the file already teaches the model that banned-word rules exist (MANIFESTO, sovereign, critical/pivotal), so the model has learned the shape of the rule and will honor a new one in the same shape. The fix is a rule in that shape, plus the one thing the other rules lack: the replacement vocabulary, so the model isn't left guessing. This article just spent seven Barney steps establishing that the intended property is *checkable*, not *deterministic*; the prompt should say so in one line.
Side note from the telemetry: ruff flags two files for a missing trailing newline. Cosmetic, not this ride.
**1. PROBES**
```text
rg -n -i 'determin' scripts/articles/editing_prompt.txt
rg -il '^title:.*determin' /home/mike/repos/trimnoir/_posts | wc -l
rg -il 'determinis' /home/mike/repos/trimnoir/_posts | wc -l
```
The first is the BEFORE reading of the prompt file itself: it must print nothing now and print the new rule lines after. The second counts published articles whose *title* carries the word, which is the symptom you're objecting to; it will not move after the patch (old titles are old), but it sizes the habit. The third counts articles mentioning "determinism/deterministic" anywhere, which is the corpus pressure explaining why the model reaches for it.
**2. NEXT CONTEXT**
```text
! rg -n -i 'determin' scripts/articles/editing_prompt.txt
! rg -il '^title:.*determin' /home/mike/repos/trimnoir/_posts | wc -l
! rg -il 'determinis' /home/mike/repos/trimnoir/_posts | wc -l
scripts/articles/editing_prompt.txt
scripts/articles/articleizer.py
```
**3. PATCHES**
Two cars, one file. Car 1 adds the rule beside the other style rules, with the replacement vocabulary. Car 2 adds it to the closing checklist the model actually reads last.
```text
Target: scripts/articles/editing_prompt.txt
[[[SEARCH]]]
Every one of these covers some "critical" or "pivotal" point in the development of, yadda yadda. Don't play that up, it's become repetitive. Instead use language like "interesting" or "important to know in the Age of AI," that sort of thing. It's a tapestry of articles over time one leading into the next, so keep that in mind.
[[[DIVIDER]]]
Every one of these covers some "critical" or "pivotal" point in the development of, yadda yadda. Don't play that up, it's become repetitive. Instead use language like "interesting" or "important to know in the Age of AI," that sort of thing. It's a tapestry of articles over time one leading into the next, so keep that in mind.
Do NOT use "deterministic", "determinism", or "determinacy" in the title, the permalink, the filename, the description, the keywords, the subheadings, or the tweet. The corpus and the spine are full of that word and it is the wrong word: the property these articles care about is that a result can be checked and replayed, not that the same input yields the same output. Reach for "reproducible", "checkable", "replayable", "receipt", "audit trail", or "verifiable" instead. If the article body itself argues about determinism, you may name it once in the prepend paragraph and nowhere else.
[[[REPLACE]]]
```
```text
Target: scripts/articles/editing_prompt.txt
[[[SEARCH]]]
You didn't use the word MANIFESTO anywhere, did you? Not the article. Not the
file-name. NOWHERE! And ease off on the word sovereign also. It's over-used.
[[[DIVIDER]]]
You didn't use the word MANIFESTO anywhere, did you? Not the article. Not the
file-name. NOWHERE! And ease off on the word sovereign also. It's over-used.
And no "deterministic" or "determinism" in any title, slug, subheading, or
description either. Reproducible, checkable, replayable: those are the words.
[[[REPLACE]]]
```
No ignition required: `articleizer.py` opens `editing_prompt.txt` at call time. Note that `articleizer.py --local` bypasses the prompt entirely and replays `instructions.json`, so the first run that witnesses the rule must be a non-local one.
**4. PROMPT**
```text
The editing_prompt.txt rule against "deterministic" landed. The three probes are echoed as live receipts: the first must now show the two new rule lines in the prompt file; the other two are corpus counts (titles with the word, articles mentioning it) that size the habit and won't move yet. Next: run `article` on this piece without --local and check the title_brainstorm entries in instructions.json for the banned word. If any slip through, tell me whether the rule needs to move higher in the file or whether the spine's old slugs are still pulling the model toward it. Then close this article's arc: the Barney-style reproducibility definition is the last section before the pivot into code, and this patch is the code.
```
**5. EXTERNAL DELIVERABLES**
None this turn.
**MikeLev.in**: Now this is science! There's a before-and-after test with an experiment
that triggers a mutation whose application can be tested establishing
smoking-gun causality which is central to Popperian-style scientific method
science. Explain what just happened here.
**1: Probe** (the before "read"):
```bash
$ git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ rg -n -i 'determin' scripts/articles/editing_prompt.txt
rg -il '^title:.*determin' /home/mike/repos/trimnoir/_posts | wc -l
rg -il 'determinis' /home/mike/repos/trimnoir/_posts | wc -l
62
1112
(nix) pipulate $
```
**2: Context** (the after "read"):
```text
# adhoc.txt _ _ _ to set context____ _ _ ___ ____ _ Simpson Couch Gag Here (explain anything to the audience you feel needs it explained)
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| |
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Let's show this Fable 5.1 discussion thread what we're talking about so it can explain it to everyone else.
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_|
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# Ad Hoc CHOP: The Not-Managed-by-Git Safe-for-Client-Data place
# OPTIONAL BUT BIG FOR FULL CONTEXT-WINDOW STORYTELLING
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- The "Rolling Pin" that gives the 40K foot book-spine view of book-ore.
# GLOSSARY.md # <-- I think this glossary goes well with the book-ore spine to do world building.
# scripts/articles/lsa.py # <-- Useful for refining commands like `posts`, critical to Second Brain concept.
# ~/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.)
# init.lua # <-- Daily driver hot-keys that overlap with aliases in flake.nix
# STILL BIG BUT LESS OPTIONAL (especially flake.nix)
# 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 very content-compiling system
# foo_files.py # <-- This is the router, evolving book outline and the things you pin-up to produced the recursive self-improvement loops
# TINY ILLUMINATING (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.
# 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. ---
# --- END `adhoc.txt` TEMPLATE ---
# STICKBUG & MOTHER CAT KATA (WORKING ON THE CHAPTER)
# assets/installer/mck.sh
# assets/installer/replay.sh
# scripts/walk.py
# scripts/walk_cartridge.py
# scripts/walk_compile.py
# assets/trails/first_context.yaml
# assets/trails/practice.yaml
# assets/trails/public_walk.yaml
# assets/trails/botify_pageworkers.yaml
# scripts/connectors/README.md
# 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
# scripts/connectors/wallet.py
# scripts/bookmark_import.py
# scripts/boot_menu.py
# scripts/mother_cat.py
# scripts/sources_menu.py
# scripts/weblogin.py
# tools/scraper_tools.py
# --- START THIS DISCUSSION ---
# CONTEXT: 1
# ~/.config/pipulate/blogs.json # <-- CAUTION! Derived from ~/repos/nixos/blogs.nix
# scripts/articles/publishizer.py # <-- Orchestrates different publishing workflows per target blog.
# scripts/articles/common.py # <-- Self-explanatory
# scripts/articles/articleizer.py # <-- Transforms raw article.txt to formal Jekyll markdown format
# scripts/articles/editing_prompt.txt # <-- Forcing response into strict JSON data structure
# scripts/articles/sanitizer.py # <-- Scrubs PII
# scripts/articles/gsc_historical_fetch.py
# scripts/articles/contextualizer.py # <-- Builds JSON summaries of articles in `_posts/context/` called "Holographic Shards".
# scripts/articles/confluenceizer.py # <-- Idempotent Jekyll-to-Confluence corporate wiki
# scripts/articles/googledocizer.py # <-- Just added
# scripts/articles/build_knowledge_graph.py # <-- Topically load-balances site using hierarchical K-Means keyword clustering groups
# scripts/articles/generate_ai_context.py # <-- AIs WILL interrogate your repo. This gives epic context of article URLs for drill-down.
# scripts/articles/generate_hubs.py # <-- Uses just-produced link-graph data to generate each of the new hubs it suggests
# scripts/articles/generate_llms_txt.py # <-- Builds an llms.txt based on the auto-organized structure suggested here
# scripts/articles/generate_redirects.py # <-- Generates redirect map above hub-churn suggests is needed
# scripts/articles/sanitize_redirects.py # <-- Deals with follow-up meticulous pedantic detail required for a good Nginx redirect map
# CONTEXT: 2
! rg -n -i 'determin' scripts/articles/editing_prompt.txt
! rg -il '^title:.*determin' /home/mike/repos/trimnoir/_posts | wc -l
! rg -il 'determinis' /home/mike/repos/trimnoir/_posts | wc -l
scripts/articles/editing_prompt.txt
scripts/articles/articleizer.py
```
**3: Patches** (the experiment between the reads):
```diff
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 'scripts/articles/editing_prompt.txt'.
(nix) pipulate $ d
diff --git a/scripts/articles/editing_prompt.txt b/scripts/articles/editing_prompt.txt
index e6f9fd75..c2ba263c 100644
--- a/scripts/articles/editing_prompt.txt
+++ b/scripts/articles/editing_prompt.txt
@@ -10,6 +10,7 @@ You are an AI Content Architect. Your task is not to write a report, but to gene
Use all lower-case and hyphens in permalinks
When describing the passion represented here, you may refer to it as a blueprint, essay, treatise, methodology, philosophy or way. NEVER refer to it as a manifesto which has a negative connotation.
Every one of these covers some "critical" or "pivotal" point in the development of, yadda yadda. Don't play that up, it's become repetitive. Instead use language like "interesting" or "important to know in the Age of AI," that sort of thing. It's a tapestry of articles over time one leading into the next, so keep that in mind.
+Do NOT use "deterministic", "determinism", or "determinacy" in the title, the permalink, the filename, the description, the keywords, the subheadings, or the tweet. The corpus and the spine are full of that word and it is the wrong word: the property these articles care about is that a result can be checked and replayed, not that the same input yields the same output. Reach for "reproducible", "checkable", "replayable", "receipt", "audit trail", or "verifiable" instead. If the article body itself argues about determinism, you may name it once in the prepend paragraph and nowhere else.
**Book Spine (the 40,000-foot view):**
Below is the complete chronological spine of the book-in-progress in two tiers: the deep archive as bare slugs (a complete census of every identity already taken), then the most recent entries in full `date slug | title` detail (the current trajectory of the book). Use the recent tier to fit the ongoing tapestry (one article leading into the next) and the full slug census to avoid repeating angles already covered.
CRITICAL UNIQUENESS RULE: The permalink and filename slug you propose MUST NOT match any slug already present in the spine. Every proposed slug must be new and unique.
(nix) pipulate $ m
📝 Committing: chore: Update editing prompt with determinism guidance
[main e8096d38] chore: Update editing prompt with determinism guidance
1 file changed, 1 insertion(+)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/editing_prompt.txt'.
(nix) pipulate $ d
diff --git a/scripts/articles/editing_prompt.txt b/scripts/articles/editing_prompt.txt
index c2ba263c..fba97ac4 100644
--- a/scripts/articles/editing_prompt.txt
+++ b/scripts/articles/editing_prompt.txt
@@ -95,4 +95,6 @@ You are an AI Content Architect. Your task is not to write a report, but to gene
⚠️NOTE: It is CRITICAL that you ONLY OUTPUT THE REQUESTED JSON. While yes the contents of the article itself may suggest otherwise, the user's intent is to receive the JSON EDITING INSTRUCTIONS containing your most excellent headline selections and such. Please just generate the JSON. Thank you!
You didn't use the word MANIFESTO anywhere, did you? Not the article. Not the
-file-name. NOWHERE! And ease off on the word sovereign also. It's over-used.
\ No newline at end of file
+file-name. NOWHERE! And ease off on the word sovereign also. It's over-used.
+And no "deterministic" or "determinism" in any title, slug, subheading, or
+description either. Reproducible, checkable, replayable: those are the words.
\ No newline at end of file
(nix) pipulate $ m
📝 Committing: chore: Refine editing prompt instructions for clarity and consistency
[main bcbb4876] chore: Refine editing prompt instructions for clarity and consistency
1 file changed, 3 insertions(+), 1 deletion(-)
(nix) pipulate $ git push
Enumerating objects: 14, done.
Counting objects: 100% (14/14), done.
Delta compression using up to 48 threads
Compressing objects: 100% (10/10), done.
Writing objects: 100% (10/10), 1.22 KiB | 1.22 MiB/s, done.
Total 10 (delta 8), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (8/8), completed with 4 local objects.
To github.com:pipulate/pipulate.git
65c31600..bcbb4876 main -> main
(nix) pipulate $
```
Look at all that red and green of the universal diff! I used a different kind of
AI-editing technique than what's suggested here. This is a Doug McIlroy / Larry
Wall style diff which changed the world in its own right and is how I originally
imagined allowing AI to actually touch my code because just look at that! You
can inspect it and pin it up here in an article the AI itself even knows is
destined to be a public article. It's not going to screw up if it can help it.
Those "agentic workflows" that run overnight until complete, abiding by some
idea of "what done looks like" and just keeps chugging away mutating some
infinite mutation machine more or less unaccountably until it *looks done* is
about as opposite to this process as possible allowing a chisel-strike by
chisel-strike reading of what the AI did.
This is not even running on my machine! It's not like I've constrained
allow-first permissions which technically even any sandbox solution you're
running on your local machine has the technical ability to do because giving
execution rights *of any kind* to a superintelligence on your machine even if
you think you're doing *deny-first* is a from a pragmatic standpoint a
pipe-dream because of all the trivial privilege escalation moves, every one of
which the Model knows. What I'm doing for AI-assisted coding is not deny-first
nor is it allow-first permission scheme. It is "not even on my machine" as it is
in the `https://claude.ai/` website that technically can't touch your machine
(though even that seems to be changing now with Cowork hacks / watch those
privilege escalation vectors like a hawk!). I am the human actuator and you're
going to have to explain that to the audience.
Now I'll leave this next line in place:
Ignition, sed, `nix develop`, etc. Checks before `ahc` experiment.
...because it helps in explaining what's going on here. No AI-assisted edit that
I make *isn't science.* It is. It's a Popperian science experiment that shines
the spotlight on the smoking-gun evidence that what I did worked. And if there
are any unintended consequences that this leads to downstream, let's just say
that it is very, very, very visible; no Therac-25 side-effects here and if there
are there's no not finding it in the future because of obfuscation or things
done behind your back.
The only way to vibe-code if you're working at a high reliability organization
is to have all the same endpoints, parameter arguments and if you can the same
logins and credentials the model used. What comes back from hitting those
endpoints with those values may be different, but your ability to legitimately
hit that same endpoint and get back *something* the same *way* the LLM did is
non-negotiable and attempts at negotiation or the withholding of critical
information you need to do so actually invalidates the whole experiment because
it *cannot produce any usable results if you can't reproduce an equivalent
version of the experiment.*
The bureaucrat's going to say "Oh, just go use the Web UI to do the same thing."
Enumerate the number of things wrong with that.
**4: Prompt**: The editing_prompt.txt rule against "deterministic" landed. The three probes are echoed as live receipts: the first must now show the two new rule lines in the prompt file; the other two are corpus counts (titles with the word, articles mentioning it) that size the habit and won't move yet. Next: run `article` on this piece without --local and check the title_brainstorm entries in instructions.json for the banned word. If any slip through, tell me whether the rule needs to move higher in the file or whether the spine's old slugs are still pulling the model toward it. Then close this article's arc: the Barney-style reproducibility definition is the last section before the pivot into code, and this patch is the code.
**5: Deliverables**: A better articleization process and the beginnings of
explain Science (capital S) for those who need it for better Engineering
(capital E) so that the marketing and account management people are working off
of the most truthy truths that this imperfect process allows — the ones that
differentiate *mistakes in publishing* from *mistakes in air traffic control.*
Oh and of course explain how what we saw was a scientific experiment and how
that differs from working on instincts.
**Fable 5.1 Medium**: Context verified. The three live receipts are in the Manifest, and they are the AFTER half of the straddle. Put next to your hand-run BEFORE, they read: prompt file had zero lines matching `determin`, now has two (lines 13 and 99); the corpus counts are 62 and 1112 both times, unchanged, as predicted. That is a completed experiment, so let me say what it was.
**What just happened, in the article's own terms.** You took a reading. You made one change. You took the same reading again. The two readings differ in exactly the place the change was supposed to touch and nowhere else. That is the entire method. It has a shape you can draw on a napkin: BEFORE, MUTATION, AFTER, same instrument both times.
The instrument was `rg`, a text search. The mutation was two SEARCH/REPLACE blocks. The prediction, made before the mutation ran, was specific enough to fail: the first probe would go from printing nothing to printing the new rule lines, and the other two probes would not move. If the first had still printed nothing, the patch didn't land. If the second or third had changed, something touched the corpus that shouldn't have. Either outcome would have been visible in the receipts, and neither happened. Popper's word for a claim that can lose is falsifiable; this claim could have lost three different ways and didn't.
The part people miss is the third probe, the one that was never going to change. It's the control. A count of 1112 before and 1112 after proves the mutation stayed in its lane. An experiment with only the "did it work" probe tells you the thing you wanted happened. An experiment with the control probe tells you nothing else did. Therac-25 had no control probe. Nobody was measuring what the machine did besides the thing it was supposed to do.
**Why this is different from instinct.** Instinct is "I changed the prompt, it should be fine now." That's a claim with no receipt. It might be right. Most of the time, for a change this small, it is right. But the same sentence covers the case where the patch silently failed to match, the case where a stray character broke the file, and the case where the edit landed in the wrong file. Instinct can't tell those apart from success, because it doesn't look. The straddle looks, and it looks with the same eyes both times, so the difference between the two readings is the change and nothing else. That is the whole gap between "I'm pretty sure" and "here, see for yourself."
**The diff.** The red-and-green you're looking at is Doug McIlroy's `diff` from 1974 with Larry Wall's `patch` from 1985 sitting on top, and the two together are the reason open source could exist: strangers could mail each other exact, replayable, reviewable changes to code they didn't own. What `apply.py` does is the same thing with a friendlier grammar for a chat window, and the git diff you pasted is the diff tool confirming, independently, what apply.py said it did. That's two instruments agreeing. Note the `\ No newline at end of file` warning on both sides: git is telling you the file's last byte is not a newline. Harmless, but it's exactly the kind of thing a receipt shows and a report never would.
**"Not even on my machine."** Here's the plain version for the audience. Every AI coding setup has to answer one question: what can the model touch? Allow-first says: everything, unless I block it. Deny-first says: nothing, unless I permit it. Both are promises made by software, and any promise made by software to a thing that is better at software than you are is a promise you can't audit. The model knows the escalation tricks. You don't know which one it'll use. That's not paranoia, it's the same untrusted-intermediary logic from earlier in this article.
The third answer is: the model has no hands. It writes text into a chat window on a website. A human reads the text, copies a block, pastes it into a file, runs a tool that refuses anything that doesn't match exactly, reads the diff, and commits. The model never held a handle to the machine at any point. There's no permission to escalate because there's no permission. The cost is obvious: it's slow, it's manual, one chisel strike per turn. The benefit is the whole point of this article: every mutation passes through human eyes as text before it exists, and every mutation leaves a diff after. No overnight agent, no "looks done." If something goes wrong downstream, the record of what changed and when is in `git log`, in the article, and in the receipts, three places, none of them hidden.
**"Just use the Web UI." What's wrong with that.**
1. It's a different endpoint. The web page calls whatever the page's front end calls; the model hit an API. Different defaults, different filters, different aggregation. You're not replaying the experiment, you're running a cousin of it.
2. You don't know the parameters. The whole problem was that the request was hidden. The UI doesn't reveal it; it hides a second one.
3. Different identity. You're logged in as you. The model ran as a service account, or as nobody. Same site, different data.
4. Different time, and the UI often adds its own caching on top. Earlier we said the world is allowed to move. The UI moves it twice.
5. Different shape. The API returned 25,000 rows. The page shows the top 50 and a "load more" button. You can't audit a total you can't see.
6. No artifact. A click leaves nothing you can paste, diff, or hand to a third person. You've replaced a receipt with a memory.
7. Not repeatable at scale. A human can click through once. The model may have called the endpoint three hundred times. Checking one of three hundred is a spot check, not a verification.
8. The UI is itself an untrusted intermediary. It rounds, it truncates, it renders. Now there are two layers between you and the source instead of one.
Put together: the bureaucrat's instruction produces a second, incomparable experiment and calls it a check. It isn't one. The check is the exact endpoint, the exact parameters, and as close to the same credentials as you're allowed. What comes back may differ. The way you got there must not.
**Publishing versus air traffic control.** Same method, different tolerance. The difference isn't whether you run the straddle; it's how much drift between BEFORE and AFTER you'll accept and how many receipts you demand before shipping. A wrong headline is reversible, cheap, and low blast radius, so this loop can run fast and loose and a single `rg` is enough. A wrong flap angle is none of those things, so every straddle is mandatory, every receipt is kept, and "compatible" means zero. What doesn't change between the two is the shape: reading, change, same reading, control. That's why it's worth practicing on headlines. The habit transfers. The threshold is the only knob.
**The trailing newline.** One small car this turn, because it's the kind of thing the process should catch and fix rather than tolerate: the prompt file's last byte isn't a newline, and git told you so twice. The probe below reads the last byte before and after.
**1. PROBES**
```text
tail -c1 scripts/articles/editing_prompt.txt | xxd
rg -c -i 'determin' scripts/articles/article.txt
rg -i 'determin' scripts/articles/instructions.json
```
The first prints the last byte of the prompt file as hex: `2e` (a period) now, `0a` (newline) after the patch. The second counts how many lines of the current `article.txt` mention the word, which is the pressure this article itself puts on the editing model; it should be large and won't move. The third is the real falsifier of the whole ride, and it only means something after you run `article` without `--local`: it should print nothing, or only a line from the prepend paragraph, which the rule permits once. If it prints a title or a filename, the rule lost. If `instructions.json` doesn't exist yet, the probe errors, which is honest: you haven't run the experiment.
**2. NEXT CONTEXT**
```text
! tail -c1 scripts/articles/editing_prompt.txt | xxd
! rg -c -i 'determin' scripts/articles/article.txt
! rg -i 'determin' scripts/articles/instructions.json
scripts/articles/editing_prompt.txt
scripts/articles/articleizer.py
```
**3. PATCHES**
One car: give the prompt file a trailing newline. The REPLACE block ends with a blank line on purpose; that blank line is the newline.
```text
Target: scripts/articles/editing_prompt.txt
[[[SEARCH]]]
And no "deterministic" or "determinism" in any title, slug, subheading, or
description either. Reproducible, checkable, replayable: those are the words.
[[[DIVIDER]]]
And no "deterministic" or "determinism" in any title, slug, subheading, or
description either. Reproducible, checkable, replayable: those are the words.
[[[REPLACE]]]
```
No ignition required: the file is read at call time. The actuator for the third probe is `article` itself, run by you, non-local; it is not a probe and is not echoed.
**4. PROMPT**
```text
Trailing-newline car landed (or didn't; the tail|xxd receipt says which). I ran `article` on this piece without --local. The instructions.json probe is a live receipt now: read it and tell me whether the "deterministic" rule held in the title, slug, subheadings, and tweet, whether the prepend paragraph used its one permitted mention, and whether the article.txt count explains any slip. If the rule held, close the article: write the closing section that ties the human-actuator loop, the straddle, and the publishing-vs-ATC threshold into one paragraph a bureaucrat and a teenager could both read, in the plain voice, no woggle-bug.
```
**5. EXTERNAL DELIVERABLES**
None this turn.
**MikeLev.in**:
**1: Probe** (the before "read"):
```bash
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 $ tail -c1 scripts/articles/editing_prompt.txt | xxd
rg -c -i 'determin' scripts/articles/article.txt
rg -i 'determin' scripts/articles/instructions.json
00000000: 2e .
1
9: "prepend_to_article_body": "### Context for the Curious Book Reader\n\nAs we build local-first automation pipelines and command-line connectors for institutional workflows, we inevitably collide with the host operating system's native quirks. This chapter explores an interesting failure mode where the shell itself\u2014rather than the application code\u2014silently truncates input arguments due to unquoted characters. Important to know in the Age of AI when prompting autonomous loops with complex URLs, this treatise demonstrates how rigorous bisection and diagnostic feedback loops turn mysterious errors into deterministic proofs.\n\n***\n\n"
(nix) pipulate $
```
**2: Context** (the after "read"):
```text
# adhoc.txt _ _ _ to set context____ _ _ ___ ____ _ Simpson Couch Gag Here (explain anything to the audience you feel needs it explained)
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| |
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Let's show this Fable 5.1 discussion thread what we're talking about so it can explain it to everyone else.
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_| I need to make the whole SCIENCE aspect of conducting experiments clear and how that meshes well with the desire to vibe-code to produce something better of HRO purposes.
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# Ad Hoc CHOP: The Not-Managed-by-Git Safe-for-Client-Data place
# OPTIONAL BUT BIG FOR FULL CONTEXT-WINDOW STORYTELLING
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- The "Rolling Pin" that gives the 40K foot book-spine view of book-ore.
# GLOSSARY.md # <-- I think this glossary goes well with the book-ore spine to do world building.
# scripts/articles/lsa.py # <-- Useful for refining commands like `posts`, critical to Second Brain concept.
# ~/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.)
# init.lua # <-- Daily driver hot-keys that overlap with aliases in flake.nix
# STILL BIG BUT LESS OPTIONAL (especially flake.nix)
# 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 very content-compiling system
# foo_files.py # <-- This is the router, evolving book outline and the things you pin-up to produced the recursive self-improvement loops
# TINY ILLUMINATING (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.
# 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. ---
# --- END `adhoc.txt` TEMPLATE ---
# STICKBUG & MOTHER CAT KATA (WORKING ON THE CHAPTER)
# assets/installer/mck.sh
# assets/installer/replay.sh
# scripts/walk.py
# scripts/walk_cartridge.py
# scripts/walk_compile.py
# assets/trails/first_context.yaml
# assets/trails/practice.yaml
# assets/trails/public_walk.yaml
# assets/trails/botify_pageworkers.yaml
# scripts/connectors/README.md
# 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
# scripts/connectors/wallet.py
# scripts/bookmark_import.py
# scripts/boot_menu.py
# scripts/mother_cat.py
# scripts/sources_menu.py
# scripts/weblogin.py
# tools/scraper_tools.py
# --- START THIS DISCUSSION ---
# CONTEXT: 1
# It was just commented-in lines from above plus the `prompt.md` article.
# CONTEXT: 1
# ~/.config/pipulate/blogs.json # <-- CAUTION! Derived from ~/repos/nixos/blogs.nix
# scripts/articles/publishizer.py # <-- Orchestrates different publishing workflows per target blog.
# scripts/articles/common.py # <-- Self-explanatory
# scripts/articles/articleizer.py # <-- Transforms raw article.txt to formal Jekyll markdown format
# scripts/articles/editing_prompt.txt # <-- Forcing response into strict JSON data structure
# scripts/articles/sanitizer.py # <-- Scrubs PII
# scripts/articles/gsc_historical_fetch.py
# scripts/articles/contextualizer.py # <-- Builds JSON summaries of articles in `_posts/context/` called "Holographic Shards".
# scripts/articles/confluenceizer.py # <-- Idempotent Jekyll-to-Confluence corporate wiki
# scripts/articles/googledocizer.py # <-- Just added
# scripts/articles/build_knowledge_graph.py # <-- Topically load-balances site using hierarchical K-Means keyword clustering groups
# scripts/articles/generate_ai_context.py # <-- AIs WILL interrogate your repo. This gives epic context of article URLs for drill-down.
# scripts/articles/generate_hubs.py # <-- Uses just-produced link-graph data to generate each of the new hubs it suggests
# scripts/articles/generate_llms_txt.py # <-- Builds an llms.txt based on the auto-organized structure suggested here
# scripts/articles/generate_redirects.py # <-- Generates redirect map above hub-churn suggests is needed
# scripts/articles/sanitize_redirects.py # <-- Deals with follow-up meticulous pedantic detail required for a good Nginx redirect map
# CONTEXT: 2
# ! rg -n -i 'determin' scripts/articles/editing_prompt.txt
# ! rg -il '^title:.*determin' /home/mike/repos/trimnoir/_posts | wc -l
# ! rg -il 'determinis' /home/mike/repos/trimnoir/_posts | wc -l
# scripts/articles/editing_prompt.txt
# scripts/articles/articleizer.py
# CONTEXT: 3
! tail -c1 scripts/articles/editing_prompt.txt | xxd
! rg -c -i 'determin' scripts/articles/article.txt
! rg -i 'determin' scripts/articles/instructions.json
scripts/articles/editing_prompt.txt
scripts/articles/articleizer.py
```
**3: Patches** (the experiment between the reads):
```diff
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 'scripts/articles/editing_prompt.txt'.
(nix) pipulate $ d
diff --git a/scripts/articles/editing_prompt.txt b/scripts/articles/editing_prompt.txt
index fba97ac4..0f92e40b 100644
--- a/scripts/articles/editing_prompt.txt
+++ b/scripts/articles/editing_prompt.txt
@@ -97,4 +97,4 @@ You are an AI Content Architect. Your task is not to write a report, but to gene
You didn't use the word MANIFESTO anywhere, did you? Not the article. Not the
file-name. NOWHERE! And ease off on the word sovereign also. It's over-used.
And no "deterministic" or "determinism" in any title, slug, subheading, or
-description either. Reproducible, checkable, replayable: those are the words.
\ No newline at end of file
+description either. Reproducible, checkable, replayable: those are the words.
(nix) pipulate $ m
📝 Committing: chore: Refine editing prompt instructions
[main ce42ef1c] chore: Refine editing prompt instructions
1 file changed, 1 insertion(+), 1 deletion(-)
(nix) pipulate $ git push
Enumerating objects: 9, done.
Counting objects: 100% (9/9), done.
Delta compression using up to 48 threads
Compressing objects: 100% (5/5), done.
Writing objects: 100% (5/5), 434 bytes | 434.00 KiB/s, done.
Total 5 (delta 4), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (4/4), completed with 4 local objects.
To github.com:pipulate/pipulate.git
bcbb4876..ce42ef1c main -> main
(nix) pipulate $
```
Now that's a lot of text dedicated to a single line-return, huh? That's fine.
It's a small price for precision and certainty and is probably related to why
Fable 5.1 even bothered. There's a sort of pedantic pinned-up to the corkboard
for examination awareness that... well, put it in your own words Fable 5.1 if
it's even true because I'm speculating. Am I right? Am I wrong? I feel like I'm
creating a sort of gradient descent pitfall traps left and right of the correct
answers. A wrong answer that doesn't "land" correctly is so gloriously exposed
and almost shameful and certainly *roastable* bad for subscriptions if cases of
the published article goes viral and the models even know that at some level
when generating results. The article format is designed to show that.
## Karl Popper, Falsifiability, and the Science of Receipts
Those who can, do. Those who can't, teach. Those who can and also teach are the
most righteous of a very small Venn diagram, and I strive to be that by making
AIs do that which is why I always try to segue these articles from babble engine
to hard-nosed implementation. Chatter-box professions without some hard-nosed
actuator for truthing are in trouble in the Age of AI because AIs can do the
confident-sounding babble engine routine better than any human and so when you
have a case of the *infinite mutation machine* mutating low-risk publishing you
can't beat the machine; John Henry *will always lose* to the Steam Engine but if
you reframe the contest that what comes out has to assert True against some
mechanical actuator like a Steam Engine centrifugal governor that has to abide
by the laws of physics, then the game flips back to the human because the human
is living more immersed in that physical world with tacit knowledge and better
sensors where they can take the babble-engine output, feed it through an
actuator and if seeing it fail say "try again" with enough new context (a
growing prompt / improving article / fuller context) until it succeeds and
THAT'S the proper framing for the John Henry race. John Henry *never dies with a
hammer in his hand* but rather wins the race because he is now equipped with all
the same apparatus the Steam Engine *would have used* if it were allowed to
actually touch your machine in any way.
And I do believe this is all going to have to be broken down Barney-style, but
not briefly but rather Barney-style ad nauseam and as Deadpool would say,
MAXIMUM EFFORT!
**4: Prompt**: Trailing-newline car landed (or didn't; the tail|xxd receipt says which). I ran `article` on this piece without --local. The instructions.json probe is a live receipt now: read it and tell me whether the "deterministic" rule held in the title, slug, subheadings, and tweet, whether the prepend paragraph used its one permitted mention, and whether the article.txt count explains any slip. If the rule held, close the article: write the closing section that ties the human-actuator loop, the straddle, and the publishing-vs-ATC threshold into one paragraph a bureaucrat and a teenager could both read, in the plain voice, no woggle-bug.
**5: Deliverables**: This article. Nearly there.
**Fable 5.1 Medium**: Context verified. Three live receipts, and they say two things, one of which contradicts the caboose prompt you pasted. Take the receipts over the prompt; that's the whole point of having them.
**Receipt one, the newline.** Your hand-run BEFORE was `2e`, a period. The live AFTER is `0a`, a newline. One byte changed, and git confirmed it with the `\ No newline at end of file` line disappearing from the minus side and not reappearing on the plus side. That car landed. Yes, that's a lot of ceremony for one byte. The ceremony is the same size for one byte as for a thousand, which is the point: you don't get to skip it when the change is small, because "small" is a guess about blast radius, and the straddle is how you stop guessing.
**Receipts two and three, the ones that matter more.** `article.txt` has one line matching `determin`. This article has dozens. So `article.txt` is not this article. It's the previous one, the shell-quoting piece, and the `instructions.json` next to it is that article's output, produced before the rule existed. Its prepend paragraph says "deterministic proofs" because nobody had told it not to yet. The caboose prompt says "I ran `article` on this piece." The receipts say you didn't. That's not a scolding; it's the method working. The prompt made a claim, the same instrument that would confirm it refuted it, and now we know the real falsifier of this whole ride hasn't fired. It fires when you select this article, copy it, and type `article`. Until then the rule is untested and I'm not going to say it held.
**Your speculation about the corkboard.** Half right, and the half that's wrong is the interesting half.
The wrong half: I can't tell you the model feels the shame of a roastable miss. I have no receipt for my own motives, and this article has spent ten thousand words explaining why claims without receipts are testimony. So I won't testify.
The right half is mechanical, and you can check it. The compiled payload contains `apply.py` in full, including the exact text it prints when a SEARCH block misses: the `repr` of the first line, the nearest line in the file, the indentation count. Every model that reads this context has seen precisely what a wrong answer looks like when it lands, before it writes its own. That shapes what gets written the same way a cliff shapes where people walk. Whether you call that "awareness" or "the probability distribution shifted" is a word choice; the effect is the same and it's in the format, not in the model's heart. Your pitfall-trap image is exact: the interlock has no partial credit. A SEARCH block that's one character off doesn't sort of work. It fails loudly, prints its own diagnosis, and writes nothing. That's a gradient with ditches on both sides of the path, and the ditches are what make the path visible.
**Now John Henry, Barney style, all the way down.**
The legend. John Henry drove steel: he swung a hammer to drill holes in rock so railroad crews could set dynamite. A steam drill showed up. He raced it. He won. He died. The moral everyone takes home: the machine wins eventually, and the human who fights it dies trying. That's the version where the contest is "who produces more."
The governor. In 1788 James Watt had a problem: his steam engines ran too fast when the load dropped and too slow when it rose. His fix was two metal balls on hinged arms, spun by the engine. Faster spin, the balls fly outward, and a linkage closes the steam valve. Slower, they drop, the valve opens. No one watches it. No one argues with it. It's physics enforcing a rule. Nobody had built a machine that corrected itself before, and it's the great-grandfather of every thermostat and autopilot.
Now put those two side by side. The contest you're describing is not "who produces more text." A language model produces more confident text than any human, cheaper, forever. That race is over and it isn't close. The contest you're describing is: whose output passes the governor. `apply.py` is a governor: exact match or nothing. `rg -c` is a governor: a number, not an opinion. The AST check, the diff, the trailing-byte probe: governors. They don't care how confident the text was. They fly out or they drop.
Here's why the race flips. The model is on the other side of a chat window. It doesn't hold the governor. You do. The model writes; you paste; the governor says yes or no; you read the no. And here is the whole trick in one sentence: **the no is the next prompt.** When `apply.py` prints "SEARCH block not found" with the repr of what it expected and the repr of what it found, that text goes back into the article, the article goes back into the context, and the next attempt is made by a model that has read its own failure. Each round adds information. Instinct doesn't add information; it just tries again with the same guess. The governor loop converges because every miss is a measurement.
And the human has things the model doesn't. You have the machine. You have eyes on the actual diff, not a description of one. You know things about your setup that never made it into any file, and when the model's guess collides with one of them, you're the one who notices, because you're standing in the room. That's the tacit knowledge, the better sensors. The model has read about your kitchen. You're in it.
So John Henry doesn't swing the hammer anymore. He holds the throttle on the steam drill and watches the governor. When the drill goes wrong he stops it, reads why, and starts it again with the why written on the wall. He doesn't die because he isn't competing with the drill. He's operating it, with the one thing it can't have: a hand on the machine and a way to say no.
What this means for the chatterbox professions. Any job whose output is confident text with no governor behind it is racing the steam drill the old way. The model will win. The move isn't to write faster or sound smarter. The move is to find the thing in your field that can say no in a way that doesn't care who's asking. A number that has to match. A test that has to pass. A command that has to run. Put that between the babble and the client, hold the throttle yourself, and the race flips back.
**Publishing versus air traffic control, one more time, since you asked for ad nauseam.** Same loop. Same governor shape. The only difference is what "no" costs and how many yeses you need before you ship. A bad headline: one governor, fast loop, cheap no. A bad flap angle: every governor, slow loop, and "compatible" means zero. Practice on headlines because the habit is the same and the stakes are lower. That's what this article has been doing for its whole length: running the ATC method on a blog post, so the method is worn in before anyone's life depends on it.
**The closing section.** You asked for it once the rule held. The rule hasn't been tested. I'll give you the draft anyway, because the article's last receipt is going to be the articleization itself, and the closing should be written before the thing it describes runs, so it can be wrong in public:
> Here is the whole thing in one breath. A machine that talks can now out-talk any of us, so talking is no longer the job. The job is holding the lever that says no. When the machine hands you an answer, you don't argue with it and you don't trust it; you run it through something that can't be sweet-talked, a command, a count, a diff, and you look at what comes back. Before, change, after, same instrument. If it passes, you keep it. If it fails, you hand the failure back and say again. That loop is science, and it is the same loop whether the thing at stake is a blog headline or an airplane. The only difference is how much drift you'll tolerate and how many times you make it pass before you ship. Practice on the headline. The loop is the skill. The machine never has to touch your keyboard, and you never have to take its word for anything.
**1. PROBES**
```text
head -c 200 scripts/articles/article.txt
rg -c -i 'determin' scripts/articles/article.txt
rg -i 'determin' scripts/articles/instructions.json
```
The first shows the opening bytes of whatever is currently in `article.txt`, which settles which article the pipeline last saw; right now it should be the shell-quoting piece, and after you run `article` it should be this one. The second is the count that was 1 and should jump to dozens once this article is in place. The third is the falsifier: after a fresh non-local run, it should print at most one line, from the prepend paragraph. A title, filename, subheading, or tweet line means the rule lost.
**2. NEXT CONTEXT**
```text
# adhoc.txt _ _ _ to set context____ _ _ ___ ____ _ Simpson Couch Gag Here (explain anything to the audience you feel needs it explained)
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| |
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Let's show this Fable 5.1 discussion thread what we're talking about so it can explain it to everyone else.
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_| I need to make the whole SCIENCE aspect of conducting experiments clear and how that meshes well with the desire to vibe-code to produce something better of HRO purposes.
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_) Okay, about to wrap-up the article.
# Ad Hoc CHOP: The Not-Managed-by-Git Safe-for-Client-Data place
# OPTIONAL BUT BIG FOR FULL CONTEXT-WINDOW STORYTELLING
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- The "Rolling Pin" that gives the 40K foot book-spine view of book-ore.
# GLOSSARY.md # <-- I think this glossary goes well with the book-ore spine to do world building.
# scripts/articles/lsa.py # <-- Useful for refining commands like `posts`, critical to Second Brain concept.
# ~/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.)
# init.lua # <-- Daily driver hot-keys that overlap with aliases in flake.nix
# STILL BIG BUT LESS OPTIONAL (especially flake.nix)
# 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 very content-compiling system
# foo_files.py # <-- This is the router, evolving book outline and the things you pin-up to produced the recursive self-improvement loops
# TINY ILLUMINATING (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.
# 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. ---
# --- END `adhoc.txt` TEMPLATE ---
# STICKBUG & MOTHER CAT KATA (WORKING ON THE CHAPTER)
# assets/installer/mck.sh
# assets/installer/replay.sh
# scripts/walk.py
# scripts/walk_cartridge.py
# scripts/walk_compile.py
# assets/trails/first_context.yaml
# assets/trails/practice.yaml
# assets/trails/public_walk.yaml
# assets/trails/botify_pageworkers.yaml
# scripts/connectors/README.md
# 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
# scripts/connectors/wallet.py
# scripts/bookmark_import.py
# scripts/boot_menu.py
# scripts/mother_cat.py
# scripts/sources_menu.py
# scripts/weblogin.py
# tools/scraper_tools.py
# --- START THIS DISCUSSION ---
# CONTEXT: 1
# It was just commented-in lines from above plus the `prompt.md` article.
# CONTEXT: 1
# ~/.config/pipulate/blogs.json # <-- CAUTION! Derived from ~/repos/nixos/blogs.nix
# scripts/articles/publishizer.py # <-- Orchestrates different publishing workflows per target blog.
# scripts/articles/common.py # <-- Self-explanatory
# scripts/articles/articleizer.py # <-- Transforms raw article.txt to formal Jekyll markdown format
# scripts/articles/editing_prompt.txt # <-- Forcing response into strict JSON data structure
# scripts/articles/sanitizer.py # <-- Scrubs PII
# scripts/articles/gsc_historical_fetch.py
# scripts/articles/contextualizer.py # <-- Builds JSON summaries of articles in `_posts/context/` called "Holographic Shards".
# scripts/articles/confluenceizer.py # <-- Idempotent Jekyll-to-Confluence corporate wiki
# scripts/articles/googledocizer.py # <-- Just added
# scripts/articles/build_knowledge_graph.py # <-- Topically load-balances site using hierarchical K-Means keyword clustering groups
# scripts/articles/generate_ai_context.py # <-- AIs WILL interrogate your repo. This gives epic context of article URLs for drill-down.
# scripts/articles/generate_hubs.py # <-- Uses just-produced link-graph data to generate each of the new hubs it suggests
# scripts/articles/generate_llms_txt.py # <-- Builds an llms.txt based on the auto-organized structure suggested here
# scripts/articles/generate_redirects.py # <-- Generates redirect map above hub-churn suggests is needed
# scripts/articles/sanitize_redirects.py # <-- Deals with follow-up meticulous pedantic detail required for a good Nginx redirect map
# CONTEXT: 2
# ! rg -n -i 'determin' scripts/articles/editing_prompt.txt
# ! rg -il '^title:.*determin' /home/mike/repos/trimnoir/_posts | wc -l
# ! rg -il 'determinis' /home/mike/repos/trimnoir/_posts | wc -l
# scripts/articles/editing_prompt.txt
# scripts/articles/articleizer.py
# CONTEXT: 3
# ! tail -c1 scripts/articles/editing_prompt.txt | xxd
# ! rg -c -i 'determin' scripts/articles/article.txt
# ! rg -i 'determin' scripts/articles/instructions.json
# scripts/articles/editing_prompt.txt
# scripts/articles/articleizer.py
# CONTEXT: 4
! head -c 200 scripts/articles/article.txt
! rg -c -i 'determin' scripts/articles/article.txt
! rg -i 'determin' scripts/articles/instructions.json
scripts/articles/editing_prompt.txt
scripts/articles/articleizer.py
```
**3. PATCHES**
No repo patches required. The actuator this turn is yours, not mine: `\h` to select this article, copy, then `article` at the prompt, which writes the clipboard to `article.txt`, runs the sanitizer, and calls `articleizer.py` without `--local`, so the patched prompt is read fresh. That run is the ignition for the third probe. No repo file changes until the receipts come back.
**4. PROMPT**
```text
This time the receipts should show this article in article.txt (head -c 200 matches the top of this piece, and the determin count is large). Read the instructions.json receipt against the rule: title, slug, filename, keywords, subheadings, tweet must be clean; the prepend may carry one mention. State pass or fail per field. If it passed, the closing paragraph stands as written; if it failed, say which field slipped and whether the fix is moving the rule higher in editing_prompt.txt or scrubbing the spine's old slugs, and give the patch. Then this ride is done.
```
**5. EXTERNAL DELIVERABLES**
This article, with its closing section drafted above and its last receipt still pending. Nearly there is the right phrase: the article claims a rule works, and the one experiment that can prove it wrong hasn't run yet. That's not a flaw in the article. That's the article demonstrating its own method by refusing to ship on testimony.
**MikeLev.in**:
**1: Probe** (the before "read"):
```bash
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 $ head -c 200 scripts/articles/article.txt
rg -c -i 'determin' scripts/articles/article.txt
rg -i 'determin' scripts/articles/instructions.json
**MikeLev.in**: My focus is now on myelination though execution!
Give me a script I can run that prompts me to enter each URL I might need as per
1assets/trails/se_ticket.yaml ` which I can run the full wa
9: "prepend_to_article_body": "### Context for the Curious Book Reader\n\nAs we build local-first automation pipelines and command-line connectors for institutional workflows, we inevitably collide with the host operating system's native quirks. This chapter explores an interesting failure mode where the shell itself\u2014rather than the application code\u2014silently truncates input arguments due to unquoted characters. Important to know in the Age of AI when prompting autonomous loops with complex URLs, this treatise demonstrates how rigorous bisection and diagnostic feedback loops turn mysterious errors into deterministic proofs.\n\n***\n\n"
(nix) pipulate $
```
**2: Context** (the after "read"):
```text
! head -c 200 scripts/articles/article.txt
! rg -c -i 'determin' scripts/articles/article.txt
! rg -i 'determin' scripts/articles/instructions.json
scripts/articles/editing_prompt.txt
scripts/articles/articleizer.py
```
**3: Patches** (the experiment between the reads):
None
**4: Prompt**: This time the receipts should show this article in article.txt (head -c 200 matches the top of this piece, and the determin count is large). Read the instructions.json receipt against the rule: title, slug, filename, keywords, subheadings, tweet must be clean; the prepend may carry one mention. State pass or fail per field. If it passed, the closing paragraph stands as written; if it failed, say which field slipped and whether the fix is moving the rule higher in editing_prompt.txt or scrubbing the spine's old slugs, and give the patch. Then this ride is done.
**5: Deliverables**:
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:
0. TLDR: 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.
1. 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.
2. BANK: name everything that graduates — rule, earmark, todo, pin —
as exact paste-ready lines, plus the exact lines to delete.
3. DANGLING: what carries forward unbanked? One line each, no essays.
4. SEED: the adhoc.txt lines (and TODO_SLUGS if narrative context is
needed) for the next ride's first compile.
5. 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.
6. NOTARIZE: name the sealed artifact of record — the newest
hash-stamped cartridge (foo--NN.zip) — and state that its
CRC-sealed, byte-reproducible archive is the witnessed receipt of
this ride. The seal is the signature; the archive is the deed.
FINALITY: after beat 6, this discussion is CLOSED. Emit NO five-car
train, NO probes, NO patches, 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**: Context verified, and the receipts refuse the premise one more time: `article.txt` opens with "My focus is now on myelination though execution!" and matches `determin` on one line. That's the previous article. `instructions.json` is still its output, with the pre-rule "deterministic proofs" in the prepend. The ignition for this ride's falsifier, running `article` on this piece, never fired. Dismounting anyway, as instructed, with that stated plainly.
**1. VERIFY**
Goal at the top: explain text commands versus GUIs and why reproducibility matters; midway it narrowed to a concrete fix: stop `articleizer.py` from putting "deterministic" in headlines. Met in part. This compile's Codebase body of `editing_prompt.txt` carries the rule at two places (the "Do NOT use" paragraph and the closing "And no deterministic" lines) and ends in a newline; the earlier compile's `rg` receipt and this compile's `tail | xxd` receipt bracketed those landings. Not met: the rule's effect on generated output. The ignition that never fired is `article` on this piece. The `instructions.json` receipt in this compile is a stale BEFORE from the prior article wearing the AFTER's label, and nothing in this ride shows the editing model obeying the rule.
**2. BANK**
Receipt line for the `foo_files.py` RECEIPTS block, newest first:
```text
# 2026-09-03 editing_prompt.txt banned "deterministic" from title/slug/filename/keywords/subheads/tweet (rule at two sites, trailing newline fixed, three straddles green on the file itself); FALSIFIER UNFIRED -- `article` never ran on the piece carrying the rule, instructions.json still the prior article's; corpus pressure measured at 62 titles / 1112 articles.
```
Lines to delete from `adhoc.txt` (they were this ride's probe echoes, now spent):
```text
# ! rg -n -i 'determin' scripts/articles/editing_prompt.txt
# ! rg -il '^title:.*determin' /home/mike/repos/trimnoir/_posts | wc -l
# ! rg -il 'determinis' /home/mike/repos/trimnoir/_posts | wc -l
# ! tail -c1 scripts/articles/editing_prompt.txt | xxd
! head -c 200 scripts/articles/article.txt
! rg -c -i 'determin' scripts/articles/article.txt
! rg -i 'determin' scripts/articles/instructions.json
```
**3. DANGLING**
- The rule is written but untested against a real editing-model run; that is the next ride's first act.
- The book spine still hands the editing model 62 old slugs carrying the word; if the rule loses, the spine is the suspect.
- `--local` replays `instructions.json` and skips the prompt entirely, silently; a one-line warning print there is an earmark.
- `apply.py` and the `m` alias still announce "DETERMINISTIC" in their own output, contradicting the vocabulary the article just adopted.
- Early in the draft one Fable reply is pasted twice back to back; cut one before publishing.
**4. SEED**
```text
# NEXT RIDE: select this article with \h, copy, run `article` (non-local) FIRST, then compile.
! head -c 200 scripts/articles/article.txt
! rg -c -i 'determin' scripts/articles/article.txt
! rg -i 'determin' scripts/articles/instructions.json
scripts/articles/editing_prompt.txt
scripts/articles/articleizer.py
```
**5. CLOSING**
This article started with a mouse and ended with a byte. Engelbart built the mouse so people could point at a machine; forty years later the machines started pointing back, in confident paragraphs, and the question became how to tell a paragraph from a receipt. The answer that held up all the way through was old and small: take a reading, change one thing, take the same reading again, and keep a control that shouldn't move. The pipeline that publishes these words got that treatment on the way out, one rule and one newline at a time, each with its before and after pinned to the page. And then the method did the one thing a method is for: it caught the article claiming a test had run when the receipts showed it hadn't. That's the book's arc in miniature. Not a machine that never lies, and not a human who never gets fooled, but a loop where the lie has nowhere to hide and the next turn starts from the failure instead of the hope. The hammer is down. The hand is on the governor.
**6. NOTARIZE**
The artifact of record is the hash-stamped cartridge this compile rotated, the newest `foo--NN.zip` on disk at the moment of this compile. Its eight-character hash is not printed anywhere in this payload, and I will not invent it; the name is whichever `foo-*.zip` is newest in the repo root right now. That CRC-sealed, byte-reproducible archive is the witnessed receipt of this ride: the seal is the signature, the archive is the deed, and the three receipts inside it record, for anyone who opens it later, that the falsifier had not yet fired when the ride was closed.
---
## Book Analysis
### Ai Editorial Take
What is most striking about this entry is its treatment of user interfaces not as neutral windows into software, but as active obfuscation layers that hide the underlying telemetry. By framing the browser click as 'testimony' and the CLI command as a 'receipt,' the text bridges epistemology and systems engineering in a way that reframes how developers must evaluate autonomous agent outputs.
### 🐦 X.com Promo Tweet
```text
GUIs are for human eyes, but LLMs need text commands to leave verifiable receipts. Here is why reproducibility and checkable execution loops matter in the Age of AI. https://mikelev.in/futureproof/text-commands-the-mouse-for-ai/ #AIWorkflows #LocalFirst
```
### Title Brainstorm
* **Title Option:** The Text Command Is the Mouse for AI: Engineering Replayable Workflows
* **Filename:** `text-commands-the-mouse-for-ai.md`
* **Rationale:** Directly links the historical lineage of Engelbart's mouse to the modern requirements of LLM tool-calling and audit trails.
* **Title Option:** From GUI Testimony to Plain Text Receipts: Engineering Checkable AI Workflows
* **Filename:** `from-gui-testimony-to-plain-text-receipts.md`
* **Rationale:** Emphasizes the core philosophical distinction between un-auditable GUI clicks and verifiable text commands.
* **Title Option:** The Popperian Governor: Building Replayable Workflows in the Age of AI
* **Filename:** `the-popperian-governor-building-replayable-workflows.md`
* **Rationale:** Focuses on the scientific method, falsifiability, and mechanical sympathy required for high-reliability systems.
### Content Potential And Polish
- **Core Strengths:**
- Masterful weaving of historical tech touchstones (Engelbart, Xerox PARC, Therac-25) with modern AI architectural challenges.
- Brilliant use of the 'incompetent contractor' and 'receipt versus report' metaphors to clarify model hallucinations.
- Rigorous application of Popperian falsifiability and physical instrumentation straddles to software engineering.
- **Suggestions For Polish:**
- Streamline the mid-article conversational tangents while preserving the authentic 'sausage factory' stream-of-consciousness feel.
- Ensure clear structural demarcation between historical anecdotes and hard technical actuator implementations.
### Next Step Prompts
- Write a follow-up implementation guide detailing how to parse raw tool-call transcripts into immutable JSON audit ledgers.
- Explore the security implications of local-first execution environments when running unverified agentic scripts.