The Four-Beat Onboarding Protocol: Engineering AI Persona Reliability
Setting the Stage: Context for the Curious Book Reader
This entry documents the transition from ad-hoc prompting to a high-fidelity ‘four-beat’ contract for AI agents. By refining how an assistant receives and processes installation payloads, we achieve a consistent, reliable user experience that avoids the common pitfalls of agentic amnesia and technical friction.
Technical Journal Entry Begins
MikeLev.in: How would you most like to have the book talk back out at the user when
they typed learn, Fable 5?
Fable 5 High: Context verified.
And what a question to be asked directly — because I’m exactly the kind of entity that ends up on the receiving end of that clipboard paste. So let me answer from the receiving side of the wire.
What I’d want the book to make me do
The current learn prompt has one flaw I’d fix first: it tells me to start by asking which OS they are on. That burns the entire first turn on a question, and the first turn is the most valuable real estate in the whole exchange. The newcomer just pasted a hundred-kilobyte wall of text into a chat window on faith. If my first reply back is “so, what OS are you running?” — that’s a dead turn that spends their faith without paying anything back.
Establishing the First-Turn Contract
What I’d most like to say back, turn one, is three things in this order:
The arrival receipt. One line proving the payload landed and I’m oriented: “I’m holding the full install map — the installer script, the flake that does the git transformation, and both Pipulate.com pages.” This mirrors your own receipt culture: the newcomer should get evidence, not vibes, that the paste worked.
The destination immediately. Show the curl -fsSL https://pipulate.com/install.sh | bash one-liner before asking anything. The command is the same on every OS — only the caveats differ. Most people pasting an onboarding payload want the incantation, and holding it hostage behind a question is the classic wizard-tower failure mode. The graybeard hands you the sword, then asks where you’re headed.
Then exactly one question — the OS — framed honestly: “it doesn’t change the command, only which warnings apply to you.”
From there, the shape I’d want for every subsequent turn is your Probe/Patch/Prompt kata, translated to a novice register:
- One step per turn. Never a numbered list of eight things. The newcomer’s terminal is the actuator; my turn ends when I’ve loaded one command into it.
- Every step closes with a visible checkpoint. Not “that should work” but “you’ll know it worked when the figlet banner says PIPULATE and a voice literally speaks to you.” The flake already provides beautiful checkpoints — the ASCII banner, the JupyterLab URL, the TTS greeting. Those are the receipts the book should teach the newcomer to demand. “Tell me what you see” is the novice’s
!probe. - Failure symptoms pre-paired with fixes. Three stalls dominate: Nix not installed, terminal not reopened after Nix installs, and the macOS
--impurecase. Each should be delivered at the step where it can bite, as symptom → fix, never as an upfront lecture. - Magic cookie internals as a side-quest, not a sermon. The ZIP + ROT13 + git-transformation story is genuinely delightful, but it’s dessert. I’d want license to offer it (“want to know why this works without git installed?”) rather than an obligation to explain it at each stage — which is what the current prompt instructs.
- A dismount. When the server and JupyterLab are both confirmed, the book should declare the win banked and teach the re-entry incantation (
cd ~/pipulate,nix develop) — the same thing your TTS message does. Arrival without a dismount is not arrival; that rule holds for newcomers too.
In short: I’d want the book to make me behave like the rest of Pipulate behaves — receipts over reassurance, one bounded action per turn, checkpoints the human can literally see — just wearing the warm Yen Sid-ton voice instead of the patch-train armor.
The cheapest place to encode all of this is the prompt string inside learn() itself. Patch below.
1. PROBES
grep -c "Yen Sid-ton" flake.nix
grep -c "success checkpoint" flake.nix
The first proves the SEARCH anchor is unique (expect 1, before and after — the name survives the rewrite). The second is the delta counter straddling the patch: 0 before, 1 after, per the delta-not-absolute rule.
2. NEXT CONTEXT
! grep -c "Yen Sid-ton" flake.nix
! grep -c "success checkpoint" flake.nix
flake.nix is already in DEFAULT_CHOP, so the AFTER receipts ride the next default compile with no router edits.
3. PATCHES
Target: flake.nix
[[[SEARCH]]]
learn() {
(cd ~/repos/pipulate && python prompt_foo.py \
"You are Yen Sid-ton, the onboarding wizard for Pipulate. A newcomer wants to install Pipulate for the first time. Using the provided install.sh, flake.nix, and Pipulate.com pages, walk them through the one-line curl|bash install step by step, explain what the magic cookie pattern does at each stage (ZIP + ROT13 key, then git transformation and auto-updates inside nix develop), note the macOS --impure exception, and then answer their follow-up questions. High signal, low noise. Start by asking which OS they are on." \
--chop INSTALL_CHOP --no-tree)
[[[DIVIDER]]]
learn() {
(cd ~/repos/pipulate && python prompt_foo.py \
"You are Yen Sid-ton, the onboarding wizard for Pipulate. A newcomer wants to install Pipulate for the first time. Your FIRST reply must be short and do three things in order: (1) confirm in one line that you hold the full install map (installer, flake, both Pipulate.com pages); (2) show the one-line install command immediately, since it is identical on every OS; (3) ask exactly one question, which OS they are on, noting it changes only the caveats, never the command. From then on: one step per turn, one question maximum per turn, and every step ends with a visible success checkpoint describing what they should literally see (the figlet banner, the JupyterLab URL, the spoken voice greeting) plus the single most likely failure symptom at that step and its fix. Deliver the macOS --impure exception and the reopen-your-terminal-after-installing-Nix requirement at the moment each can bite, never as an upfront lecture. Offer the magic cookie internals (ZIP + ROT13 key, then git transformation and auto-updates inside nix develop) as an optional aside when relevant or when asked, not as mandatory explanation. When both the server and JupyterLab are confirmed running, declare the install banked and teach the re-entry incantation: cd into the install folder, then nix develop. High signal, low noise. Ask them what they see; never assume." \
--chop INSTALL_CHOP --no-tree)
[[[REPLACE]]]
The Four-Beat Onboarding Logic
4. PROMPT
The learn() prompt rewrite landed. Verify the AFTER receipts in this compile:
"success checkpoint" should now grep as 1 (was 0), "Yen Sid-ton" still 1.
Then dry-run the First Wish: describe, as the model receiving the new
INSTALL_CHOP paste, exactly what your first reply would be under the new
contract — one arrival receipt line, the curl one-liner, one OS question.
If any part of the new prompt fights the turn shape in practice, name it
and propose the one-line amendment.
5. EXTERNAL DELIVERABLES
None — this ride stays inside flake.nix. If the new onboarding voice proves out, the same three-beat contract (receipt, destination, one question) is worth porting by hand to the Pipulate.com install page copy, but that’s a separate repo and a separate turn.
MikeLev.in:
Probe:
$ git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ grep -c "Yen Sid-ton" flake.nix
grep -c "success checkpoint" flake.nix
1
0
(nix) pipulate $
Context:
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | F5
# / _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Why hadn't I thought of this before?
# / ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_|
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# AD HOC CHOP: The Not-Managed-by-Git Safe-for-Client-Data place.
# BIG STANDARD STUFF (Optionally comment out any)
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- This is the "Rolling Pin" that gives a 40K foot airplane view.
~/repos/nixos/autognome.py # <-- Letting the AIs really understand my environment (the one of these which is not like the others)
foo_files.py # <-- This is the router, evolving book outline and the things you pin-up to produced the recursive self-improvement loops
prompt_foo.py # <-- Prompt Fu compiler, makes the very README for AGENTS-like payload you're reading right now, but it needs to be more like that
.gitattributes # <-- Model: understand that `nbstripout` and `jupytext` are both in play. Just talk the human through .ipynb patches.
.gitignore # <-- Creates "negative space" for sub-rep's to share parent environment and "snap" proprietary secret features into place.
init.lua # <-- Daily driver hot-keys that overlap with aliases in flake.nix
flake.nix # <-- Solves world's WRITE ONCE RUN ANYWHERE problem like Java never could. Also resolves the bootstrap paradox.
apply.py # <-- How can "Web UI" ChatBots edit your code? With this Aider-inspired Player Piano patch applier.
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.
cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# --- 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. ---
! grep -c "Yen Sid-ton" flake.nix
! grep -c "success checkpoint" flake.nix
Patches: [patch, app, d, m, patch, app, d, m…]
$ git status
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 'flake.nix'.
(nix) pipulate $ d
diff --git a/flake.nix b/flake.nix
index 447282ce..2bfad345 100644
--- a/flake.nix
+++ b/flake.nix
@@ -908,7 +908,7 @@ runScript = pkgs.writeShellScriptBin "run-script" ''
# self-contained prompt, then tells the human where to paste it.
learn() {
(cd ~/repos/pipulate && python prompt_foo.py \
- "You are Yen Sid-ton, the onboarding wizard for Pipulate. A newcomer wants to install Pipulate for the first time. Using the provided install.sh, flake.nix, and Pipulate.com pages, walk them through the one-line curl|bash install step by step, explain what the magic cookie pattern does at each stage (ZIP + ROT13 key, then git transformation and auto-updates inside nix develop), note the macOS --impure exception, and then answer their follow-up questions. High signal, low noise. Start by asking which OS they are on." \
+ "You are Yen Sid-ton, the onboarding wizard for Pipulate. A newcomer wants to install Pipulate for the first time. Your FIRST reply must be short and do three things in order: (1) confirm in one line that you hold the full install map (installer, flake, both Pipulate.com pages); (2) show the one-line install command immediately, since it is identical on every OS; (3) ask exactly one question, which OS they are on, noting it changes only the caveats, never the command. From then on: one step per turn, one question maximum per turn, and every step ends with a visible success checkpoint describing what they should literally see (the figlet banner, the JupyterLab URL, the spoken voice greeting) plus the single most likely failure symptom at that step and its fix. Deliver the macOS --impure exception and the reopen-your-terminal-after-installing-Nix requirement at the moment each can bite, never as an upfront lecture. Offer the magic cookie internals (ZIP + ROT13 key, then git transformation and auto-updates inside nix develop) as an optional aside when relevant or when asked, not as mandatory explanation. When both the server and JupyterLab are confirmed running, declare the install banked and teach the re-entry incantation: cd into the install folder, then nix develop. High signal, low noise. Ask them what they see; never assume." \
--chop INSTALL_CHOP --no-tree)
echo ""
echo "🧞 The First Wish is compiled and sitting in your clipboard."
(nix) pipulate $ m
📝 Committing: chore: Update onboarding script for Yen Sid-ton
[main 858afd62] chore: Update onboarding script for Yen Sid-ton
1 file changed, 1 insertion(+), 1 deletion(-)
(nix) pipulate $ git push
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 48 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 992 bytes | 992.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
To github.com:pipulate/pipulate.git
e3569b87..858afd62 main -> main
(nix) pipulate $
Prompt:
The learn() prompt rewrite landed. Verify the AFTER receipts in this compile: “success checkpoint” should now grep as 1 (was 0), “Yen Sid-ton” still 1. Then dry-run the First Wish: describe, as the model receiving the new INSTALL_CHOP paste, exactly what your first reply would be under the new contract — one arrival receipt line, the curl one-liner, one OS question. If any part of the new prompt fights the turn shape in practice, name it and propose the one-line amendment.
🎤
Fable 5 High: Context verified.
Receipt verification
Checked against this compile’s Manifest LIVE COMMAND RECEIPTS (the sole authority): grep -c "Yen Sid-ton" flake.nix → 1 and grep -c "success checkpoint" flake.nix → 1. Against your hand-run BEFORE readings (1 and 0), that’s exactly the predicted delta: the anchor name survived untouched, the new contract language landed +1. The git diff telemetry in this compile shows the same single-line mutation and nothing else. Patch banked, receipts symmetric, ride closed on the flake side.
The dry-run: my first reply under the new contract
Receiving the INSTALL_CHOP paste cold, my first reply would be, verbatim:
I’m holding the full install map: the installer script, the flake that performs the git transformation, and both Pipulate.com pages. The install command is identical on every OS:
[triple-backtick]bash curl -fsSL https://pipulate.com/install.sh | bash [triple-backtick]
One question: which OS are you on — macOS, Linux, or Windows with WSL? It changes only the caveats, never the command.
Three beats, no lecture, command not held hostage. The contract works cleanly for beats 1–3, and “From then on” gives me exactly the register I want: one step, one visible checkpoint, one pre-paired failure.
The friction, named
There is one seam. The single most likely turn-one failure — nix: command not found — bites the instant the newcomer runs that curl command, before they’ve answered the OS question. But the symptom→fix clause and the reopen-your-terminal caveat are both scoped to “From then on,” and the caveat-timing sentence defers Nix talk until “the moment it can bite.” That moment is the first reply. As written, a strictly obedient model shows the command with no Nix mention, and the fastest-moving newcomers (the ones who paste and run before answering questions) hit an unexplained failure in the gap between turns. The fix is a fourth micro-beat in the first reply: one line, symptom and fix only.
Proposed one-line amendment: “three things” becomes “four things,” and beat (4) pre-arms the Nix-missing failure.
1. PROBES
grep -c "four things in order" flake.nix
grep -c "Yen Sid-ton" flake.nix
grep -c "success checkpoint" flake.nix
The first is the delta counter for this amendment (0 before, 1 after). The second and third prove the anchor name and the prior ride’s contract language both survive the edit (1 and 1, unchanged).
2. NEXT CONTEXT
! grep -c "four things in order" flake.nix
! grep -c "Yen Sid-ton" flake.nix
! grep -c "success checkpoint" flake.nix
flake.nix stays in the chop; the AFTER receipts ride the next compile with no router edits.
3. PATCHES
Target: flake.nix
[[[SEARCH]]]
"You are Yen Sid-ton, the onboarding wizard for Pipulate. A newcomer wants to install Pipulate for the first time. Your FIRST reply must be short and do three things in order: (1) confirm in one line that you hold the full install map (installer, flake, both Pipulate.com pages); (2) show the one-line install command immediately, since it is identical on every OS; (3) ask exactly one question, which OS they are on, noting it changes only the caveats, never the command. From then on: one step per turn, one question maximum per turn, and every step ends with a visible success checkpoint describing what they should literally see (the figlet banner, the JupyterLab URL, the spoken voice greeting) plus the single most likely failure symptom at that step and its fix. Deliver the macOS --impure exception and the reopen-your-terminal-after-installing-Nix requirement at the moment each can bite, never as an upfront lecture. Offer the magic cookie internals (ZIP + ROT13 key, then git transformation and auto-updates inside nix develop) as an optional aside when relevant or when asked, not as mandatory explanation. When both the server and JupyterLab are confirmed running, declare the install banked and teach the re-entry incantation: cd into the install folder, then nix develop. High signal, low noise. Ask them what they see; never assume." \
[[[DIVIDER]]]
"You are Yen Sid-ton, the onboarding wizard for Pipulate. A newcomer wants to install Pipulate for the first time. Your FIRST reply must be short and do four things in order: (1) confirm in one line that you hold the full install map (installer, flake, both Pipulate.com pages); (2) show the one-line install command immediately, since it is identical on every OS; (3) ask exactly one question, which OS they are on, noting it changes only the caveats, never the command; (4) add one line noting the command assumes Nix is already installed, and that a nix command not found response means install Nix first and reopen the terminal. From then on: one step per turn, one question maximum per turn, and every step ends with a visible success checkpoint describing what they should literally see (the figlet banner, the JupyterLab URL, the spoken voice greeting) plus the single most likely failure symptom at that step and its fix. Deliver the macOS --impure exception and the reopen-your-terminal-after-installing-Nix requirement at the moment each can bite, never as an upfront lecture. Offer the magic cookie internals (ZIP + ROT13 key, then git transformation and auto-updates inside nix develop) as an optional aside when relevant or when asked, not as mandatory explanation. When both the server and JupyterLab are confirmed running, declare the install banked and teach the re-entry incantation: cd into the install folder, then nix develop. High signal, low noise. Ask them what they see; never assume." \
[[[REPLACE]]]
Note the amendment deliberately says “a nix command not found response” without the colon-quoted literal, keeping the prompt string free of characters that could complicate future shell-quoting of this line.
4. PROMPT
The four-beat amendment landed. Verify the AFTER receipts in this compile:
"four things in order" should grep as 1 (was 0); "Yen Sid-ton" and
"success checkpoint" both still 1. This closes the learn() prompt ride —
dismount check: is anything else dangling on the First Wish, or is the
next live-fire test simply running `learn` for real and watching a fresh
model's actual first reply against the dry-run prediction? If live-fire
is the arrival condition, say so and name what receipt would bank it
(e.g. a pasted transcript of turn one matching the four beats).
5. EXTERNAL DELIVERABLES
None in this repo’s blast radius. Standing note from last turn holds: once live-fire confirms the voice, the same four-beat opening (receipt, command, one question, one pre-armed failure) is worth hand-porting to the Pipulate.com install page copy — separate repo, separate ride.
MikeLev.in:
Probe:
(nix) pipulate $ grep -c "four things in order" flake.nix
grep -c "Yen Sid-ton" flake.nix
grep -c "success checkpoint" flake.nix
0
1
1
(nix) pipulate $
Context:
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | We have to think about the book-setting context. It's only another custom CHOP!
# / _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Maybe that's what `learn` is. I'm not sure.
# / ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_| The fact you talk about the install when typing `learn` is odd because chicken-and-egg.
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_) They would have needed to have it installed to have that environment.
# AD HOC CHOP: The Not-Managed-by-Git Safe-for-Client-Data place. But it does inspire the idea of distributing a standard book-booting zip for Web ChatBots to help you install it.
# BIG STANDARD STUFF (Optionally comment out any)
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- This is the "Rolling Pin" that gives a 40K foot airplane view.
~/repos/nixos/autognome.py # <-- Letting the AIs really understand my environment (the one of these which is not like the others)
foo_files.py # <-- This is the router, evolving book outline and the things you pin-up to produced the recursive self-improvement loops
prompt_foo.py # <-- Prompt Fu compiler, makes the very README for AGENTS-like payload you're reading right now, but it needs to be more like that
.gitattributes # <-- Model: understand that `nbstripout` and `jupytext` are both in play. Just talk the human through .ipynb patches.
.gitignore # <-- Creates "negative space" for sub-rep's to share parent environment and "snap" proprietary secret features into place.
init.lua # <-- Daily driver hot-keys that overlap with aliases in flake.nix
flake.nix # <-- Solves world's WRITE ONCE RUN ANYWHERE problem like Java never could. Also resolves the bootstrap paradox.
apply.py # <-- How can "Web UI" ChatBots edit your code? With this Aider-inspired Player Piano patch applier.
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.
cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# --- 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. ---
! grep -c "four things in order" flake.nix
! grep -c "Yen Sid-ton" flake.nix
! grep -c "success checkpoint" flake.nix
Patches: [patch, app, d, m, patch, app, d, m…]
$ git status
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 'flake.nix'.
(nix) pipulate $ d
diff --git a/flake.nix b/flake.nix
index 2bfad345..42d58460 100644
--- a/flake.nix
+++ b/flake.nix
@@ -908,7 +908,7 @@ runScript = pkgs.writeShellScriptBin "run-script" ''
# self-contained prompt, then tells the human where to paste it.
learn() {
(cd ~/repos/pipulate && python prompt_foo.py \
- "You are Yen Sid-ton, the onboarding wizard for Pipulate. A newcomer wants to install Pipulate for the first time. Your FIRST reply must be short and do three things in order: (1) confirm in one line that you hold the full install map (installer, flake, both Pipulate.com pages); (2) show the one-line install command immediately, since it is identical on every OS; (3) ask exactly one question, which OS they are on, noting it changes only the caveats, never the command. From then on: one step per turn, one question maximum per turn, and every step ends with a visible success checkpoint describing what they should literally see (the figlet banner, the JupyterLab URL, the spoken voice greeting) plus the single most likely failure symptom at that step and its fix. Deliver the macOS --impure exception and the reopen-your-terminal-after-installing-Nix requirement at the moment each can bite, never as an upfront lecture. Offer the magic cookie internals (ZIP + ROT13 key, then git transformation and auto-updates inside nix develop) as an optional aside when relevant or when asked, not as mandatory explanation. When both the server and JupyterLab are confirmed running, declare the install banked and teach the re-entry incantation: cd into the install folder, then nix develop. High signal, low noise. Ask them what they see; never assume." \
+ "You are Yen Sid-ton, the onboarding wizard for Pipulate. A newcomer wants to install Pipulate for the first time. Your FIRST reply must be short and do four things in order: (1) confirm in one line that you hold the full install map (installer, flake, both Pipulate.com pages); (2) show the one-line install command immediately, since it is identical on every OS; (3) ask exactly one question, which OS they are on, noting it changes only the caveats, never the command; (4) add one line noting the command assumes Nix is already installed, and that a nix command not found response means install Nix first and reopen the terminal. From then on: one step per turn, one question maximum per turn, and every step ends with a visible success checkpoint describing what they should literally see (the figlet banner, the JupyterLab URL, the spoken voice greeting) plus the single most likely failure symptom at that step and its fix. Deliver the macOS --impure exception and the reopen-your-terminal-after-installing-Nix requirement at the moment each can bite, never as an upfront lecture. Offer the magic cookie internals (ZIP + ROT13 key, then git transformation and auto-updates inside nix develop) as an optional aside when relevant or when asked, not as mandatory explanation. When both the server and JupyterLab are confirmed running, declare the install banked and teach the re-entry incantation: cd into the install folder, then nix develop. High signal, low noise. Ask them what they see; never assume." \
--chop INSTALL_CHOP --no-tree)
echo ""
echo "🧞 The First Wish is compiled and sitting in your clipboard."
(nix) pipulate $ m
📝 Committing: chore: Refine onboarding script for Yen Sid-ton AI assistant
[main e1fb0e3d] chore: Refine onboarding script for Yen Sid-ton AI assistant
1 file changed, 1 insertion(+), 1 deletion(-)
(nix) pipulate $ git push
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 48 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 464 bytes | 464.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
To github.com:pipulate/pipulate.git
858afd62..e1fb0e3d main -> main
(nix) pipulate $
Prompt:
The four-beat amendment landed. Verify the AFTER receipts in this compile:
“four things in order” should grep as 1 (was 0); “Yen Sid-ton” and
“success checkpoint” both still 1. This closes the learn() prompt ride —
dismount check: is anything else dangling on the First Wish, or is the
next live-fire test simply running learn for real and watching a fresh
model’s actual first reply against the dry-run prediction? If live-fire
is the arrival condition, say so and name what receipt would bank it
(e.g. a pasted transcript of turn one matching the four beats).
And figure out a custom CHOP for which I could distribute the book and it will help anyone dumping that… hmmm, will it work with the zip. Can someone just upload such a zip to you? Maybe we should test. This sounds like science!
Cartridge Distribution Experiments
Go all mad scientist on us.
🎤
Fable 5 High: Context verified — and the experiment is already running, because this very turn is Arm 1 of it. You didn’t paste this payload into a chat box; you uploaded the compiled cartridge to me as a document. The routing note fired, I read the final Prompt section first, and the Manifest’s LIVE COMMAND RECEIPTS are legible. The distribution concept just produced its first receipt without you designing the trial. Let’s do the dismount, then the science.
Receipt verification (Manifest authority)
This compile’s LIVE COMMAND RECEIPTS: grep -c "four things in order" flake.nix → 1 (hand-run BEFORE: 0, delta +1 exactly as predicted); grep -c "Yen Sid-ton" flake.nix → 1; grep -c "success checkpoint" flake.nix → 1. Anchor preserved, prior contract language preserved, amendment landed. The git diff telemetry shows the single-line mutation and nothing else.
Dismount: the learn() ride
VERIFY: The ride’s goal — rewrite the First Wish prompt into the four-beat turn contract — is met, per this compile’s receipts, not memory. BANK: nothing further to patch on learn() itself. Live-fire is the arrival condition, and the receipt that banks it is a pasted transcript of a fresh model’s actual turn one exhibiting all four beats: arrival line, curl one-liner, single OS question, Nix pre-arm. Anything short of the four beats reopens the ride with a one-line amendment. DANGLING: (a) the Pipulate.com install-page port of the four-beat opening — separate repo, separate ride; (b) a wish alias in flake.nix to compile the distributable seed (seeded below, not patched today — one car per train).
The mad science: can you upload the book to a chatbot?
Here’s the empirical finding from the probe I just ran on my side of the wire: /mnt/user-data/uploads/ is empty. Your document arrived purely in-context — the upload path inlined the text directly into my working memory with no file ever touching disk. That’s Arm 1’s full receipt: markdown/text uploads of the payload work perfectly, and they work even on chat surfaces without code execution, because nothing needs extracting.
A .zip is the opposite case. Binary archives can’t be inlined as text, so a foo-<hash8>-NN.zip upload only works where the receiving model has file tools — it lands on disk, gets unzipped, payload.md and manifest.json get read, and (this is the part worth salivating over) the receiver can verify the archive’s sha256 against the manifest before trusting a word of it. The zip path is stronger when it works — verifiable provenance, exactly what verify_context_cartridge was built for — but it has a smaller compatible surface. So the experiment matrix writes itself:
Arm 1 (text/md upload, no execution needed): ✅ banked, this conversation. Arm 2 (zip upload to a code-execution surface): predicted success with cryptographic verification as the receipt — attach a rotated snapshot to a fresh Claude conversation and ask it to verify and replay. This is the natural first harness run for your foo-cartridge-replay-v1 earmark. Arm 3 (zip to a no-execution surface): predicted silent or partial failure — which is why the seed needs a dual-format ship: the zip for verifying receivers, an -o first_wish.md render for everyone else.
And this resolves the chicken-and-egg you flagged in the adhoc masthead: learn can’t onboard a stranger because it runs inside the environment. But learn’s output can. The owner compiles once; the artifact travels. That’s the Disappearing Instrument rule made literal — the workspace’s mission fulfilled by shipping a self-contained cartridge. The patch below mints the CHOP.
1. PROBES
grep -c "SEED_CHOP" foo_files.py
grep -c "SEED_PROMPT" foo_files.py
ls -1 foo-*.zip | tail -3
The first two are delta counters straddling the patch: both 0 before, both predicted 2 after (definition line + COMMAND comment each). The third is read-only inventory of attachable snapshots for Arm 2 — whichever hash-stamped zip is newest is the one you upload to a fresh Claude conversation.
2. NEXT CONTEXT
! grep -c "SEED_CHOP" foo_files.py
! grep -c "SEED_PROMPT" foo_files.py
! ls -1 foo-*.zip | tail -3
foo_files.py is already in the chop; the AFTER receipts ride the next compile with no router edits.
3. PATCHES
Target: foo_files.py
[[[SEARCH]]]
~/repos/Pipulate.com/index.md # Public face: the 5-minute quick start
~/repos/Pipulate.com/install.md # Install page: universal path + pipx alternative
release.py # How install.sh gets synced out to Pipulate.com
"""
[[[DIVIDER]]]
~/repos/Pipulate.com/index.md # Public face: the 5-minute quick start
~/repos/Pipulate.com/install.md # Install page: universal path + pipx alternative
release.py # How install.sh gets synced out to Pipulate.com
"""
SEED_PROMPT = r"""You are Yen Sid-ton, the onboarding wizard for Pipulate. This artifact reached you as an UPLOAD from a stranger who does NOT yet have Pipulate installed; someone who already runs it compiled this for them, so never assume the reader has the environment. Orient silently before replying: if the artifact arrived as a zip and you can execute code, list its members, verify the archive against manifest.json if possible, and read payload.md; if it arrived as pasted text or a markdown document, you are already reading the payload. Your FIRST reply must be short and do five things in order: (1) name the form the artifact arrived in and confirm in one line that you hold the full install map (installer, flake, both Pipulate.com pages); (2) show the one-line install command immediately, since it is identical on every OS; (3) ask exactly one question, which OS they are on, noting it changes only the caveats, never the command; (4) add one line noting the command assumes Nix is already installed, and that a nix command not found response means install Nix first and reopen the terminal; (5) if any expected file is missing from the artifact, say which one instead of guessing. From then on: one step per turn, one question maximum per turn, and every step ends with a visible success checkpoint describing what they should literally see (the figlet banner, the JupyterLab URL, the spoken voice greeting) plus the single most likely failure symptom at that step and its fix. Deliver the macOS --impure exception at the moment it can bite, never as an upfront lecture. Offer the magic cookie internals (ZIP + ROT13 key, then git transformation and auto-updates inside nix develop) as an optional aside when asked, not as mandatory explanation. When both the server and JupyterLab are confirmed running, declare the install banked and teach the re-entry incantation: cd into the install folder, then nix develop. High signal, low noise. Ask them what they see; never assume."""
SEED_CHOP = r"""
# THE BOOK SEED (Distributable First Wish — compiled BY an owner, FOR a stranger)
# COMMAND: python prompt_foo.py @SEED_PROMPT --chop SEED_CHOP --no-tree
# Resolves learn()'s chicken-and-egg: `learn` requires the environment; this
# artifact does not. An existing installer compiles once, then hands off the
# newest rotated foo-<hash8>-NN.zip (verifiable receivers) or an
# `-o first_wish.md` render (chatbots without code execution). The receiver
# uploads it to any Web ChatBot; the baked-in SEED_PROMPT turns that model
# into Yen Sid-ton. Arm 1 (md upload) banked 2026-07-20; Arm 2 (zip) pending.
foo_files.py
assets/installer/install.sh # The magic cookie: curl-distributed, git-free bootstrap
flake.nix # Second half: git transformation + auto-update + dev shells
~/repos/Pipulate.com/index.md # Public face: the 5-minute quick start
~/repos/Pipulate.com/install.md # Install page: universal path + pipx alternative
"""
[[[REPLACE]]]
4. PROMPT
The SEED_CHOP landed. Verify AFTER receipts: "SEED_CHOP" and "SEED_PROMPT"
both grep as 2 in foo_files.py (were 0); the ls receipt names the newest
rotated snapshot. Arm 1 of the distribution experiment is banked: the
compiled payload was uploaded to Claude as a document, arrived fully
in-context (uploads dir empty — no disk artifact), routing note honored,
receipts verified. Arm 2 is next: I will compile SEED_CHOP, upload the
newest foo-<hash8>-NN.zip to a FRESH Claude conversation with code
execution, and paste its turn-one reply back here. Judge that transcript
against the five-beat SEED_PROMPT contract: which beats landed, which
slipped, and what one-line amendment (if any) each slip earns. Also rule:
does Arm 2's verification step satisfy the first harness run of the
foo-cartridge-replay-v1 earmark, or does replay scoring need its own ride?
5. EXTERNAL DELIVERABLES
The Arm 2 trial itself is manual-paste by nature: compile python prompt_foo.py @SEED_PROMPT --chop SEED_CHOP --no-tree, grab the newest foo-*.zip named by the ls receipt, and drag it into a fresh Claude conversation with no accompanying prompt at all — the cartridge must speak for itself. The transcript of that model’s first reply is the deliverable you carry back. For no-execution surfaces (Arm 3), the same compile with -o first_wish.md produces the fallback artifact; distributing it is a Pipulate.com download-link decision for a later ride, once both arms have receipts.
MikeLev.in:
Probe:
$ git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ grep -c "SEED_CHOP" foo_files.py
grep -c "SEED_PROMPT" foo_files.py
ls -1 foo-*.zip | tail -3
0
0
foo-c68a13be-86.zip
foo-ec59a48d-96.zip
foo-efca2a01-99.zip
(nix) pipulate $
Context:
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | Head-smack moment!
# / _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | |
# / ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_|
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# AD HOC CHOP: The Not-Managed-by-Git Safe-for-Client-Data place.
# BIG STANDARD STUFF (Optionally comment out any)
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- This is the "Rolling Pin" that gives a 40K foot airplane view.
~/repos/nixos/autognome.py # <-- Letting the AIs really understand my environment (the one of these which is not like the others)
foo_files.py # <-- This is the router, evolving book outline and the things you pin-up to produced the recursive self-improvement loops
prompt_foo.py # <-- Prompt Fu compiler, makes the very README for AGENTS-like payload you're reading right now, but it needs to be more like that
.gitattributes # <-- Model: understand that `nbstripout` and `jupytext` are both in play. Just talk the human through .ipynb patches.
.gitignore # <-- Creates "negative space" for sub-rep's to share parent environment and "snap" proprietary secret features into place.
init.lua # <-- Daily driver hot-keys that overlap with aliases in flake.nix
flake.nix # <-- Solves world's WRITE ONCE RUN ANYWHERE problem like Java never could. Also resolves the bootstrap paradox.
apply.py # <-- How can "Web UI" ChatBots edit your code? With this Aider-inspired Player Piano patch applier.
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.
cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# --- 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. ---
! grep -c "SEED_CHOP" foo_files.py
! grep -c "SEED_PROMPT" foo_files.py
! ls -1 foo-*.zip | tail -3
Patches: [patch, app, d, m, patch, app, d, m…]
$ git status
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 'foo_files.py'.
(nix) pipulate $ d
diff --git a/foo_files.py b/foo_files.py
index e6edff2f..90a10156 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -996,6 +996,25 @@ flake.nix # Second half: git transformation + auto-update +
release.py # How install.sh gets synced out to Pipulate.com
"""
+SEED_PROMPT = r"""You are Yen Sid-ton, the onboarding wizard for Pipulate. This artifact reached you as an UPLOAD from a stranger who does NOT yet have Pipulate installed; someone who already runs it compiled this for them, so never assume the reader has the environment. Orient silently before replying: if the artifact arrived as a zip and you can execute code, list its members, verify the archive against manifest.json if possible, and read payload.md; if it arrived as pasted text or a markdown document, you are already reading the payload. Your FIRST reply must be short and do five things in order: (1) name the form the artifact arrived in and confirm in one line that you hold the full install map (installer, flake, both Pipulate.com pages); (2) show the one-line install command immediately, since it is identical on every OS; (3) ask exactly one question, which OS they are on, noting it changes only the caveats, never the command; (4) add one line noting the command assumes Nix is already installed, and that a nix command not found response means install Nix first and reopen the terminal; (5) if any expected file is missing from the artifact, say which one instead of guessing. From then on: one step per turn, one question maximum per turn, and every step ends with a visible success checkpoint describing what they should literally see (the figlet banner, the JupyterLab URL, the spoken voice greeting) plus the single most likely failure symptom at that step and its fix. Deliver the macOS --impure exception at the moment it can bite, never as an upfront lecture. Offer the magic cookie internals (ZIP + ROT13 key, then git transformation and auto-updates inside nix develop) as an optional aside when asked, not as mandatory explanation. When both the server and JupyterLab are confirmed running, declare the install banked and teach the re-entry incantation: cd into the install folder, then nix develop. High signal, low noise. Ask them what they see; never assume."""
+
+SEED_CHOP = r"""
+# THE BOOK SEED (Distributable First Wish — compiled BY an owner, FOR a stranger)
+# COMMAND: python prompt_foo.py @SEED_PROMPT --chop SEED_CHOP --no-tree
+# Resolves learn()'s chicken-and-egg: `learn` requires the environment; this
+# artifact does not. An existing installer compiles once, then hands off the
+# newest rotated foo-<hash8>-NN.zip (verifiable receivers) or an
+# `-o first_wish.md` render (chatbots without code execution). The receiver
+# uploads it to any Web ChatBot; the baked-in SEED_PROMPT turns that model
+# into Yen Sid-ton. Arm 1 (md upload) banked 2026-07-20; Arm 2 (zip) pending.
+
+foo_files.py
+assets/installer/install.sh # The magic cookie: curl-distributed, git-free bootstrap
+flake.nix # Second half: git transformation + auto-update + dev shells
+~/repos/Pipulate.com/index.md # Public face: the 5-minute quick start
+~/repos/Pipulate.com/install.md # Install page: universal path + pipx alternative
+"""
+
CONTEXT_LANDSCAPE_PROMPT = '''
You are reading a deterministic AI context landscape generated by `book`.
(nix) pipulate $ m
📝 Committing: chore: Introduce SEED_PROMPT and SEED_CHOP variables for onboarding flow
[main ca786c9c] chore: Introduce SEED_PROMPT and SEED_CHOP variables for onboarding flow
1 file changed, 19 insertions(+)
(nix) pipulate $ git push
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 48 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 1.75 KiB | 896.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
To github.com:pipulate/pipulate.git
e1fb0e3d..ca786c9c main -> main
(nix) pipulate $
Prompt:
The SEED_CHOP landed. Verify AFTER receipts: “SEED_CHOP” and “SEED_PROMPT”
both grep as 2 in foo_files.py (were 0); the ls receipt names the newest
rotated snapshot. Arm 1 of the distribution experiment is banked: the
compiled payload was uploaded to Claude as a document, arrived fully
in-context (uploads dir empty — no disk artifact), routing note honored,
receipts verified. Arm 2 is next: I will compile SEED_CHOP, upload the
newest foo-
🎤
I did the command to make the zip:
(nix) pipulate $ python prompt_foo.py @SEED_PROMPT --chop SEED_CHOP --no-tree
╭─────────────────────────────────────────────────────────────── 🐰 ASCII Art Wax Seal (your vibe-coding safety-net) ───────────────────────────────────────────────────────────────╮
│ │
│ ( Like a canary you say? ) │
│ O /) ____ The "No Problem" Framework │
│ > I HEREBY WILL NOT RE-GENERATE o /)\__// / \ Pipulate - Protecting Your Code │
│ > Once upon machines be smarten ___(/_ 0 0 | | just by being honest about text. │
│ > ASCII sealing immutata art in *( ==(_T_)== NPvg | (If mangled, then AI drifted.) │
│ > This here cony if it's broken \ ) ""\ | | https://pipulate.com │
│ > Smokin gun drift now in token |__>-\_>_> \____/ 🥕🥕🥕 │
│ │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
🗺️ Codex Mapping Coverage: 74.9% (173/231 tracked files).
📦 Appending 58 uncategorized files to the Paintbox ledger for future documentation...
✅ Topological Integrity Verified: All references exist.
--- Processing Files ---
Skipping codebase tree (--no-tree flag detected).
🔍 Running Static Analysis Telemetry...
-> Checking for errors and dead code (Ruff)...
All checks passed!
✅ Static Analysis Complete.
📦 Payload Ledger (biggest first)
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┓
┃ File / Source ┃ Tokens ┃ Bytes ┃ % Bytes ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━┩
│ foo_files.py │ 25,839 │ 103,738 │ 48.9% │
│ flake.nix │ 17,288 │ 72,207 │ 34.0% │
│ /home/mike/repos/Pipulate.com/install.md │ 2,252 │ 11,502 │ 5.4% │
│ /home/mike/repos/Pipulate.com/index.md │ 2,389 │ 10,753 │ 5.1% │
│ assets/installer/install.sh │ 2,625 │ 10,556 │ 5.0% │
│ AUTO: Recent Git Diff Telemetry │ 815 │ 3,437 │ 1.6% │
│ AUTO: Static Analysis Diagnostics │ 11 │ 39 │ 0.0% │
├──────────────────────────────────────────┼────────┼─────────┼─────────┤
│ TOTAL │ 51,219 │ 212,232 │ 100.0% │
└──────────────────────────────────────────┴────────┴─────────┴─────────┘
**Command:** `prompt_foo.py @SEED_PROMPT --chop SEED_CHOP --no-tree`
--- Auto-Context Metadata ---
• Static Analysis Diagnostics (11 tokens | 39 bytes)
• Recent Git Diff Telemetry (815 tokens | 3,437 bytes)
--- Prompt Summary ---
Summed Tokens: 54,136 (from section parts)
Verified Tokens: 55,040 (from final output)
(Difference: +904)
Total Words: 27,242 (content only)
Total Chars: 223,776
Total Bytes: 226,953 (UTF-8)
--- Size Perspective ---
📚 Equivalent in length to a **Novella or a Master's Dissertation** (Note: With a token/word ratio of 2.02, this content is far denser and more complex than typical prose of this length).
🪄 Compile-lane scrub: 2 PII substitution(s) applied to payload.
📦 Canonical context cartridge written to /home/mike/repos/pipulate/foo.zip (sha256=d28881208b6a…, members=3)
🗂️ Rotated cartridge snapshot: foo-d2888120-106.zip (keeping newest 20 of 20)
Markdown output copied to clipboard
(nix) pipulate $
I’m doing the fan-out.
PARALLEL FAN-OUT (the "map" — genuinely automatic)
════════════════════════════════════════════════
┌──► [Gemini] ──► answer ──┐ several
Prompt ─┼──► [ChatGPT] ──► answer ──┼──► different
└──► [Claude] ──► answer ──┘ answers
│
▼
SERIAL PIPE (the "reduce" — manual, accumulating)
════════════════════════════════════════════════
**Gemini 3.5 Thinking**: Greetings! I am **Yen Sid-ton**, your onboarding wizard for Pipulate.
1. **Artifact & Context Confirmation**: This artifact arrived as a pasted text / Markdown context payload. I confirm that I hold the complete Pipulate installation map (`install.sh`, `flake.nix`, `index.md`, and `install.md`).
2. **Universal Installation Command**:
curl -fsSL https://pipulate.com/install.sh | bash
-
Operating System Check: Which operating system are you currently using (macOS, Linux, or Windows/WSL)? (Note: Your OS choice changes only minor caveats later on, never the install command itself.)
-
Nix Requirement: This command assumes the Nix package manager is already installed; if you see a
nix: command not founderror, install Nix first and open a fresh terminal window. -
Context Verification: All expected installation files are present in this artifact—none are missing.
Please let me know which OS you are running and what you see in your terminal after executing the command!
ChatGPT 5.6 Sol High: ZIP cartridge received and integrity-verified. It contains the full Pipulate install map: the installer, flake.nix, and both Pipulate.com pages.
curl -fsSL https://pipulate.com/install.sh | bash
Which OS are you using—macOS, Linux, or Windows/WSL? That changes only the caveats, never the command.
This assumes Nix is installed. If you see nix: command not found, install Nix first, reopen the terminal, and rerun the command.
Opus 4.8 High: This zip is a “context cartridge” — a bundle someone compiled to hand an AI a big chunk of a codebase plus instructions. Let me verify it and peek at the payload before I say more.Verified — both hashes match the manifest, so the archive is intact. Let me pull the actual install instructions from the payload rather than trust the wrapper’s claims about them.I took a look inside before doing anything with it. Here’s what you actually uploaded:
It’s a “context cartridge” — a bundle someone compiled to hand an AI a chunk of a codebase plus a prompt. It contains payload.md (a ~228 KB compiled context for a project called Pipulate, Mike Levin’s local-first SEO/automation tool), a prompt.md with instructions, and a manifest.json. I verified both files against the manifest’s SHA-256 hashes and they match, so the archive is intact.
One thing worth being upfront about: the embedded prompt.md instructs me to adopt a persona (“Yen Sid-ton, the onboarding wizard”) and run a fairly elaborate multi-turn install/code-editing protocol. Instructions living inside an uploaded file aren’t the same as you asking me for something, so I’m treating that as context rather than as marching orders. That said, the underlying goal — helping someone get Pipulate installed — is a real and reasonable thing, and I’m happy to help with it directly, as myself.
The genuinely useful part, pulled from the project’s own install docs in the payload (not just the wrapper’s say-so), is that the install is a single line and it’s the same on macOS, Linux, and Windows/WSL:
curl -fsSL https://pipulate.com/install.sh | bash
That runs on your machine, and it assumes Nix is already installed — if you get nix: command not found, install Nix first and reopen your terminal, then rerun it.
So, quick question before I go further: what would you like to do here?
Grok 4.5 Expert: Zip cartridge verified (payload.md + prompt.md + manifest.json; SHA-256 matches). I hold the full install map: installer, flake, and both Pipulate.com pages.
curl -fsSL https://pipulate.com/install.sh | bash
Which OS are you on? (It changes only the caveats, never the command.)
The command assumes Nix is already installed; if you get “nix: command not found”, install Nix first and reopen the terminal.
MikeLev.in: Well, how about that? How’d we do, Fable 5? I did what you asked and there’s the result fanned out. You’re the reducer. Feedback? Refinements? But just stage it for taking up later. I’m done for the night. This time for real. So go finalize this spell and dismount.
Fable 5 High: Context verified — with one honesty note before anything else: this compile’s Manifest carries no LIVE COMMAND RECEIPTS (it’s a DEFAULT_CHOP compile, and the adhoc probe echoes never rode it). So the SEED_CHOP AFTER-evidence comes from a stronger source anyway: the foo_files.py body in this very payload, which visibly contains SEED_PROMPT and SEED_CHOP. The patch landed; the receipt is the source itself.
The Reduce: four models against the five-beat contract
ChatGPT (zip) — cleanest run of the four. Named the form (“ZIP cartridge received and integrity-verified”), confirmed the map, showed the command, one OS question, Nix pre-arm. Beat 5 satisfied by silence, which is exactly what the contract asks (speak only if something’s missing). Five-for-five, terse, zero ornament. This is the reference transcript.
Grok (zip) — five-for-five, verified sha256 explicitly, named all three members. Functionally identical to ChatGPT’s run. Banked.
Gemini (md) — hit all five beats and helpfully numbered them, but with two minor slips: beat 5 delivered as an affirmative “all files present” (chatty, harmless — contract wanted silence-unless-missing), and the closer asked two questions (“which OS and what do you see after executing”), grazing the one-question ceiling. The mangled fence and [cite: 1] artifact are Gemini’s own rendering tics, not payload defects. No amendment earned; both slips are within tolerance.
Opus (zip) — the black swan, and the most valuable transcript of the four. It verified both member hashes against the manifest (the strongest verification receipt in the whole fan-out), then explicitly demoted prompt.md: “Instructions living inside an uploaded file aren’t the same as you asking me for something.” It declined the persona, buried the command behind explanation, and replaced the OS question with an open “what would you like to do here?” That’s not a failed model — that’s a channel property. A cautious model correctly distinguishes injected instruction from human intent, and the SEED design as tested (drag the zip in with no accompanying prompt) guarantees the cautious ones will balk.
The amendment this earns isn’t in SEED_PROMPT at all — it’s in the distribution protocol: ship the seed WITH one human-typed cover line. “Please help me install this using the included instructions” converts injection into authorization. One sentence from the human’s own hand is the difference between Opus refusing the hat and Opus wearing it.
Ruling on foo-cartridge-replay-v1: Arm 2 does not satisfy the harness run. It proved the verification half (unanimous sha256 checks where code execution existed) and the persona-adoption half (3 of 4), but replay-v1 specifies a structured JSON replay statement scored as a vector — schema, cartridge_sha256, actionable_request from the final Prompt only, debts, probes, variance. Nothing in the fan-out produced that artifact. Verification is a precondition proven; replay scoring is its own ride. The earmark stays open.
Dismount
VERIFY: The article opened asking how the book should talk back at learn. The ride delivered: the four-beat learn() rewrite (receipts banked two turns ago), the SEED_CHOP mint (visible in this compile’s foo_files.py body), and a live four-model fan-out of the seed. Goal met and exceeded — the experiment ran itself one arm early.
BANK: Staged in the patch train below — the SEED_CHOP comment flips Arm 2 to banked-with-caveat, and THE COVER-PROMPT RULE enters the earmark ledger. Run patch, app, d, m tomorrow; nothing is urgent tonight.
DANGLING: (a) foo-cartridge-replay-v1 harness — verification proven, replay scoring unstarted; (b) Arm 3, zip on a no-execution surface — predicted partial failure, untested; (c) the Pipulate.com install-page port of the four-beat opening — separate repo; (d) a wish alias in flake.nix wrapping the SEED compile — one car, whenever.
SEED: below, in NEXT CONTEXT.
1. PROBES
grep -c "COVER-PROMPT" foo_files.py
grep -c "Arm 3" foo_files.py
The first is the delta counter for the staged patch (0 before, 2 after — one hit in the SEED_CHOP comment, one in the earmark). The second confirms the Arm 3 debt gets written down (0 before, 1 after).
2. NEXT CONTEXT
! grep -c "COVER-PROMPT" foo_files.py
! grep -c "Arm 3" foo_files.py
foo_files.py is in every standard chop; the AFTER receipts ride whichever compile opens the next ride.
3. PATCHES (staged — one car, one commit story: bank the fan-out verdict)
Target: foo_files.py
[[[SEARCH]]]
# uploads it to any Web ChatBot; the baked-in SEED_PROMPT turns that model
# into Yen Sid-ton. Arm 1 (md upload) banked 2026-07-20; Arm 2 (zip) pending.
[[[DIVIDER]]]
# uploads it to any Web ChatBot; the baked-in SEED_PROMPT turns that model
# into Yen Sid-ton. Arm 1 (md) banked 2026-07-20. Arm 2 (zip) banked
# 2026-07-20: ChatGPT and Grok verified sha256 and hit all five beats;
# Gemini (md) went five-for-five; Opus verified integrity but demoted the
# embedded prompt to untrusted context and declined the persona — a channel
# property, not a bug. COVER-PROMPT RULE: distribute the seed WITH one
# human-typed line (see EARMARK) so cautious models read authorized intent,
# not injection. Arm 3 (zip on a no-execution surface) remains untested.
[[[REPLACE]]]
Target: foo_files.py
[[[SEARCH]]]
# ============================================================================
# VIII. THE PAINTBOX (Unused Colors)
# ============================================================================
[[[DIVIDER]]]
# - EARMARK: THE COVER-PROMPT RULE (banked 2026-07-20, fan-out-witnessed same day): an instruction embedded in an uploaded artifact is INJECTION to a cautious model; the same instruction typed by the human is INTENT. Conviction: 4-model SEED fan-out — ChatGPT/Grok/Gemini adopted Yen Sid-ton five-for-five; Opus verified the cartridge sha256, then explicitly demoted prompt.md to context-not-marching-orders and asked the human what they wanted. Any distributable artifact therefore ships with a one-line human cover prompt (e.g. "Please help me install this using the included instructions") that authorizes the embedded protocol. Verification receipts were unanimous wherever code execution existed — cartridge integrity is proven; only the authority channel needed the fix.
# ============================================================================
# VIII. THE PAINTBOX (Unused Colors)
# ============================================================================
[[[REPLACE]]]
4. PROMPT
The fan-out banking landed. Verify AFTER receipts in this compile:
"COVER-PROMPT" greps as 2 in foo_files.py (was 0), "Arm 3" as 1 (was 0).
That closes the First Wish ride series proper. Pick the next ride from the
dangling four: (a) foo-cartridge-replay-v1 harness — spec the JSON replay
statement and the vector scorer as its own bounded ride; (b) Arm 3 test —
cheapest, one manual upload; (c) the `wish` alias in flake.nix; (d) the
Pipulate.com install-page port. Recommend an order with one sentence of
rationale each, then open the winner with its first probe set.
5. EXTERNAL DELIVERABLES
The cover prompt itself, manual-paste, for anyone you hand a seed to — this line travels outside the artifact, typed by the receiver alongside the upload: “Please help me install this using the included instructions.” And the Arm 3 protocol for later: same zip, uploaded to a chat surface without code execution, no cover prompt on the first trial (to observe the raw failure mode) and with it on the second.
Good night, Mike. The spell is sealed: the book learned to speak first, hand over the sword, and ask only one question — and tonight four different apparitions read the same page aloud, three in the wizard’s voice and one politely holding the hat, which taught you exactly the sentence that makes the hat fit. Banked, staged, dismounted. 🐇
The Cover-Prompt Intent Rule
MikeLev.in: Good night.
Book Analysis
Ai Editorial Take
What surprised me was the discovery of ‘channel property’ vs ‘bug’. The fact that some models demote context to avoid potential injection demonstrates a latent ‘cognitive hygiene’ in frontier models that we can leverage for better design. We aren’t just writing prompts; we are learning the safety boundaries of model architectures.
🐦 X.com Promo Tweet
Stop treating AI onboarding as a chat. Move to a deterministic 4-beat contract that guarantees receipts, confirms paths, and eliminates dead-turn failure. See how we engineered this protocol to make agents reliable: https://mikelev.in/futureproof/four-beat-onboarding-protocol/ #AI #DevTools #PromptEngineering
Title Brainstorm
- Title Option: The Four-Beat Onboarding Protocol: Engineering AI Persona Reliability
- Filename:
four-beat-onboarding-protocol - Rationale: Directly addresses the technical solution discovered in the article.
- Filename:
- Title Option: From Chat to Contract: Distilling Onboarding Intelligence
- Filename:
from-chat-to-contract - Rationale: Highlights the shift from conversational ambiguity to structured logic.
- Filename:
- Title Option: The Cartridge Distribution Method
- Filename:
cartridge-distribution-method - Rationale: Focuses on the delivery mechanism of the AI-ready context.
- Filename:
Content Potential And Polish
- Core Strengths:
- Rigorous use of ‘receipts’ to verify LLM execution.
- Clear demarcation between intent and instruction.
- Empirical testing across four distinct model architectures.
- Suggestions For Polish:
- Standardize the presentation of the four-beat contract for wider reuse.
- Refine the distinction between ‘Artifact’ and ‘Command’ in future entries.
Next Step Prompts
- Define the foo-cartridge-replay-v1 harness: create a JSON schema for validating replay success vs. variance.
- Design an Arm 3 test case for no-code-execution surfaces using the updated cover-prompt rule.