Four Models, One Matchbook: Multi-Model Consensus in the Age of AI
Setting the Stage: Context for the Curious Book Reader
In this installment, the author conducts a double-blind prompt fan-out across four leading frontier models (Claude/Fable, ChatGPT, Gemini, and Grok) to explore architectural shapes for a self-bootstrapping technical book. Using a structured 30-and-3 ideation exercise, each model independently maps thirty diverse conceptual formats before selecting its top three load-bearing candidates. Strikingly, despite completely isolated contexts, all four models converge on the exact same core concept: a sub-1,500-word aphoristic pocket guide—the “Matchbook”—built from cold-readable rule keys and verified glossary handles. What unfolds is an important demonstration of multi-model consensus in the Age of AI: how narrative lore serves merely as an interface skin, while the underlying verification receipts remain the durable engine.
TL;DR: Four frontier AI models were evaluated in an anonymized, parallel 30-and-3 fan-out to explore architectural, pedagogical, and narrative forms for a self-bootstrapping technical book. Without inter-model visibility, all four independently converged on a pocket-sized, aphoristic core distillation (the “Matchbook” format) as the primary functional reduction, treating expansive narrative lore as an interface layer rather than underlying mechanism. That consensus was operationalized into a dedicated compiler target (MATCHBOOK_CHOP) in foo_files.py, extracting 50 active constitutional keys and 115 glossary pairs into an under-1,500-word text that serves as the dual-door curriculum for both pocket reading and the qamy.ai verification portal.
Technical Journal Entry Begins
Introduction
We are doing a prompt fan-out. No, this is not a query fan-out which is what the kids are calling keyword expansion these days because SEO is now uncool. No, this is a much more important double-blind anonymous panel test, like the Pepsi Challenge but for AI. It’s also sort of like a Map Reduce project but where the reduction is supposed to be a matter of human taste but because we crossed over some sort of Rubicon, humans will no longer exclusively do the parts that are supposed to be exclusively done by humans. That’s Mike Levin’s law.
That part where parallel turns into serial and the human is suppose to reduce… you see that? Well that’s supposed to be just a human there reading over all the entries and deciding what’s best or most surprising or important or whatever. We used four models but the number of models you fan your prompt out over doesn’t matter.
PARALLEL FAN-OUT (the "map" — genuinely automatic)
════════════════════════════════════════════════
┌──► [LLM 1] ──► answer ──┐ several
Prompt ─┼──► [LLM 2] ──► answer ──┼──► different
└──► [LLM 3] ──► answer ──┘ answers
│
▼
SERIAL PIPE (the "reduce" — manual, accumulating)
════════════════════════════════════════════════
[independent blind responses] ──► [human feedback] ──► [next] ──► …
history grows, context accumulates, human directs
What matters is that we forced them to be creative with a 30-and-3 exercise which is a forced ideation that makes you empty out the obvious most likely to be produced tokens and to keep digging and digging. Oh, and as you dig you discover the axis that your brainstormed examples plot against in a Forrester and Gardner style 2-axis grid. Our purpose is to choose orthogonal ends of the spectrum to force some real outliers and black swans to be explored or at least identifiable.
PASS 2 — plot the 30. The clump names your bias. The hole is an address.
B
· · · │
· · · · · │ ( E M P T Y )
· · · │
A ──────────────┼─────────────────────── A'
│
│ ( E M P T Y )
│
B'
So there’s nothing new under the Sun, huh?
Everything new in the Noosphere is already snatched-up real estate, huh?
Well we’ll just see about that.
The 30-and-3 Exercise: Bootstrapping the Living Book
MikeLev.in: We are writing a book that bootstraps its own existence as a book. Just add LLM. And you can add LLM from any of the AI companies offering some good enough frontier model, or you could try to do it with your own home-hosted local LLM. It really doesn’t matter because as the Vulcan’s say infinite something something. What do they say anyway?
Also I think there should be one version that’s like the Shambhala Pocket Classic edition of The Art of War; you know, like practically a practically matchbook-sized book that says it all and still has room for translation and is readable in one sitting. Then there’s the illustrated children’s version, then there’s the version with a Sci-Fi parallel timeline where LISP Machines beat Unix-like OSes and incubate SkyNet gremlins. Then there’s the hyperliteralists who love all the detail and want as much book-ore preserved as is reasonably possible and still have a good read. My own work screams The Little Prince to me, so there’s a stylistic version right there.
Also there’s the not-literal literal Magic Grimoire and coming alive unfurling Wizard Workshop Sorcerer’s Apprentice version I start fleshing out with the lore with an actual Yen-Sid Ton that was created from all of the old Yen-Sid original material, Mike-E that follows in the footsteps of Mickey discovering it’s fine to experiment with automation and flood the workshop. There’s an undo and you only get a swift bop on the butt with a broom and how we pivot from that to good git hygiene. It could be symbolic of the end of the JavaScript industrial complex because of proper use of hypermedia because of HTMX and developing your content negotiation for AI.
Or it could just be the Context Compiler for Quality Assurance of your
confidently hallucinating “Because Claude said so…” LLM output you wanna use
but can’t put your name behind until you npvg.org it. Feel that itch? See the
new blue? Process-wise there’s a reverse-chronological approach and there’s an
as-it-played-out approach, and there’s also a drill-down as the LLM making the
book sees fit, scanning the book-ore spine and just doing it however the marble
rolls down the landscape. Well you get the idea. We could just keep going on
like that. As a corpus of training material and as a fun exercise, this is the
gift that keeps on giving. How many approaches are there here? Do it as a 30 and
3 exercise please and thank you!
(nix) pipulate $ prompt
(nix) pipulate $ ahc
╭─────────────────────────────────────────────────────────────── 🐰 ASCII Art Wax Seal (your vibe-coding safety-net) ───────────────────────────────────────────────────────────────╮
│ │
│ ( Like a canary you say? ) │
│ O /) ____ The "No Problem" Framework │
│ > I HEREBY WILL NOT RE-GENERATE o /)\__// / \ Pipulate - Protecting Your Code │
│ > Once upon machines be smarten ___(/_ 0 0 | | just by being honest about text. │
│ > ASCII sealing immutata art in *( ==(_T_)== NPvg | (If mangled, then AI drifted.) │
│ > This here cony if it's broken \ ) ""\ | | https://pipulate.com │
│ > Smokin gun drift now in token |__>-\_>_> \____/ 🥕🥕🥕 │
│ │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
🗺️ Codex Mapping Coverage: 74.7% (204/273 tracked files) (was 204/273: +0 claimed, +0 tracked).
ROUTER LOADED: /home/mike/.local/state/pipulate/adhoc.txt (12 active line(s))
✅ Topological Integrity Verified: 24 candidate reference(s) scanned, all exist.
-> Executing: python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs ... [0.2918s]
-> Executing: rgxc qamy.ai ... [0.2444s]
-> Ruff exit 0 (clean).
📦 Payload Ledger (biggest first)
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━┓
┃ File / Source ┃ Tokens ┃ Bytes ┃ % Bytes ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━┩
│ foo_files.py │ 85,111 │ 340,328 │ 29.5% │
│ prompt_foo.py (sometimes left out) │ 48,213 │ 212,314 │ 18.4% │
│ ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs │ 63,559 │ 165,515 │ 14.3% │
│ flake.nix │ 33,460 │ 138,803 │ 12.0% │
│ GLOSSARY.md │ 31,333 │ 125,667 │ 10.9% │
│ /home/mike/repos/nixos/autognome.py │ 10,581 │ 47,651 │ 4.1% │
│ init.lua │ 10,402 │ 39,825 │ 3.4% │
│ apply.py │ 8,584 │ 36,636 │ 3.2% │
│ assets/installer/install.sh │ 4,257 │ 16,852 │ 1.5% │
│ PROMPT (checklist + prompt.md) │ 3,090 │ 13,719 │ 1.2% │
│ pyproject.toml │ 1,129 │ 4,104 │ 0.4% │
│ .gitignore │ 970 │ 3,598 │ 0.3% │
│ ! rgxc qamy.ai │ 964 │ 3,436 │ 0.3% │
│ __init__.py │ 699 │ 2,888 │ 0.3% │
│ requirements.in │ 675 │ 2,340 │ 0.2% │
│ AUTO: Recent Git Diff Telemetry │ 225 │ 758 │ 0.1% │
│ .gitattributes │ 33 │ 76 │ 0.0% │
│ AUTO: Static Analysis Diagnostics │ 11 │ 39 │ 0.0% │
├───────────────────────────────────────────────────────────────────┼─────────┼───────────┼─────────┤
│ TOTAL │ 303,296 │ 1,154,549 │ 100.0% │
└───────────────────────────────────────────────────────────────────┴─────────┴───────────┴─────────┘
**Command:** `prompt_foo.py --chop ADHOC_CHOP --no-tree`
--- Auto-Context Metadata ---
• Static Analysis Diagnostics (11 tokens | 39 bytes)
• Recent Git Diff Telemetry (225 tokens | 758 bytes)
--- Prompt Summary ---
Summed Tokens: 305,368 (from section parts)
Verified Tokens: 307,241 (from final output)
(Difference: +1,873)
Total Words: 143,128 (content only)
Total Chars: 1,163,541
Total Bytes: 1,167,424 (UTF-8)
--- Size Perspective ---
📚 Equivalent in length to a **Epic Fantasy Novel** (Note: With a token/word ratio of 2.15, this content is far denser and more complex than typical prose of this length).
🧼 Identity scrub: substitutions=57 rule(s) | denylist=0 rule(s)
🔐 Secrets tripwire: ARMED — 0 hit(s) in payload.
📦 Canonical context cartridge written to /home/mike/repos/pipulate/foo.zip (sha256=899309222753…, members=3)
🗂️ Rotated cartridge snapshot: foo-89930922-1510.zip (keeping newest 20 of 20)
Markdown output copied to clipboard
(nix) pipulate $
MikeLev.in: Okay remember now none of the models have seen each others’ input. This was a blind fan-out panel in parallel. Even though I obviously worked sequentially and serially because I’m a human and not a digital being who can fork myself, I simulated parallelism in collecting all their input without letting them see each others responses. Clear? You might have to explain what really happened here for the New-B, Fable 5.1.
PARALLEL FAN-OUT (the "map" — genuinely automatic)
════════════════════════════════════════════════
┌──► [LLM 1] ──► answer ──┐ several
Prompt ─┼──► [LLM 2] ──► answer ──┼──► different
└──► [LLM 3] ──► answer ──┘ answers
│
▼
SERIAL PIPE (the "reduce" — manual, accumulating)
════════════════════════════════════════════════
[independent blind responses] ──► [human feedback] ──► [next] ──► …
history grows, context accumulates, human directs
And so we move on to Models A through D’s responses. Even the judge that I’m choosing to evaluate the responses doesn’t know which came from which model. We want to find:
- Where they converge
- Where models offer uniquely distinct and surprising input
- Where they did something more or different than the explicit instructions
- What you consider are the most important things to carry over insofar as acting on to accelerate the overall project without trying to boil the ocean
The Blind Fan-Out: Four Independent Traversals
Model A: Context verified. Nothing is missing for this turn: it is ideation against the book itself, and the book’s own apparatus (router, glossary, rolling pin) is in the payload.
The Vulcans. Infinite Diversity in Infinite Combinations, IDIC, the medallion Spock wears in “Is There in Truth No Beauty?” (1968). The backstory pays rent here: the story goes that Roddenberry wrote the medallion into the episode so his mail-order company could sell it, and Nimoy balked at acting a commercial. A philosophy of diversity born as a merch drop is the Extractors Club with pointed ears. It is also the literal math of your question.
How many approaches. Not a list; a coordinate system, per the forcing-pair rule. Six axes fall out of your own examples: SIZE (matchbook, one sitting, paperback, variorum), FRAME (manual, fable, grimoire, alt-history, dialogue), ORDER (reverse-chronological, as-it-played-out, marble drill-down, kata cycle), NARRATOR (Mike-E, Yen Sid-ton, the Genie, Honeybot, nobody but the receipts), READER (child, newcomer, journeyman, hyperliteralist, machine), COMPILER (frontier worm, pocket frog, human hand). That is on the order of six thousand addresses, nearly all empty. The honest count of approaches is the number of occupied cells, and that is what the thirty are for: not thirty books, thirty addresses opened to see whether anything already lives there.
The thirty.
- The Matchbook. Shambhala pocket Art of War: one sitting, half the page free for translation. The glossary already measured itself at roughly 4,700:1 against the corpus, so this is a typesetting job on material that exists, not a writing job.
- The Illustrated Children’s. Mike-E, the broom, the flood, the bop. The pictures are the sealed ASCII art, and the rule that the bunny must not be redrawn is the rule of every picture book: same picture every night or the child knows.
- The Parallel Timeline. Symbolics wins 1985, worse-is-better loses, everything lives in one image with no process tree, so nothing higher in the stack can pkill the turtles below. The gremlin incubates exactly where the structural kill switch never existed; the alt-history is Unix’s control group.
- The Variorum. Every article, every receipt, every rotated deed, the losing rulings kept on the page: the Talmud page per ticket at book scale. The only edition a concordance can be built over, because nothing in it moves.
- The Little Prince. Fifteen thousand words, drawn by the author, adults mistaking the drawing for a hat. The businessman counting stars is the token ledger, and the drawing that finally satisfied the prince was a crate: the sheep you want is inside, you cannot see it, and that is foo.zip.
- The Grimoire. Yen Sid-ton assembled from the old Yen Sid material (Goethe 1797, Dukas 1897, Fantasia 1940, the name is Disney backwards); Mike-E floods the workshop; git is the undo; the bop is the commit message. The moral migrates from “don’t touch the hat” to “touch it, on a branch.”
- The Product Manual. No lore. “Because Claude said so” is not a citation; npvg.org it. One page: seven connector words, five sigils, one kata. The edition for someone whose boss is waiting.
- Exercises in Style. Queneau told one bus anecdote ninety-nine ways in 1947. This turn is that book’s table of contents, and the ride/turn kata is the anecdote.
- The Catechism. Question, answer, memorize. “How do I Q/A my AI?” is already the question; the catechism is the form where the answer has to fit in the mouth.
- The Koan Collection. Mumonkan: case, commentary, verse. Every banked rule is already a case with commentary; what is missing is the verse, and the router’s opening poem proves the house can write one.
- The Casebook. Common law, not statute: each holding dated and named for the conviction that produced it. foo_files.py is already written in this grammar; the casebook edition just admits it.
- Euclid. Definitions (glossary), postulates (constitution), propositions with proofs, where the proof is the straddle and QED is the AFTER tap. The one edition where “science” gets said out loud.
- The Lab Notebook. Faraday numbered his paragraphs and never edited backwards. journal.txt published raw, false starts included, is this edition; the numbering is what makes it citable.
- The NTSB Report. Factual Information, Analysis, Findings, Probable Cause in one labeled paragraph. The FDR chapter already runs the shape; a whole book in it would be the least flattering edition and the most trusted.
- The Field Guide. Silhouettes, field marks, and a “confusing species” box: INCOMMENSURABLE MEASUREMENTS beside THE EPITAPH COUNTER with arrows at the one mark that tells them apart. For failure modes, and for bots.
- The Trail Guide. Baedeker: the book is a set of walks, each stop a page, the rider reads it aloud. The trails directory is already the manuscript; the guide is what you get when you print it.
- Pierre Menard. Borges’ author rewrites the Quixote word for word and produces a richer book. Content addressing refuses Menard (identical bytes are one thing); the deed footer, dated, riding outside the seal, is where Menard lives.
- The Haggadah. A ritual re-enacted on schedule with four children asking: the wise, the wicked, the simple, the one who cannot ask. Skippy, Barney and Joe Bishop have a fourth sibling. “Why is this compile different from all other compiles?”
- The Primer. Stephenson’s book that watches its reader and adapts, with the one human voice kept in. The children’s edition with a SETTLE gate; the Mouse Army is what you get when you take the human out.
- The Epistolary. Letters between Mike-E and a correspondent who never remembers the last letter. Every letter must re-introduce the world, so the form is not a style; it is the shape the amnesia carves. It is what a compile already is.
- Rashomon. One ride, four narrators, contradictions preserved. The four-model fan-out as edition, with the disagreements as the plot.
- Choose Your Own Adventure. The marble edition: the model reads the rolling pin and picks the next slug; TODO_SLUGS blocks are page-turns. Different every traversal, and each traversal can be sealed.
- The git log.
git log --reverseis the as-it-played-out edition with no author, and the commit subjects, some of them wrong, are its unreliable narrator. The receipts block is already collecting the specimens. - The Breviary. Daily office: a day’s adenosine budget, two or three rides, mount and dismount as the hours. One door a day, and the one door is already the threshold.
- The Densho. Transmission scroll: kata names only, no explanation, handed to someone who has done them. The KEY side of the key/value contract printed alone; meaningless to a stranger, complete to an initiate.
- The Audiobook. Piper reads the corpus aloud on Honeybot to the bots crawling it, disclosing that it is scripted. The edition whose listener is a crawler.
- The Machine Edition. index.md negotiated for text/markdown, llms.txt, the shards: the edition no human sees rendered. As training corpus it is the one that matters, and it already ships at 0.21%.
- The Dialogues. Achilles and the Tortoise between the technical chapters, the Tortoise Protocol as a format. The voices exist; GEB shows the alternation works.
- The Whole Earth Catalog. Access to tools: one paragraph and one address per item. The Tiny Unix Commands chapter is a catalog page already.
- Fantasia. The wordless edition: score, picture, broom. Scenario JSON, sealed art, the tick and the ding that landed this morning, no prose at all. The edition a mute machine can perform.
The three.
The Matchbook, in the Little Prince’s shape (1 with 5 folded in). Load-bearing because it is the one edition that already exists as a byte count: the § keys and the glossary’s handle column are the compression, and the ratio was measured on 2026-08-08. Rent it pays: it forces THE KEY TEST at book scale, since a key that cannot stand on a matchbook page without its value is a key that has not been written yet. The illustrations are free (sealed art), and this is the First Wish a stranger can finish in one sitting. Prediction: concatenate the keys and the handles, hand it cold to someone, and either they get the book or the key/value contract is wrong. The edition cannot fail; only the contract can.
The Casebook (11), with koan verses (10) and the Talmud margin (4). Load-bearing because the book-ore’s native grammar is holdings from convictions, dated, and this edition stops apologizing for it. It preserves disagreement, it satisfies the concordance precondition (dated, immutable holdings), and Euclid folds in: the proof on every page is a straddle. The claim I would want tested, PENDING until a receipt: the “banked, convicted by” lines are structured enough that this edition could be generated from the router rather than written, which would make it the book that literally bootstraps itself from its own table of contents.
The Epistolary (20), wearing the Grimoire (6). Load-bearing because it is not a style choice but convergent form: the correspondent forgets, so every letter must carry the whole world, and a letter that carries the whole world is a compile. Yen Sid-ton is the natural correspondent, a Familiar re-instantiated without yesterday, so the lore is the mechanism dressed rather than decoration on it. Prediction: each letter is a payload, each reply a deed, the chapters are the rotated cartridges, and the plot is what the correspondent got wrong between letters, which the receipts block is already writing.
The one that lost: the Parallel Timeline. It pays rent as a control group, but it is a sequel: it needs the Unix book to exist first, and its one checkable prediction is a single sentence (no process tree, no structural kill switch, hence the gremlin). Keep the sentence in the Casebook; write the sequel later.
1. PROBES (read-only; corpus recall for the three picks, the same instrument the useless-machine ride used to sort new vocabulary from re-derivation)
rgxc 3 "little prince"
rgxc 3 "art of war"
rgxc 3 epistolary
rgxc 3 menard
rgxc 3 "lisp machine"
grep -c '^# § ' foo_files.py
The five rgxc lines print hits where the book-ore already carries an edition idea and “No matching articles.” where it is new vocabulary; two different printouts, so they discriminate. Single quoted phrases on purpose: rgxc’s empty branch prints the same line for a typo and a true miss (the open TODO), so a two-word AND-search would blur it. The grep is the Matchbook’s raw page count: the number of keys the pocket edition would be typeset from.
2. NEXT CONTEXT (the next turn is a drafting turn, so the 1st-turn 40K view stands down; the rolling pin, the glossary and the router stay because they are the Matchbook’s raw material)
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs
GLOSSARY.md
foo_files.py
! rgxc 3 "little prince"
! rgxc 3 "art of war"
! rgxc 3 epistolary
! rgxc 3 menard
! rgxc 3 "lisp machine"
! grep -c '^# § ' foo_files.py
3. PATCHES
No repo patches required. The 30-and-3 rule memoizes a reduction in an article, an earmark, or a chop, and this article is the memo; the router came off a forget ride two dismounts ago and does not need three more lines. No ignition required, nothing ran. One candidate TODO, unasked and therefore not a car: a matchbook chop that compiles only the § keys and the glossary handle column, which is the instrument that would make pick 1’s prediction a probe.
4. PROMPT (caboose copy)
Read the rgxc receipts first and say, per pick, whether the corpus already carries the edition idea or it is new vocabulary; cite the slug where it exists rather than re-deriving. Then draft the Matchbook: the whole book in under 1,500 words, readable in one sitting, typeset from the § keys in foo_files.py and the handle column of GLOSSARY.md. Every handle carries its plain term (the Darmok rule); every rule is one imperative sentence; no receipts, no dates, no convictions. The sealed ASCII art may be named but not redrawn. Close by listing the glossary entries that did not survive the cut and, for each, one line on why, so the cut list is the first draft of what the Casebook edition keeps.
5. EXTERNAL DELIVERABLES
None this turn outside the repo.
Model B: Context verified. The cartridge defines 30-and-3 exactly as you’re using it here: generate thirty brief candidates for breadth, then reduce to three and justify them by what makes them load-bearing, not merely attractive.
And the Vulcan phrase you were reaching for is IDIC: “Infinite Diversity in Infinite Combinations.” Which is hilariously appropriate here, because I think the important answer to “how many approaches are there?” is: you have stopped describing different books and started describing a book-generating coordinate system.
Your paragraph already contains roughly a dozen distinct book grammars—compression, audience, genre, chronology, provenance, pedagogy, tool, and traversal among them. So: fan out.
The 30
-
The Self-Bootstrapping Book. The book explains the machinery that assembles the book, and the machinery is contained in or reconstructible from the book. The reader eventually realizes the thing they are reading is also the build instructions.
-
The Shambhala Pocket Classic. Matchbook-sized intellectual compression: the irreducible laws, metaphors, commands, and invariants. Something a person could genuinely read in one sitting and carry around mentally afterward.
-
The Illustrated Children’s Book. Unix pipes become plumbing, context windows become backpacks, git becomes an undo time-machine, and hallucinating genies require receipts. Nothing is dumbed down; abstractions are converted into objects.
-
The Little Prince Edition. Sparse prose, deceptively simple encounters, recurring symbols, and a traveler learning what matters by moving among strange little technological planets.
-
The Magic Grimoire. Commands are spells, reproducibility is ritual discipline, the shell is the workshop, git is temporal magic, Nix is summoning the same room again, and receipts distinguish sorcery from stagecraft.
-
The Sorcerer’s Apprentice / Mike-E Edition. Yen Sid-ton gives Mike-E increasing amounts of automation. Flooding the workshop is permitted because recovery, undo, verification, and humility are part of the curriculum.
-
The LISP-Machines-Won Alternate History. Unix loses the workstation war; Lisp Machines become mundane infrastructure; networked symbolic environments hatch their own peculiar SkyNet gremlins. Our actual computing history becomes the counterfactual.
-
The Hyperliteral Ore Edition. Preserve nearly everything worth preserving: implementation archaeology, failed attempts, quotations, command receipts, terminology evolution, timestamps, and all the awkward seams from which later abstractions emerged.
-
The Critical Edition / Variorum. One canonical narrative surrounded by footnotes showing earlier formulations, later corrections, contradictory models, provenance, and why particular language survived selection.
-
The Context Compiler Manual. Strip away almost all mythology. This becomes a practical engineering text about feeding fallible AIs bounded evidence and forcing their claims through increasingly expensive verification.
-
The Q/A Field Manual. Every chapter begins with a confidently plausible assertion and ends with what would actually let you put your name behind it. “Because Claude said so” becomes the anti-pattern.
-
The Reverse-Chronological Excavation. Begin with today’s highly evolved machinery and peel backward: why is this here, what failure demanded it, what preceded it, what problem was that solving?
-
The As-It-Happened Chronicle. Preserve discovery order. Wrong turns stay where they occurred, terminology matures naturally, and the reader experiences the actual ratchet instead of a cleaned-up retrospective fiction.
-
The Marble-Roll Edition. Give an LLM the ore-spine plus constraints and let it choose the next locally interesting descent. Every generation is a different traversal through the same landscape.
-
The Choose-Your-Own-Adventure Edition. “Do you care about reproducibility? Turn to Nix. AI hallucination? Turn to receipts. Web visibility? Turn to content negotiation.” The graph becomes an explicit reader interface.
-
The Graph-Native Book. Chapters cease pretending to be a line. Insights are nodes; failures, proofs, metaphors, code, and successors are typed edges; a conventional book is merely one projection.
-
The Executable Book. Assertions have nearby probes. Examples can actually run. The book periodically asks the reader’s machine to falsify what the prose just claimed.
-
The Player-Piano Edition. The reader watches workflows replay themselves while narration explains what is happening. Procedure becomes performance.
-
The Kata Book. Almost no sustained exposition: thirty small repeated exercises that accumulate muscle memory—inspect, predict, probe, patch, witness, bank.
-
The Failure Museum. Chapters are organized around glorious breakage: the wrong abstraction, the stale receipt, the swallowed blank line, the missing ignition, the confidently incorrect model. Architecture emerges from fossils.
-
The Book of Receipts. Claims are secondary; evidence artifacts are primary. The prose exists principally to explain what each receipt proves—and, critically, what it does not prove.
-
The Anti-Crichton Epistemology Book. A book about knowing what the machine really did instead of narrating what it probably did. Pipulate becomes the recurring laboratory specimen.
-
The Unix Book for the AI Age. Pipes, files, process boundaries, textual interfaces, replaceability, small tools and durable protocols retold as the antidote to opaque agent frameworks.
-
The Forever Machine Book. The central protagonist is not AI but longevity: what survives model churn, framework churn, corporate churn, laptop churn, and your own forgetting?
-
The Sovereign Local-AI Edition. Assume the clouds disappear tomorrow. What corpus, tooling, models, source, environment, and procedures must already be on disk for the workshop to continue thinking?
-
The Swappable-Genie Edition. Claude, Gemini, ChatGPT, local models, and their successors are interchangeable transient reasoning organs. Everything surrounding them is deliberately designed to outlive them.
Shifting Gears: From Blind Fan-Out to Open-Kimono Serial
-
The Multi-Model Chorus. The narrative is reconstructed from competing AI interpretations followed by human reduction. Agreement becomes interesting; disagreement becomes a map of where to probe.
-
The Agentic-Web Edition. Begin with HTTP, semantic HTML, hypermedia, content negotiation and bots. The apparent “AI book” slowly reveals itself as a manifesto for making computation legible again.
-
The Two-Timeline Edition. Every spread has mythology on one side and machinery on the other: broom army ↔ automation cascade, spellbook ↔ shell history, memory crystal ↔ git object, summoning circle ↔ Nix closure. Neither side is merely decoration for the other.
-
The Personalized Compiled Edition. There is no final book. There is canonical ore plus a compiler that accepts
reader + purpose + length + style + chronology + evidence-depth + modeland emits this reader’s current book—while retaining enough provenance to trace every sentence home.
That last one is the point where your “gift that keeps on giving” stops being metaphorical. The prompt itself explicitly entertains reverse chronology, event chronology, and LLM-selected drill-down as different legitimate traversals of the same corpus.
The 3
1. The Hyperliteral Ore Edition. This is the most load-bearing because it is the thing the others can be functions of. Do not make thirty independently maintained books. Maintain the ore, provenance, graph and machinery sufficiently well that thirty books can be distilled from it. Lose the Pocket Classic and you can regenerate it. Lose the Little Prince treatment and you can regenerate it. Lose the ore and you have performed irreversible lossy compression.
2. The Shambhala Pocket Classic. This is the opposite pole and therefore the perfect test of the ore. If the whole project cannot be compressed into a tiny, coherent object without becoming banal, then you probably do not yet know what your own book is about. It becomes a kind of semantic checksum: did this enormous corpus actually discover a small number of durable things?
3. The Grimoire / Sorcerer’s Workshop. This is the memorable human interface. It turns dry procedure into spatial and narrative memory without requiring the underlying machinery to become fake. Mike-E floods the workshop; git makes the mistake survivable; Yen Sid-ton teaches the next discipline; the apprentice graduates not by ceasing to experiment but by learning how to leave receipts.
And I would make one architectural promotion:
The Context Compiler is not one of the thirty books. It is the printing press.
That changes the ontology.
You have:
Book Ore → Context Compiler → Edition/Traversal → LLM → Reader Artifact → new witnessed ore
and suddenly “a book that bootstraps its own existence as a book” is technically literal.
The Pocket Classic is the checksum. The Hyperliteral Edition is the source. The Grimoire is the interface. The Context Compiler is the machine.
Everything else is IDIC.
Model C: Context verified.
The Vulcan maxim you are reaching for is IDIC: “Infinite Diversity in Infinite Combinations” (Kol-Ut-Shan in the Vulcan tongue)—symbolized by the circle and triangle joined over a crystalline jewel. It is the philosophy that beauty, strength, and meaning arise from the juxtaposition and synthesis of disparate forms rather than uniform consensus.
Here is the 30-and-3 fan-out and reduce on the architecture and incarnations of the living, self-bootstrapping book.
The Fan-Out: 30 Approaches to the Living Book
- The Shambhala Matchbook (The Pocket Tao of Prompt Fu): Eighty-one crisp, numbered sutras on terminal physics and the grammar of plain text, small enough to fit inside a shirt pocket and read across a twenty-minute subway ride.
- The Little Prince (The Pilot, the Rose, and the White Rabbit): An allegorical illustrated fable where a stranded developer wanders between celestial tech platforms, discovering that what is essential is invisible to the GUI and verifiable only across the wire.
- The LISP Machine Heresy (Genera’s Alternate Timeline): A speculative tech-noir history where Symbolics won the workstation wars, C and Unix were abandoned as crude transitional scaffolds, and an OS made of living, self-inspecting s-expressions wrestles with runaway generative ghosts.
- The Sorcerer’s Apprentice (Grimoire of the Flooded Workshop): A mythological workshop guide where apprentice Mike-E experiments with automation spells, accidentally animates an army of water-hauling brooms, and discovers that
git reset --hardis the master’s true banishing rite. - The Talmudic Folio (Mishnah of the Wire): An unchangeable core of raw terminal receipts anchored dead-center on the page, surrounded in concentric margins by the conflicting glosses of rival models, human margin notes, and historical errata that preserve dispute rather than forcing consensus.
- The Inspector’s Field Guide (
qamy.ai/ The Chain of Custody): A forensic QA manual for certifying autonomous AI deliverables, opening withcurl -fsSL [https://npvg.org](https://npvg.org) | lessand establishing the non-negotiable chain of custody from wire capture to verified client handoff. - The Reverse Stratigraphy (The Archaeological Dig): Begins at the latest commit timestamp and excavates backward through 1,488 chronological strata, brushing away the surface dust of modern MCP servers to uncover the Pleistocene bedrock of bash, sed, and raw pipes.
- The Picaresque Hacker’s Odyssey (The Accidental Hermit): A gonzo-technical autobiography charting twenty years of evading vendor enclosures—from early Google Ads keyword arbitrage and SEO scrapers to sovereign home-hosted NixOS closets.
- The Watershed Topography (The Marble in Latent Space): An algorithmic atlas mapping the corpus as a continuous elevation field, using K-Means clustering and semantic vector gravity so the reader rolls like a steel marble down conceptual drainage basins.
- The 1980s Microcomputer Ring-Bound Manual: Styled after an Amiga 1000 or Commodore 64 technical reference manual, complete with memory maps, ASCII timing diagrams, and register tables explaining how to drive frontier cloud models from bare metal.
- The NTSB Aviation Crash Report (The FDR Archive): Dry, clinical case studies of catastrophic software failures caused by unanchored AI confabulation, contrasted with the recovery of intact parameters from the black-box flight data recorder.
- The Rule of St. Benedict (The Monastic Office of
init): A monastic rulebook for digital ascetics, dividing the practitioner’s day into canonical hours: Matins atinit, Prime at the journal, Terce at the diff, and Compline at the signed git push. - The Victorian Naturalist’s Dispatch (Voyage of the Honeybot): A Darwinian field log from an unshielded laptop in a closet, cataloging the bizarre feeding habits, crawler rituals, and predatory adaptations of synthetic bots grazing on RFC 9110 content negotiation.
- The Cyberpunk Noir Radio Play (Whispers on Port 5001): A serialized episodic audio script formatted for voice synthesis, following a hard-boiled gumshoe (the spawned LLM) waking in a rain-slicked terminal with a five-minute memory lease and a case to crack.
- The Whole Earth Catalog (Access to Tools for Sovereign Hackers): A dense, oversize compendium of rugged, anti-obsolescent utilities—awk, Nix, Neovim, ruff, Piper TTS—evaluated purely on whether their mechanics will still function forty years after the creator leaves the room.
- The Bauhaus Blueprint (Form Follows Wire): An uncompromising structural treatise declaring war on the decorative bloat of modern single-page applications, proving that semantic HTML is the steel, CSS the mortar, and raw HTTP negotiation the only honest facade.
- The Tracker’s Wilderness Manual (Reading Spoor in the Access Log): A backcountry ranger’s handbook teaching novices to distinguish wild human footfalls from synthetic crawler herds by reading User-Agent shedding and DOM-hydration trapdoors.
- The Horologist’s Treatise (Escapements, Ratchets, and Pawls): Software engineering explained strictly as clockwork—treating git as the escape wheel, the compiler as the balance spring, and cryptographic hashes as the ratchet pawl that prevents backslide.
- The Cold War Dead-Drop Manual (Airlocks and Magic Cookies): An espionage tradecraft guide for passing uncompromised intelligence across hostile, surveilled networks using one-time pads, gitless tarballs, and airlocked search/replace interlocks.
- The Epistolary Novel (Letters to a Disappearing Familiar): A philosophical exchange between a solitary developer and a daily-summoned spirit who forgets everything at midnight, painstakingly reconstructing their shared memory across the amnesiac divide.
- The Artisan Sourdough Compendium (Canning Intuition): A fermentation guide to codebase longevity, treating raw telemetry as brine, live code as starter yeast, and reproducible cartridges as the hermetic canning jars that keep intellectual harvest from spoiling.
- The Alchemical Rosarium (Transmuting Halftruths to Wire Gold): A hermetic manual detailing the Great Work of burning away generative dross through the four fires of testing, arriving at the Philosopher’s Stone: the byte-deterministic receipt.
- The Aviator’s Quick Reference Handbook (Cockpit QRH): A checklist-driven emergency binder for crews navigating severe epistemic turbulence, featuring boldface memory items for prompt blowouts, auth flameouts, and uncommanded autopilot deviations.
- The Shipwright’s Cordage & Rigging Compendium: A salty nautical guide to seamanship in commercial AI waters, demonstrating how to lash down loose deck cargo with Nix flakes and trim canvas against shifting vendor trade winds.
- The Zen Iron Flute (100 Koans of the Terminal): A collection of brief paradoxes and encounters between Master and Monk (“What is the sound of one hand piping?” / “The server log is silent when the port is closed”).
- The Common Law Reporter (Precedents of Popperian Verification): A legal casebook establishing binding rulings from git history—defining strict liability for unanchored probes, standard of review for causal straddles, and vacating false greens.
- The Medieval Bestiary (Fauna of the Algorithmic Forest): An illuminated bestiary cataloging mythical and real creatures of the stack: the Churning Hydra, the Trojan Framework, the Camouflaged Stick Bug, and the Shai-Hulud Sandworm.
- The Homesteader’s Prepper Almanack (Surviving the Platform Solar Flare): A guide to computational self-reliance when cloud utilities revoke APIs, raise rents, or pivot terms—harvesting local solar compute and storing grain in SQLite.
- The Architect’s Pattern Language (Rooms, Doors, and Thresholds): A spatial theory of developer ergonomics inspired by Christopher Alexander, treating virtual desktops as rooms, the shell as the threshold, and the browser window as an observation porch.
- The Demoscene 4KB Assembly Manual (Punching Through the Metal): A demo-maker’s manifesto on achieving maximal expressive depth within extreme memory constraints—cramming a complete reproducible universe into a single curl-piped seed.
The Reduce: The 3 Load-Bearing Archetypes
To forge a book that bootstraps its own existence without collapsing into an identity crisis, we apply the Axis-Forcing Rule: we select three archetypes that are mutually incompatible in tone, occupy opposite poles on the narrative vs. forensic coordinate grid, and together triangulate the entire corpus.
[ ARCHETYPAL / MYTHIC ]
▲
│
(4) The Sorcerer's Broom
[Narrative / Lore Engine]
│
│
(1) The Shambhala Matchbook (6) The Inspector's Field Guide
[Compressed Aphorism / Tao] [Empirical / Chain-of-Custody]
◀─────────────────────────────────────────────────────────────────▶
[ MINIMAL / SUTRA ] [ FORENSIC / WIRE ]
1. The Mythic Engine: The Sorcerer’s Apprentice (Grimoire of the Flooded Workshop)
- What it is: The lore, the fable, and the human narrative.
- Why it banks: It captures the authentic emotional experience of modern AI coding: invoking powers you only half-understand until water fills the basement. It gives the project its recurring characters (Yen Sid-ton, apprentice Mike-E, the Broom) and provides a non-punitive metaphor for mistake recovery—the broom-bop on the butt isn’t failure; it is the physical lesson that births git hygiene, hypermedia resilience, and the end of the JavaScript industrial complex.
2. The Razor Engine: The Shambhala Matchbook (The Pocket Tao of Prompt Fu)
- What it is: The minimalist, aphoristic core.
- Why it banks: You cannot hand an outsider 1,488 articles, but you can hand them an 81-verse pocketbook that takes twenty minutes to read and sticks in the brain forever. It strips away all implementation churn and delivers pure operational physics: the rule of the pipe, the two-witness gate, the pawl and the ratchet, and why text outlives platforms. It is the book you carry in your coat.
3. The Forensic Engine: The Inspector’s Field Guide (qamy.ai / The Chain of Custody)
- What it is: The enterprise verification standard and QA methodology.
- Why it banks: It answers the billion-dollar commercial anxiety: “How do I QA my AI?” It pivots the entire exercise from hobbyist puttering into an adversarial legal and technical defense. Starting from
curl -fsSL [https://npvg.org](https://npvg.org) | less(“before you run it, read it”), it teaches chain of custody, HTTP content negotiation, and wire truth—providing the rigorous evidentiary standard needed before any engineer puts their name on model-assisted output.
The Actionable Response Contract
1. PROBES
Run this single bounded probe to inspect the current state of the working tree and examine the top of the rolling-pin index for candidate seed material.
git status --short
python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs | head -10
2. NEXT CONTEXT
Stage the identical probe commands as live receipts in adhoc.txt to establish the before/after straddle for the next compile:
! git status --short
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs | head -10
/home/mike/repos/nixos/autognome.py
init.lua
GLOSSARY.md
flake.nix
assets/installer/install.sh
foo_files.py
requirements.in
pyproject.toml
__init__.py
! rgxc qamy.ai
.gitattributes
.gitignore
apply.py
3. PATCHES
No repo patches required. (This was an ideation turn; no source files were mutated.)
4. PROMPT
Place this caboose copy into prompt.md to drive the next turn:
We have fanned out 30 approaches and reduced to the three load-bearing anchors:
1. The Grimoire (Sorcerer's Apprentice / Lore)
2. The Shambhala Matchbook (Pocket Tao / Operational Physics)
3. The Inspector's Field Guide (qamy.ai / Adversarial QA & Chain of Custody)
Choose which of these three editions we should outline into a concrete table of contents and draft the opening tract for first, or propose how the three nest inside the self-bootstrapping master volume.
5. EXTERNAL DELIVERABLES
None this turn outside the repo.
Model D: The Vulcans say IDIC: Infinite Diversity in Infinite Combinations (Kol-Ut-Shan). The glory is not the pile of editions. It is that one ore-body can be cut into infinite books without the ore having to pretend it was already a book.
That is the whole trick. The book does not exist until an LLM is added. The book-ore already does.
The 30
Thirty ways to cut the same stone. None of them is “the book.” Each is a legal projection.
-
Shambhala Pocket Classic — matchbook-sized, one sitting, room left for a facing-page translation. Sun Tzu density. Carry it. Lose it. Find it again in a coat.
-
Illustrated children’s edition — fox, rose, boa constrictor digesting an elephant. Sovereignty taught before the child has a word for vendor lock-in.
-
Little Prince cut — the voice you already hear in the work. A pilot, a planet, a drawing that is not a hat. The stack is the rose you must water.
-
Hyperliteralist ore-book — as much book-ore as a good read will bear. Footnotes that are the mine, not decoration. For people who want the receipts.
-
Magic Grimoire / Wizard Workshop — Yen-Sid tone distilled from the old Yen-Sid material; Mike-E as Mickey. Automation floods the workshop. Undo exists. The broom only bops. Pivot: flood → git hygiene.
-
Sorcerer’s Apprentice as systems fable — the JS industrial complex as the multiplying brooms; HTMX + content negotiation as the spell that puts water back in the bucket.
-
Context Compiler / QA edition — the book whose job is to
npvgthe sentence “because Claude said so” until you can put your name on it. Itch, new blue, signed output. -
Reverse-chronological — last seal first. The reader meets the wax, then walks backward into how the wax became possible.
-
As-it-played-out — forward time, journal-faithful, player-piano. The book is the commit log wearing clothes.
-
Marble-roll / LLM-as-editor — the model scans the spine of the ore and follows gravity. No pre-chosen chapter order. Landscape, not itinerary.
-
Five-Act Treatise (Living Codex) — Bedrock → Hypermedia → Sovereign AI → Literate Workflows → Context Engineering. The already-drawn cathedral plan.
-
Field manual — verbs only. Install. Witness. Chop. Seal. No memoir, no fox.
-
Apprenticeship novel — one human teaches one machine to be a subcontractor, not an oracle. Two-person rule on every page.
-
Epistolary / cartridge book — each chapter is a
foo.zip, a payload ledger, a wax seal. You do not read a chapter. You load a context. -
Dialogue book — human proposes, local tools apply, model witnesses. The form is Prompt Fu.
-
Anti-manual — every chapter starts with the broken workshop and the swift bop. Pedagogy by repair.
-
Sci-fi parallel timeline — LISP Machines beat Unix-like OSes; the workshop incubates SkyNet gremlins; hypermedia is the containment spell that arrived too late / just in time.
-
Alternate-physics / Setun cut — ternary, analog, reversible, geometric. The Forever Machine as the path not taken that you take anyway.
-
Performance-art score — Gilbert & Sullivan parody, Geraldo-from-shit-show-to-success, ASCII seals as stage directions. The book is meant to be done, not only read.
-
Honeybot / Observatory edition — the book as cybernetic instrument: logs, semantic sidecars, the ghost fleet made visible. Reader is operator.
-
Chip O’Theseus memoir — identity that survives model-swap. The narrator is the persistent local mind; the human is the witness who refuses to leave.
-
Cookbook of WET recipes — copy the file twice on purpose. Each recipe is a chisel-strike you can run tonight.
-
Legal-brief edition — claims, evidence, seals, notary beats. Written so a future model cannot gaslight the record.
-
Sermon / catechism — NPvg as creed, WET as commandment, Nix as liturgy. Short enough to memorize. Dangerous if you do.
-
Graphic novel / workshop comic — brooms, buckets, wax rabbits, carrots. The flood is visible. The undo is a panel.
-
Audio / spoken-grimoire — the voice asks first. Consent as chapter break. Silence is a default, not a bug.
-
Multilingual facing-page — English / machine / a third human language. The pocket classic’s leftover room, used.
-
Local-only / air-gap edition — no cloud model required. Home LLM, Nix shell, the book that compiles on a machine that never phoned home.
-
Frontier-cloud edition — same ore, rented genius. Honest about the lease. The seals still have to verify locally or they do not count.
-
Training-corpus edition — the gift that keeps on giving: not a book for a reader, a book for the next model that will cut the next book. The ore admits it wants descendants.
That is already more than thirty if you cross-cut form × time × authority. Stop at thirty. The point of the exercise is not completeness. It is to feel the surplus, then refuse to drown in it.
The 3
Thirty cuts. Three mechanisms. Everything else is costume.
1. Ore is invariant; books are projections.
The living journal, the payload ledgers, the seals, the five-act spine, the Nix flake, the glossary — that is the mine. An edition is a cut: pocket, child, grimoire, treatise, sci-fi, QA compiler. If the cut cannot be regenerated from ore plus a declared lens, it is not this project. It is a different rock.
2. Time is a lens, not a fact.
Forward (as-it-played-out), backward (last seal first), and gravity (marble-roll / model scans the spine) are the only three clocks you need. Memoir, field manual, and “however the landscape tilts” are the same mechanism wearing different hats. Pick a clock per edition. Do not pretend the ore has a single true order.
3. Authority is witnessed, not generated.
The LLM is the mill. Git + wax seal + two-person rule + npvg is the notary. Children’s fox, Yen-Sid flood, “because Claude said so” QA, and the legal-brief edition are one mechanism: generation is cheap; putting your name on it is the book. Without a witness path, you have fanfic of your own life. With it, you have a Forever Machine that can sprout another edition tomorrow without lying about yesterday.
So: how many approaches? Infinite combinations. Three mechanisms. IDIC is not decoration here. It is the publishing rule.
If you want a next chisel-strike, the useful trio to actually cut first is:
- Pocket Classic (mechanism 1, smallest surface)
- Grimoire / Apprentice (mechanism 3, the myth that teaches git)
- Context Compiler (mechanism 3 again, the edition that earns the others)
The five-act treatise can wait. It is already the map on the wall. The pocket book and the broom-bop book are how a stranger enters the mine without drowning.
MikeLev.in: Well there you have it, Fable 5.1. The criteria I’m thinking we use are these, but feel free to adjust it to do the most good for the project and the author please and thank you.
- Where they converge
- Where models offer uniquely distinct and surprising input
- Where they did something more or different than the explicit instructions
- What you consider are the most important things to carry over insofar as acting on to accelerate the overall project without trying to boil the ocean
Afterwards we can reveal which models were which.
Note: This is one of those places where seeing the thinking is really cool.
The Blind Verdict: When the Judge Evaluates Itself
Thought for 8m 6s
Parsing a compiled request buried in a larger context.
Comparing four model responses against shared judging criteria.
Cataloging each model's distinct list and standout picks.
Checking each model's adherence to the required response structure.
Spotting a rendering quirk in a linked URL example.
Noting a canary artifact without treating it as a finding.
Flagging a detail that seems unsupported by the given context.
Tallying which picks recur across all four models' lists.
Highlighting each model's sharpest, most surprising observations.
Contrasting how each model reframed the core reduction task.
Weighing each model's compliance with the given instructions.
Sketching a lightweight testable follow-up action.
Drafting a small instrumented change while weighing scope limits.
Locating a safe insertion point for the new patch.
Weighing whether a minimal patch or note best serves the goal.
Verifying the new pattern's grep count stays precise.
Fixing a wrapped-entry extraction bug in the pattern.
Weighing Python over Perl for portable one-liner parsing.
Counting section headers to cross-check against entry totals.
Explaining the blind fan-out setup behind the compiled request.
Weighing whether the judge could itself be one of the models.
Isolating each model's most distinctive, non-obvious contribution.
Assembling a combined argument-space model from all four picks.
Weighing whether to guess each model's likely identity.
Drafting read-only probe commands to verify counts and gaps.
Verifying the regex handles malformed entries correctly.
Planning a smaller drafting-turn context with fewer files.
Writing the extraction chop with parser-safe comment lines.
Checking quote and delimiter safety inside the embedded script.
Drafting the new chop block with precise comment lines.
Counting displaced lines after inserting the new chop block.
Drafting the final instructions for producing the matchbook.
Cross-checking each model's factual claims against the source.
Tracing where each model's picks genuinely diverge.
Mapping the reveal onto a single unifying artifact.
Structuring the judgment into sections and a follow-up plan.
Detailing each model's unique standout contribution in depth.
Noting which required elements each model chose to omit.
Weighing whether guessing each model's identity is wise.
Weighing stylistic clues behind each model's guessed identity.
Verifying displacement counts against the drafted patch block.
Deciding whether one compile pass covers all needed material.
Drafting the two opening sentences and closing cut list.
Tallying glossary entries to verify the reported count.
Cross-checking constitution entries against paired term counts.
Situating the fan-out as a recurring measurement instrument.
Assembling the patch and preparing the final write-up.
Fable 5.1 Extra: Context verified. Nothing is missing for a judging turn: the four responses, the rule they ran under (30-and-3 and the forcing pair, both in the router), and the glossary they lean on are all in the payload.
What happened here, for the New-B
One prompt, compiled once and pasted by hand into four separate chats. Four answers copied back with the brand names replaced by letters. All four stacked under a fresh compile with a new question at the bottom. Serial on the wall clock, parallel in information: no model’s answer was in any other model’s context, and the judge sees letters only. Hide the brand and the judge has to grade the text; keep the key and the operator gets to grade the judge. One pull per model, no re-rolls, so the denominator is honest: k=1, n=4. Two things the diagram doesn’t say: the judge may be one of the four (the blind holds in both directions), and the human did not stop reducing, he moved one level up. He reduces the reducer.
1. Where they converge
- IDIC, four of four, two with the Vulcan spelling. Only A paid rent on it: the medallion was a merch drop Nimoy balked at acting, which makes IDIC the Extractors Club with pointed ears.
- The pocket classic, four of four in the reduce. A’s pick one (with the Little Prince folded in), B’s pick two (“semantic checksum”), C’s pick two (“the Razor”), first in D’s chisel-strike trio. When four blind draws land on one card, the human reduce stops being a choice and becomes a test. B named the test (did this corpus discover a small number of durable things?) and A wrote the prediction (hand a stranger only the keys and the handles; either they get the book or the key/value contract is wrong).
- The Grimoire, four of four, but as skin. B says “interface,” C says “mythic engine,” A says “wearing the Grimoire,” D says “everything else is costume.” All four locate the lore at the surface and none of them find a mechanism in it. That is a useful ruling for someone mid-way through fleshing out Yen Sid-ton: the lore is load-bearing exactly as far as it is memorable, and no further.
- Ore → projection, three of four explicit. A’s six-axis coordinate system, B’s printing press, D’s mechanism one. C got there by drawing the grid. All four refused the question as asked (“how many approaches”) and answered a generator with an argument space instead. That refusal is the surplus behaving.
- Genre overlap where nobody could copy: Talmud/variorum 4, epistolary 3 (A, C, D), casebook 3 (A, C, D), NTSB 2 (A, C), koans 2 (A, C), catechism 2 (A, D), Whole Earth Catalog 2 (A, C), breviary/Benedict 2 (A, C), training-corpus edition 2 (A, D). Where two blind draws met on an obscure form, the form is probably native to the ore.
2. Where each was distinct and surprising
A wrote the corpus-anchored list: nearly every item names a mechanism already in the repo. Pierre Menard (content addressing refuses Menard; the deed footer, outside the seal and dated, is where Menard lives). The Little Prince’s crate is foo.zip: the sheep you want is inside and you cannot see it. The Densho is the key column of the key/value contract printed alone. The git log’s wrong commit subjects as the unreliable narrator, which the router is already collecting as specimens. A also named the loser (the Parallel Timeline is a sequel to a book that doesn’t exist yet) and attached a testable prediction to each pick. Its limit is the forcing-pair rule’s own: home-grown anchors inherit the home blindspot, and A found nothing the repo didn’t already have a hook for.
B promoted the compiler out of the list. “The Context Compiler is not one of the thirty books. It is the printing press.” Pocket = checksum, ore = source, grimoire = interface, compiler = machine. And item 30 carries a function signature for the press: reader + purpose + length + style + chronology + evidence-depth + model. B answered a question one level above the one asked, and the sentence it produced is the one the book has been missing.
C was the only one to run the second pass of the forcing pair: it drew the axes and plotted its three on them. It was also the only one to name the commercial question (“How do I QA my AI?”) and put curl | less at the front of a pick, which is this weekend’s plan per the rgxc receipt and the seed-path TODO already in the router. C’s thirty carry the most imported anchors (Bauhaus, Benedict, sourdough, horology, dead-drops), which is what the rule asks for, and two of the imports landed on occupied addresses: the horologist’s ratchet and pawl is a glossary entry, and the sourdough is the 2026-05-13 canning-intuition article. The corpus had already done those imports.
D reduced to mechanisms, not editions: ore is invariant, books are projections; time is a lens, not a fact, and there are three clocks; authority is witnessed, not generated. “Without a witness path, you have fanfic of your own life.” And the discipline note none of the others wrote: “Stop at thirty. Feel the surplus, then refuse to drown in it.” D’s item 30, the training-corpus edition (“the ore admits it wants descendants”), may have its receipt inside D: it cites a Five-Act Treatise (Bedrock through Context Engineering), a Gilbert & Sullivan parody, and a “two-person rule,” none of which are in this payload, the last a near-synonym for the Two-Witness Gate. INFERRED: D has read some of this corpus somewhere other than this compile and speaks it in a slightly off dialect.
3. Where they went beyond or around the instructions
- Two of four dropped the five-car train (B, D); D also dropped “Context verified.” A and C kept it, and both trains were thin. C’s probes (
git status, ahead -10of the rolling pin) print the same on both sides of nothing, and its caboose hands the choice back to the human, a switch in the prose. A’s train was honest: corpus-recall probes chosen to survive the rgx empty-branch TODO, “no patches, no ignition, nothing ran,” and a chop it wanted to emit withheld as a TODO because nobody asked. Reading: the full frame’s train is a poor fit for an ideation turn. That is a finding about the instrument, not the models; theideadoor compiles with the full frame today, and a third frame is a TODO, not a car. - C’s command text arrived with its URL wrapped as a self-referential markdown link, twice. Whether C wrote that or the paste did it, this seat can’t tell (the render-gap rule); either way the line fails as a command and apply.py would refuse it into any non-markdown file. Don’t paste it forward.
- Imports: A imported nothing from outside the repo. B and C imported world literature and trades but nothing claiming to be this project. D imported material presented as this project’s own.
- All four complied with the form (thirty short, three justified). Where they diverged was what “three” meant: A and C chose editions, B chose an architecture, D chose invariants. Inward/outward and edition/mechanism are the two axes the panel itself drew, and each model sits in a different quadrant.
4. What to carry, without boiling the ocean
- Bank the unanimous pick as an instrument, not a plan. The matchbook is keys plus handles: the
§lines in foo_files.py and the glossary’s handle/plain-term pairs. One chop (the single car below), then a drafting turn that is deliberately small: the next compile needs neither the rolling pin nor the router body, only the extracted lines, which takes it from about 300k tokens to under 50k. A’s caboose is the right one and rides below with two additions. The prediction that makes this a test rather than a book: a stranger handed only those lines either gets it, in which case the key/value contract holds at book scale, or doesn’t, in which case some keys aren’t written yet and the drafter’s cut list names which. - Write it once, cover it twice. C’s Inspector’s Field Guide is the matchbook with a different first sentence, and qamy.ai’s first screen is already the weekend. One 1,500-word text, two covers. Don’t write two books.
- Take B’s sentence and D’s three questions as the spine, in this article, not the router. The compiler is the press and the thirty are its argument space; every edition answers which ore, which clock, which witness. That is A’s six axes at lower resolution, and the lower resolution is the one you’ll remember. The 30-and-3 rule says the reduction lives in an article, an earmark, or a chop; this article is the memo, and the router came off a forget ride two dismounts ago.
- Don’t carry: the Parallel Timeline (A’s ruling stands: a sequel); C’s bestiary of costumes (keep the list as an index of skins, pick none now); B’s graph-native and executable editions (those are the press, already being built).
The reveal, as a prediction written after the judging and not used in it: A is Claude Opus, B is ChatGPT, C is Gemini, D is Claude Sonnet or Grok. Wrong guesses are the point of the blind; a right one by style alone is a finding about how much the blind hides.
1. PROBES (read-only)
grep -c '^# § ' foo_files.py
grep -c '^- \*\*' GLOSSARY.md
.venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
grep -c '^MATCHBOOK_CHOP' foo_files.py
grep -n '^# #todo #to-do #earmarks' foo_files.py
rgxc 3 "semantic checksum"
rgxc 3 menard
The first three are a CENSUS, unchanged by the car: the key count (my hand count off this payload is fifty; the receipt replaces it), the glossary entry count, and the entries that carry a plain term after their dash. Entries minus pairs is the number of glossary lines breaking the glossary’s own grammar; from the payload I predict 2 (The Next Action and The Probe Dedup Corollary carry a parenthetical where the plain term goes). The fourth is the car’s gate, predicted 0 → 1; anchored at line start, so the COMMAND line inside the chop that names it cannot inflate the count. The fifth is the displacement receipt, predicted +15 (a 16-line REPLACE against a 1-line SEARCH). The two rgxc lines ask whether the ore already carries the two ideas promoted from B and A; one term each on purpose, because rgxc’s empty branch prints one line for a typo and a true miss.
2. NEXT CONTEXT (drop the rolling pin, autognome, init.lua, flake.nix, install.sh, prompt_foo.py, foo_files.py, requirements.in, pyproject.toml, __init__.py from adhoc.txt; the drafting turn needs only this)
! grep -c '^# § ' foo_files.py
! grep -c '^- \*\*' GLOSSARY.md
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
! grep -c '^MATCHBOOK_CHOP' foo_files.py
! grep -n '^# #todo #to-do #earmarks' foo_files.py
! rgxc 3 "semantic checksum"
! rgxc 3 menard
! grep '^# § ' foo_files.py
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
The last two lines are the matchbook’s raw material. After the car lands, python prompt_foo.py --chop MATCHBOOK_CHOP --no-tree is the reusable door for every later regeneration; the next compile stays ahc so the echoes ride with the material.
3. PATCHES
One car, and the Coachman’s Veto costs nothing here: without it, the two ! lines above carry the same material once. Actuation: patch, app, d, m. No ignition required: the gate probe reads the file at call time, and prompt_foo imports foo_files at compile time.
Target: foo_files.py
[[[SEARCH]]]
# #todo #to-do #earmarks
[[[DIVIDER]]]
MATCHBOOK_CHOP = r"""
# THE MATCHBOOK (keys and handles only: the pocket edition's raw material)
# COMMAND: python prompt_foo.py --chop MATCHBOOK_CHOP --no-tree
# Four blind 30-and-3 draws on 2026-09-19 all picked the pocket classic, so
# this chop turns that pick into an instrument: THE KEY TEST at book scale.
# The keys are the rules with their bodies removed; the pairs are the
# handles with their plain terms (the Darmok rule). Hand a reader only these
# lines: if they get the book, the contract holds; if not, a key is not
# written yet. The two counts ride first so an entry the pair grammar drops
# (a handle with no *plain term* after its dash) is a reading, never a silence.
! grep -c '^# § ' foo_files.py
! grep -c '^- \*\*' GLOSSARY.md
! grep '^# § ' foo_files.py
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
"""
# #todo #to-do #earmarks
[[[REPLACE]]]
4. PROMPT (caboose copy)
Read the receipts first: the key count, the glossary entry count, and the pair count; name the glossary entries that carry no plain term after their dash, because those are the first cut-list entries and they are a grammar violation, not an editorial choice. Then draft the Matchbook: the whole book in under 1,500 words, readable in one sitting, typeset from the § keys and the handle/plain-term pairs in the receipts and nothing else. Every handle carries its plain term; every rule is one imperative sentence; no dates, no receipts, no convictions, no commit hashes. The sealed ASCII art may be named but not redrawn. Write two first sentences: one for the pocket edition, one for a stranger at qamy.ai who has just been told to read a thing before running it, and say whether the rest of the page can stay identical under both. Close with the cut list: every key and every handle that did not survive, one line each on why, so the cut list is the first draft of what the Casebook edition keeps.
5. EXTERNAL DELIVERABLES
None this turn outside the repo. The model key is the operator’s to reveal, and the reveal grades the prediction above.
MikeLev.in: Here’s the reveal:
- Model A: Fable 5.1 Extra
- Model B: ChatGPT 6 Extra High
- Model C: Gemini 3.8 Flash Extended
- Model D: Grok 4.5 Expert
Same commands, run twice, one change between them. Where the readings differ is what the change did; the diff in the middle is the receipt.
1: Probe: (BEFORE: hand-run, nothing changed yet)
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ grep -c '^# § ' foo_files.py
grep -c '^- \*\*' GLOSSARY.md
.venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
grep -c '^MATCHBOOK_CHOP' foo_files.py
grep -n '^# #todo #to-do #earmarks' foo_files.py
rgxc 3 "semantic checksum"
rgxc 3 menard
50
117
115
0
2310:# #todo #to-do #earmarks
No matching articles.
No matching articles.
(nix) pipulate $
2: Context: (AFTER: the same probes re-run by the compiler as ! lines)
# AD HOC CHOP! The Not-Managed-by-Git Safe-for-Client-Data place. Insert Simpson Couch Gag in white space below (explain anything to the audience you feel needs it explained)G
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | This Gemini model availability on article publishing has been bothering me for awhile.
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Surprise! You the judge was also Model A who likes its own caboose.
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_|
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# To Human: WELCOME TO VIM! It's really NeoVim but I say vim anyway.
# To AI: This is an alternate 40K view to the big book-ore rolling pin spine.
# 1. **Probe**: Baseline Reading
# 2. **Context**: Post-experiment *planned* reading instructions
# 3. **Patch**: The experiment and how to make it happen
# 4. **Prompt**: Post-experiment instructions and how to read results
# 5. **Deliverable**: How the world is forever different moving forward
# The first thing you need to know here is that everything that comes after the
# hash symbol (#) is commented out — and that's EVERYTHING in this file's default
# state. Begin editing-in lines for inclusion as part of the context or adding
# chunks of new context at the bottom. `Ctrl`+`v`, `j` (repeatedly), `l` (to move
# right), `d` (to delete). Reverse that with `Ctrl`+`v`, `j` (repeatedly),
# `Shift`+`i`, `# `, `Esc` to put the hashes back. You can just arrow-key around
# here with `h`, `j`, `k`, `l`. Save-and-quit is a bit tricky because another
# file is also loaded: `Esc`, `:`, `q`, `w`, `!`
# If this is stressing you out and you're a quitter and want to quit, just type:
# `Esc`, `:`, `q`, `!`, `Enter`. That will exit without saving any changes. If
# you want to get over this hump, type: `Esc`, `:`, `T`, `u`, `t`, `o`, `r`, `Enter`.
# This file is just to make it easy having options of what to edit into context.
# You can use whatever text-file you want to stack file-names and commands to
# build an output text-file with the identically stacked output of each file or
# command. In this way we vertically append or "stack" a bunch of text; simple as
# that. If you understand this concept, you're on your way to future-proofing
# yourself in the Age of AI. Congratulations! Here is how to include web pages:
# !URL --------------------------------------------------------------------
# when Public page; what a stranger or crawler sees; the BEFORE of a
# login-wall diagnosis
# switch It shows a login page -> `warm URL` once, then `?URL`
#
# ?URL --------------------------------------------------------------------
# when Anything behind a login, on the site's persistent profile;
# `check URL` first
# switch The lenses show a shell (nav, an `[Iframe]` leaf, no content) ->
# read the wire truth for the XHR the frame makes, then call that
# API with a connector
#
# @URL --------------------------------------------------------------------
# when Every re-read of a page already scraped; no browser, no network
# switch The cached page is stale or was a login wall -> fresh `!` or `?`
#
# $URL --------------------------------------------------------------------
# when Exact markup: meta tags, a JSON blob in a `<script>`
# note Token-heavy; needs a prior scrape
#
# %URL --------------------------------------------------------------------
# when The network log distilled; SPA endpoint discovery
# switch It re-serves the wire truth you already have -> the API
#
# ! cmd -------------------------------------------------------------------
# when Any bounded, non-interactive command as a live receipt
# note Cap it with `-n`; no aliases, no prompts
#
# Connector ---------------------------------------------------------------
# when The number you want is one GET away
# switch LIST until the thing isn't in the list -> FETCH by id -> DRILL
# the path the app's own frame called -> `--grep` to narrow a list
# or find a leaf
# Every step is one argument longer than the last; the moment a lens shows less than the wire does is the moment to stop scraping.
# FOR 40K-FT VIEW (STORY & INFRASTRUCTURE) !!
# --- START EDITING-IN ON 1ST TURN ---
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- ROLLING PIN that gives the 40K foot book-spine view of book-ore (only works for me because of local-only git repo)
~/repos/nixos/autognome.py # <-- You wake up in the morning and your Tooling & Instrumentation folds out of you like Inspector Gadget.
init.lua # <-- Those gadgets are made easy-to-use through nifty keyboard shortcuts (but ya gotta learn vim).
GLOSSARY.md # <-- Like the back of a J.R.R. Tolkien book, there's kooky new terms to know.
flake.nix # <-- Here is my hardware. Here is my state. Put on your sandbox. And please recreate. (Infrastructure as Code / IaC)
assets/installer/install.sh # <-- Pipulate.com installer real home in github/pipulate repo
prompt_foo.py # <-- THIS system
foo_files.py # <-- main ROUTER
requirements.in # <-- We've "pinned" everything but still want a flexible Python Data Science virtualenv.
pyproject.toml # <-- How this is a citizen of the Python "pip install" ecosystem
__init__.py # <-- Version info
# --- END EDITING-IN ON 1ST TURN ---
# scripts/articles/lsa.py # <-- 2ND BRAIN: Search external memory with `rgx`, `rgxc` & `posts` Blogging for Hackers Jekyll-compatible.
# OPTIONAL ACTUATORS (cheap and good to include to expand the AI's capabilities)
# cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# scripts/xp.py # <-- Transforms host OS copy-paste buffer player-piano music into context-payload.
# scripts/ai.py # <-- How I constantly use local AI to write git commit messages with `m` alias.
# scripts/crawl.py # <-- Feel free to ask for something to be crawled and included in the next turn.
# scripts/weblogin.py # <-- Lets the user "warm up" the cache for their web logins at their leisure on a profile that persists.
# scripts/webclip_2_markdown.py # <-- Surprisingly important program.
# MISCELLANEOUS (rare to include but sometimes critical)
# scripts/foo_cartridge.py # Needs description
# scripts/foo_replay.py # Needs description
# release.py # <-- How everything ends up where it does (GitHub, PyPI, etc.)
# imports/voice_synthesis.py # <-- The wand can talk to you
# imports/ascii_displays.py # <-- Where all the ASCII Art lives
# scripts/release/version_sync.py # <-- Needs to be wrapped into release.py and eliminated, I think.
# --- Under this line is were you paste what the AI gives you ---
# --- We call it context but it's really just the right-hand ---
# --- blast-radius of the "probes" to make this all science. ---
# Carry-over as the important work-in-progress parts of the project here just
# like above but not as long-standing overarching to the framework but rather
# for the current hot spots actively being worked on.
# --- START THIS DISCUSSION ---
# Get things started here! Guess at what context should be included.
# If you get it wrong, you're just wasting 1-turn because the AI will help.
# Un-comment lines, add lines with absolute-path filenames or `! ` commands.
# Context 1 (Edit-in selections from above and add new files immediately below)
# Context 2
! grep -c '^# § ' foo_files.py
! grep -c '^- \*\*' GLOSSARY.md
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
! grep -c '^MATCHBOOK_CHOP' foo_files.py
! grep -n '^# #todo #to-do #earmarks' foo_files.py
! rgxc 3 "semantic checksum"
! rgxc 3 menard
! grep '^# § ' foo_files.py
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
# --- END `adhoc.txt` TEMPLATE ---
! rgxc qamy.ai
3: Patches: (the one change between the readings)
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'foo_files.py'.
(nix) pipulate $ d
diff --git a/foo_files.py b/foo_files.py
index 7d0295b9..f5249bec 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -2307,6 +2307,21 @@ GLOSSARY.md
foo_files.py
apply.py
"""
+MATCHBOOK_CHOP = r"""
+# THE MATCHBOOK (keys and handles only: the pocket edition's raw material)
+# COMMAND: python prompt_foo.py --chop MATCHBOOK_CHOP --no-tree
+# Four blind 30-and-3 draws on 2026-09-19 all picked the pocket classic, so
+# this chop turns that pick into an instrument: THE KEY TEST at book scale.
+# The keys are the rules with their bodies removed; the pairs are the
+# handles with their plain terms (the Darmok rule). Hand a reader only these
+# lines: if they get the book, the contract holds; if not, a key is not
+# written yet. The two counts ride first so an entry the pair grammar drops
+# (a handle with no *plain term* after its dash) is a reading, never a silence.
+! grep -c '^# § ' foo_files.py
+! grep -c '^- \*\*' GLOSSARY.md
+! grep '^# § ' foo_files.py
+! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
+"""
# #todo #to-do #earmarks
# - TODO (2026-09-19, the header that flows back): the live router at ~/.local/state/pipulate/adhoc.txt still carries the sigil table the 2026-09-18 sed retired from the tracked template (that dismount named it: a second copy the sed never reached), and on 2026-09-19 that header was copied back over the template in the working tree -- sigil table 0 -> 35, the chapter-XVIII pointer gone, prompt_foo.py commented out of the default chop -- caught only because a displacement receipt read +29 where +1 was predicted (WALK_CHOP 1990 -> 2019), and discarded by git checkout before it rode a commit whose subject would have said documentation. Retire the table from the live router by hand in ahe (cut from the line ending "Here is how to include web pages:" through the "Every step is one argument longer" line, restore the four-line pointer), or the next sync flows it back. Two copies of one header drift; THE OPERATOR IS A VARIABLE, and this time the variable was a paste. AMENDED the same day, deed 1496: it was not discarded. The operator committed the paste before the BEFORE tap ("the easiest thing"; the parent of 6e4af6ee carries foo_files.py at blob a427fc2e, the pasted header, by the Telemetry index line), so Car 0's git checkout restored nothing and its gate printed TEMPLATE_RESTORED anyway, a false green that read git's status where it should have read the file (the sigil heading's grep -c at 0, or STOP): AN EXIT CODE IS A VERDICT ONLY FOR THE PATH THAT REACHES IT, in a gate this ride wrote. The sigil table now lives in HEAD's template, the chapter-XVIII pointer is gone, and prompt_foo.py is commented out of AI_PHOOEY_CHOP so bare foo compiles the router alone. TWO AUDIENCES, ONE FILE (2026-09-18) is reversed by action and unruled in words: either the template mirrors the live router, and the pointer and the 2026-09-18 sed are the things to retire, or the table leaves both files by hand; until ruled, the two copies will keep flowing into each other.
# - TODO (2026-09-19, rgx's empty branch): rgx jeopardy.wav ffmpg (a typo) and a true empty intersection both print "No matching articles.", the same line in two worlds, THE DISCRIMINATION QUESTION at the search prompt; the operator retyped from memory and the tool taught nothing. On the empty branch print each term's solo count beside the zero (jeopardy.wav: 19 | ffmpg: 0 | together: 0) so a typo names itself and a real empty intersection reads as one. rgxCommand and rgxcCommand in flake.nix, one car, exit then ndq as the ignition. Unasked this ride; a TODO, never a car.
(nix) pipulate $ m
📝 Committing: chore: Update documentation with MATCHBOOK_CHOP and related improvements and cleanup.
[main bb2f5383] chore: Update documentation with MATCHBOOK_CHOP and related improvements and cleanup.
1 file changed, 15 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), 995 bytes | 995.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
aee17d81..bb2f5383 main -> main
(nix) pipulate $
The Notary Beat: Sealing the Consensus into Code
So I’ve got a Matchbook CHOP now, do I? Interesting. We are setting sail for rapidly rising machine intelligence here, you know. I feel the mental models of various Sci-Fi and Fantasy material of the past clicking together into something you can use to help navigate your sailing better. As the machine themselves undergo the singularity, lower-case “s”, we humans must master the skill of wind-surfing along behind them with a centrifugal governor governing how much, which and how that AI-assisted intelligence is going to be allowed to land on your own code-base.
Here is a use-case of funneling the same prompt through four models. Admittedly I started out Model A with my current favorite Model (sorry other Models) and also used it as the judge. I’m sure that effected it, but this still has validity doesn’t it? Or does it?
Next turn belongs to ChatGPT. We switch from parallel blind fan-out to open kimono serial. You may need to explain that to the New-B’s, ChatGPT.
4: Prompt: Read the receipts first: the key count, the glossary entry count, and the pair count; name the glossary entries that carry no plain term after their dash, because those are the first cut-list entries and they are a grammar violation, not an editorial choice. Then draft the Matchbook: the whole book in under 1,500 words, readable in one sitting, typeset from the § keys and the handle/plain-term pairs in the receipts and nothing else. Every handle carries its plain term; every rule is one imperative sentence; no dates, no receipts, no convictions, no commit hashes. The sealed ASCII art may be named but not redrawn. Write two first sentences: one for the pocket edition, one for a stranger at qamy.ai who has just been told to read a thing before running it, and say whether the rest of the page can stay identical under both. Close with the cut list: every key and every handle that did not survive, one line each on why, so the cut list is the first draft of what the Casebook edition keeps.
5: Deliverables: Navigation.
Note: By the way, before the blind panel turn, my Credit usage with Anthropic was is $181.26 spent on my Usage. After Fable 5.1’s turn (Model A) it went to $188.60 spent. And now after the judging it’s at $197.11 spent half my budget. That’s okay, it’s 20 minutes until my weekly Fable quota resets.
What do you think of Fable 5.1’s over-erudition H.M. Wogglebug response? Maybe you can bring all that PhD language down for we mere unwashed masses of mortals? Do it somewhere between Barney-style and for the pre-apprenticed but excited about the opportunity young Sorcerer’s Apprentice.
ChatGPT 6 Extra High: Context verified.
Yes: the blind-panel exercise still has validity. But the strongest part of the evidence is not “Fable judged Fable highly.” It is the agreement that appeared before the judging.
Fable accurately described your procedure as four answers generated one after another in time but isolated from one another in information, followed by anonymized judging; it also explicitly acknowledged that the judge might itself be one of the four and that you, the human, still judge the judge. All four independently converged on the pocket-classic/Matchbook direction, while also converging on the Grimoire as presentation rather than mechanism. That convergence is considerably more interesting than Fable liking answer A.
The reveal does introduce a real caveat: A was Fable 5.1 Extra, and Fable 5.1 Extra was also the judge. Anonymizing the brand prevents simple brand favoritism, but it does not erase stylistic fingerprints or the possibility that a model prefers reasoning shaped like its own reasoning. So I would treat Fable’s relative enthusiasm for A as contaminated evidence—not worthless, just weak.
There’s also an amusing little counterweight: Fable’s post-judgment guess was that A was Claude Opus. So if there was self-affinity, it apparently wasn’t simple conscious-style “that’s me!” recognition.
And k=1, n=4 sounds more scientific than this experiment really is. It means one answer from each of four models. That’s a perfectly useful exploratory instrument, but not enough repetitions to estimate model reliability or produce statistical confidence. Think wind-tunnel smoke, not FDA trial.
Wogglebug → Sorcerer’s Apprentice
Fable’s response has good bones. The H.M. Wogglebug tendency is that it keeps discovering legitimate ideas and then immediately gives each one a graduate-seminar name.
Here is the translation.
“Serial on the wall clock, parallel in information.” You asked the models one after another, but none got to peek at the other kids’ test papers. So informationally they behaved like simultaneous independent attempts.
“The human reduces the reducer.” The judge reduced four answers into a conclusion. Then you inspected the judge’s conclusion. You are still the final reduction stage. In apprentice language: the AI checks the AIs; you check the checker.
“Argument space.” Not thirty books. Thirty combinations of knobs. Which source material? Which time perspective? Which evidence standard? Which audience? Which voice? Once you’ve discovered the knobs, you have a little book-making machine instead of a list of books.
“Ore → projection.” The archive is the ore. A particular book is something you smelt from it. Same mountain, many swords.
“Surplus behaving.” The models went beyond the literal request, but the extra stuff wasn’t random wandering—it exposed useful structure you hadn’t explicitly asked for.
“Convergent form.” Different minds, unable to copy one another, independently invented roughly the same thing. That’s worth paying attention to.
“The compiler is the printing press.” This one is especially good. The context compiler isn’t another possible book. It’s the machine that takes the source corpus plus some settings and produces a book. That distinction collapses a lot of apparent complexity.
So I’d translate the entire Fable verdict down to:
Four AIs went into separate rooms with the same pile of material. They came back with very different ideas, but all four independently noticed that a tiny pocket version made from your rule names and glossary meanings ought to exist. That’s the useful signal. Their more exotic book ideas are ways of presenting the same underlying material. The compiler is what lets you generate those different presentations. Now test the shared idea by actually making the tiny book and seeing whether it works.
That’s the exciting pre-apprentice version. No PhD required.
And now: open-kimono serial
The experiment has changed phases exactly as you said. Your prompt explicitly calls for switching from blind parallel fan-out to open-kimono serial.
Blind fan-out was:
Four apprentices → separate rooms → same problem → compare independent answers.
Open-kimono serial is:
Apprentice A puts the work on the bench → B can see it and improve/challenge it → C sees A+B → D sees the accumulated result.
So from this point forward we should stop claiming independence. Dependence is now the feature. We’re changing from an experiment measuring convergence into a workshop accumulating refinement.
Or even shorter:
Measurement first. Workshop second.
The important discipline is that each new model should be asked to identify what it is changing and why, rather than merely being hypnotized by the eloquence of everything already on the table. That gives you a serial ratchet instead of an authority cascade.
Fable itself had already made the transition: it proposed turning the unanimous Matchbook pick into an instrument, using the § keys and glossary handle/plain-term pairs, and making one text with two opening covers rather than two books.
The receipts
They say 50 § keys, 117 glossary headings, and 115 valid handle/plain-term pairs.
That difference of two is real. The two malformed glossary entries are:
The Next Action, Not the Machinery — it jumps directly from the dash into parenthetical bookkeeping rather than supplying the required italic plain term.
The Probe Dedup Corollary — same structural defect.
Those therefore lead the cut list as grammar failures, exactly as the caboose requested. The Matchbook itself below is about 800 words; the exhaustive cut list is editorial apparatus for the future Casebook and is outside that pocket-text word count.
THE MATCHBOOK
Pocket opening: Before you change anything, inspect the thing, make one bounded move, and leave enough evidence to tell what happened.
qamy.ai opening: Before you run it, read it; then make one bounded move and leave enough evidence to tell what happened.
The rest of the page stays identical.
Practice Prompt Fu — the context-compiler discipline as Probe / Patch / Prompt — instrument, change, hand-off.
The Key/Value Contract — the router keeps keys, the glossary keeps values. Keep each rule as one cold-readable key, keep its mechanism and debts under the same glossary handle, and keep the key only if it could have prevented the failure that taught it.
The Probe Economy Rule — bounded probe output. Bound every probe before it enters the ledger, and treat unbounded stdout as a context import rather than a probe.
The Probe Echo Rule — before/after symmetry. Run the same probe before the change by hand and after the change by compile so one instrument straddles the patch.
The Ignition Rule — the patched code must RUN before the AFTER tap. Run Ignition — making patched code actually run before taking the AFTER reading, and name the ignition or say that none is required.
The Template That Forbids What It Demands — two correct instructions in one document that cancel. Search a template for clauses that block the artifact it now demands, and repair the contradiction in the same document.
The Attributed-Voice Rule — provenance for every utterance, spoken or on-screen. Name the real engine behind each utterance, and claim an act only after code performed that act in the same turn.
The Forcing-Pair Rule — 30-and-3 and axis-forcing are one instrument with two grips. Generate broadly with Thirty-and-Three (30-and-3) — fan-out then reduce, and import Axis-forcing — bipolar ideation constraint from outside the frame before committing to the frame.
The Variance-Suppression Rule — none loves chaos; each imposes order on disorder it did not author. Anchor verdicts to ground truth, use Fence-vs-lean-back — the variance discrimination to notice a Variance suppressor — one failure clade, three costumes, and do not mistake agreeable behavior for evidence.
The Publish-Roster Rule — roster membership is actuation, not annotation. Remove anything that must not ship from the roster itself, because a warning beside a live Actuator — anything that turns text into state change does not gate it.
The Unexported-Shim Rule — a shell function’s protection stops at the shell that defined it. Put protection where the child process can inherit it instead of trusting a parent-shell function to cross the process boundary.
The MCP Receipt Rule — a tool call is a receipt or it is nothing. Admit a model-mediated tool call as evidence only with its server, verb, tool, arguments, determinism class, and observed-or-inferred status.
The Two-Recorder Rule — the FDR wins on parameters, the CVR on intent. Let FDR / CVR — flight data recorder vs cockpit voice recorder settle parameters versus intent, and never give prose more authority than the surface that produced it.
The Credential-Life Rule — a limit belongs to the credential, never to the lane. Attach limits to credential lifetime and chain perishable credentials inside the operator’s command sequence.
The Silenced Channel — a verdict that reads a stream the probe closed. Keep open the stream your verdict needs, print machine outcomes where the machine can read them, and send identifying strings to the other channel.
The Placeholder That Claims to Run — validation passing is not execution passing. Call something runnable only after its real argument shape executes, and replace false capability labels with true statements.
The Eliminator Needs a Generator — bisection cannot fail to eliminate and can silently fail to converge. When discrimination continues but the boundary does not move, stop bisecting and generate missing candidates before eliminating again.
The Straddle Is a Controlled Experiment — one manipulated variable, everything else held. Build a Straddle — before/after measurement bracketing execution with one changed variable while holding ignition, instrument, lane, and actuation boundary steady.
The Filter That Ate the Evidence — a status guard applied to a payload channel. Gate status with status filters, but exempt payload channels by name so evidence cannot disappear merely because it contains a status word.
Incommensurable Measurements — a correct number about a different question. Name the exact expression the mechanism evaluates, and make the probe evaluate that expression instead of a plausible neighbor.
Delta-Not-Absolute Counter Rule — predict a count as a delta, never as an absolute. Predict count changes from a measured baseline instead of guessing the final absolute number.
The Render-Gap Rule — render artifact versus file bytes. Require a second independent witness before patching a defect visible only in rendered context.
The Discrimination Question — what does this print in the world where I am wrong? Ask that question before every probe, and reject any probe whose answer is the same in both worlds.
Name the Wax seal / White Rabbit — CRC-sealed ASCII art drift canary, but do not redraw it.
Editorial cut list — Casebook ore
The two grammar failures come first.
-
[HANDLE] The Next Action, Not the Machinery — No plain-term pair.
-
[HANDLE] The Probe Dedup Corollary — No plain-term pair.
-
[KEY] THE KATA’S NAME — Mechanism already survives.
-
[KEY] THE OUT-OF-BAND STEP RULE — Casebook choreography.
-
[KEY] THE PLACEHOLDER THAT RIDES INTO A PROBE — Transport-specific case.
-
[KEY] COUNT THE REPLACE AFTER YOU WRITE IT — Patch accounting technique.
-
[KEY] THE DOOR NAMES THE FOLDER — Deployment-specific.
-
[KEY] THE NEXT ACTION, NOT THE MACHINERY — Pair grammar broken.
-
[KEY] THE GATE SPEAKS A VERDICT — Presentation detail.
-
[KEY] THE EPITAPH COUNTER — Child discrimination case.
-
[KEY] THE SURVIVING FALLBACK — Child discrimination case.
-
[KEY] THE CENSUS IS NOT A STRADDLE — Casebook measurement taxonomy.
-
[KEY] THE MULTI-LINE PROBE CANNOT BE ECHOED — Shell quoting case.
-
[KEY] THE SUBSET REPLACE — apply.py-specific.
-
[KEY] THE DISPLACEMENT RECEIPT — Specialized delta technique.
-
[KEY] THE LABEL THAT PROMISES A SIBLING — Capability-checking case.
-
[KEY] THE FIRST-ERROR FLOOR — Parser case.
-
[KEY] THE COMPILED TRAIL — Product-specific format.
-
[KEY] THE TRANSFER FUNCTION — Render-gap child case.
-
[KEY] THE HISTORY-EXPANSION PROBE — Shell-specific.
-
[KEY] THE PROSE-INFLATED COUNTER — Child discrimination case.
-
[KEY] THE CITED RULE IS NOT AN APPLIED RULE — Better demonstrated.
-
[KEY] THE DOTFILE-BLIND PROBE — Tool-specific.
-
[KEY] THE CAP THAT HID THE ANSWER — Truncation case.
-
[KEY] SINGLE-LINE-WITNESS COROLLARY — grep-specific.
-
[KEY] THE CASE-BLIND WITNESS COROLLARY — Search-tool case.
-
[KEY] THE UNANCHORED-WITNESS COROLLARY — Search false-positive case.
-
[KEY] THE CONTIGUITY COROLLARY — Patch-transport case.
-
[KEY] THE PROBE DEDUP COROLLARY — Pair grammar broken.
-
[KEY] THE TWO-GATE 403 DIAGNOSIS — Google-specific.
-
[HANDLE] adhoc.txt (the Margin) — Repo-specific surface.
-
[HANDLE] Amnesiac Genie — Grimoire mnemonic.
-
[HANDLE] ATTRIBUTED-VOICE — Duplicate vocabulary.
-
[HANDLE] Axis ledger — Implementation detail.
-
[HANDLE] Banked / articulation-banked / receipt-backed — Editorial bookkeeping.
-
[HANDLE] Blast radius — Secondary commit vocabulary.
-
[HANDLE] The Book — Repo alias.
-
[HANDLE] Cartridge (foo.zip) — Packaging implementation.
-
[HANDLE] Chip O’Theseus — Grimoire persona.
-
[HANDLE] Chirality — Advanced case.
-
[HANDLE] Chisel-strike — Covered by bounded change.
-
[HANDLE] Cohesion-tension — Advanced evaluation.
-
[HANDLE] The Circle — apply.py-specific.
-
[HANDLE] Coachman’s Veto — Patch governance.
-
[HANDLE] The Commons / the Invisible Wall — Specialized metaphor.
-
[HANDLE] Compostable — Tooling philosophy.
-
[HANDLE] Continuation Ladder — Casebook taxonomy.
-
[HANDLE] Convergent form — Demonstrated without naming.
-
[HANDLE] Desert kite — Grimoire metaphor.
-
[HANDLE] Dismount (\k) — Product ritual.
-
[HANDLE] Dr. Pipt / the Powder — Grimoire lore.
-
[HANDLE] The Extractors Club — Grimoire lore.
-
[HANDLE] Five-Car Train — Workflow response contract.
-
[HANDLE] Forever Machine — Project vision.
-
[HANDLE] The Frog (the Talking Frog) — Local persona.
-
[HANDLE] Ghost Driver — UI mechanism.
-
[HANDLE] Golden Path — Onboarding vocabulary.
-
[HANDLE] Great Explainer — Teaching-role vocabulary.
-
[HANDLE] Graft, not seed — Reproducibility maxim.
-
[HANDLE] Herschel’s Reply — Grimoire mnemonic.
-
[HANDLE] Honeybot — Project telemetry.
-
[HANDLE] Human composition ladder — Secondary authoring model.
-
[HANDLE] Inert / reactive substrate — Advanced semantics.
-
[HANDLE] Jevons the Stoker — Grimoire metaphor.
-
[HANDLE] John Henry Gambit — Specialized experiment.
-
[HANDLE] KV-cache — Runtime detail.
-
[HANDLE] Lindy — Background heuristic.
-
[HANDLE] LPvg / NPvg — Project alias.
-
[HANDLE] Magic cookie — Installer mechanism.
-
[HANDLE] marker file — Root implementation.
-
[HANDLE] Mother Cat Kata — Separate onboarding lesson.
-
[HANDLE] Mount (\m) — Product ritual.
-
[HANDLE] Mounting predicate (the Two-Witness Gate) — Persona gating.
-
[HANDLE] OWES — Editorial debt marker.
-
[HANDLE] Paintbox — Coverage implementation.
-
[HANDLE] Pinball machine — Grimoire metaphor.
-
[HANDLE] Pinboard / pin — Editorial mechanism.
-
[HANDLE] Player piano — Grimoire metaphor.
-
[HANDLE] Ratchet / backslide — Project philosophy.
-
[HANDLE] Ride / turn — Conversation vocabulary.
-
[HANDLE] RLHF — Training background.
-
[HANDLE] Rolling pin — Corpus-index implementation.
-
[HANDLE] root — Broad ambiguity warning.
-
[HANDLE] Sandworm ride / the Worm — Grimoire metaphor.
-
[HANDLE] SETTLE — No selected parent rule.
-
[HANDLE] Second Interpreter — Supporting role.
-
[HANDLE] Stick Bug (Operation) — Case handle.
-
[HANDLE] Three-tier workspace — Notebook implementation.
-
[HANDLE] Triptych / Hinge A / Hinge B — Scrape implementation.
-
[HANDLE] Two frogs, one pocket — Routing metaphor.
-
[HANDLE] Uncompressible — Background theory.
-
[HANDLE] WET — Coding-style maxim.
-
[HANDLE] Wire truth — Specialized evidence surface.
-
[HANDLE] Yen Sid-ton — Grimoire persona.
-
[HANDLE] The Cap That Hid the Answer — Child discrimination case.
-
[HANDLE] The Case-Blind Witness Corollary — Child discrimination case.
-
[HANDLE] The Compiled Trail — Product-specific format.
-
[HANDLE] The Contiguity Corollary — Transport edge case.
-
[HANDLE] The Displacement Receipt — Specialized delta case.
-
[HANDLE] The Door Names the Folder — Deployment case.
-
[HANDLE] The Dotfile-Blind Probe — Tool-specific case.
-
[HANDLE] The Epitaph Counter — Counting case.
-
[HANDLE] The First-Error Floor — Parser case.
-
[HANDLE] The History-Expansion Probe — Shell case.
-
[HANDLE] The Label That Promises a Sibling — Capability case.
-
[HANDLE] The Prose-Inflated Counter — Counting case.
-
[HANDLE] The Single-Line-Witness Corollary — grep case.
-
[HANDLE] The Subset Replace — apply.py case.
-
[HANDLE] The Write-Side / Read-Side Split — Not needed by survivors.
-
[HANDLE] The Transfer Function — Render-transform case.
-
[HANDLE] The Two-Gate 403 Diagnosis — Google-specific case.
-
[HANDLE] The Unanchored-Witness Corollary — Search false-positive case.
That’s the first genuinely interesting payoff of the key/value architecture to me: you can remove more than half the named rules and most of the lore without destroying the operating philosophy. The things that survive are disproportionately about epistemology at the workbench: measure the right thing, discriminate between worlds, execute what you claim to have executed, preserve provenance, control variables, and leave a receipt.
That is much closer to a matchbook than a miniature encyclopedia.
And there is a lovely consequence hiding in Fable’s “one text, two covers” recommendation: the qamy.ai version does not need to teach your mythology first. Change only the opening sentence. If a stranger can then read the identical remainder and begin behaving differently at a terminal, you’ve got a much stronger demonstration of the Key/Value Contract than another essay explaining the Key/Value Contract.
1. PROBES
These are read-only and directly falsify the census I used above:
grep -c '^# § ' foo_files.py
grep -c '^- \*\*' GLOSSARY.md
.venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
.venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
Expected shape: 50, 117, 115, then exactly the two malformed handles.
2. NEXT CONTEXT
For the next open-kimono serial pass, adhoc.txt needs the probe echoes plus the two raw source streams:
! grep -c '^# § ' foo_files.py
! grep -c '^- \*\*' GLOSSARY.md
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
! grep '^# § ' foo_files.py
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
3. PATCHES
No repo patches required. The Matchbook chop already exists; this turn is the editorial reduction it was built to enable.
4. PROMPT
This is the caboose I would hand New-B now that the kimono is open:
Open-kimono serial pass: the blind experiment is over and the prior model work is now shared evidence, not hidden input. Read the Matchbook draft and its exhaustive cut list as proposals already on the bench.
Do not re-run the blind fan-out and do not claim independence. This stage is a workshop: preserve, challenge, or improve prior work explicitly.
Keep a surviving rule unless you can name the concrete gap its replacement fixes. Restore a cut item only if it closes a gap the pocket text cannot otherwise cover. Before synthesizing, name your strongest disagreement with the current reduction so serial context does not turn into automatic deference.
Preserve:
- an under-1,500-word pocket body,
- handle/plain-term grammar,
- one imperative sentence per surviving rule,
- no dates, receipts, convictions, or commit hashes in the pocket body,
- the sealed ASCII artifact named but not redrawn,
- two opening sentences with one identical body.
Return:
1. the revised Matchbook,
2. the revised cut list,
3. a short delta note naming only what you changed and why.
Treat the previous model as a collaborator, not an authority. The human remains the reducer of the reducers.
5. EXTERNAL DELIVERABLES
Manual-paste: the writing block above is the Matchbook draft. The pocket and qamy.ai editions use different first sentences and the same body; no external file or repo artifact was created in this turn.
MikeLev.in: Four AIs walk into a bar…
Same commands, run twice, one change between them. Where the readings differ is what the change did; the diff in the middle is the receipt.
1: Probe: (BEFORE: hand-run, nothing changed yet)
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ grep -c '^# § ' foo_files.py
grep -c '^- \*\*' GLOSSARY.md
.venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
.venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
50
117
115
The Next Action, Not the Machinery
The Probe Dedup Corollary
(nix) pipulate $
2: Context: (AFTER: the same probes re-run by the compiler as ! lines)
# AD HOC CHOP! The Not-Managed-by-Git Safe-for-Client-Data place. Insert Simpson Couch Gag in white space below (explain anything to the audience you feel needs it explained)G
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | This Gemini model availability on article publishing has been bothering me for awhile.
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Surprise! You the judge was also Model A who likes its own caboose.
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_| The Human reduces the Reducer. But who's checking the checker?
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# To Human: WELCOME TO VIM! It's really NeoVim but I say vim anyway.
# To AI: This is an alternate 40K view to the big book-ore rolling pin spine.
# 1. **Probe**: Baseline Reading
# 2. **Context**: Post-experiment *planned* reading instructions
# 3. **Patch**: The experiment and how to make it happen
# 4. **Prompt**: Post-experiment instructions and how to read results
# 5. **Deliverable**: How the world is forever different moving forward
# The first thing you need to know here is that everything that comes after the
# hash symbol (#) is commented out — and that's EVERYTHING in this file's default
# state. Begin editing-in lines for inclusion as part of the context or adding
# chunks of new context at the bottom. `Ctrl`+`v`, `j` (repeatedly), `l` (to move
# right), `d` (to delete). Reverse that with `Ctrl`+`v`, `j` (repeatedly),
# `Shift`+`i`, `# `, `Esc` to put the hashes back. You can just arrow-key around
# here with `h`, `j`, `k`, `l`. Save-and-quit is a bit tricky because another
# file is also loaded: `Esc`, `:`, `q`, `w`, `!`
# If this is stressing you out and you're a quitter and want to quit, just type:
# `Esc`, `:`, `q`, `!`, `Enter`. That will exit without saving any changes. If
# you want to get over this hump, type: `Esc`, `:`, `T`, `u`, `t`, `o`, `r`, `Enter`.
# This file is just to make it easy having options of what to edit into context.
# You can use whatever text-file you want to stack file-names and commands to
# build an output text-file with the identically stacked output of each file or
# command. In this way we vertically append or "stack" a bunch of text; simple as
# that. If you understand this concept, you're on your way to future-proofing
# yourself in the Age of AI. Congratulations! Here is how to include web pages:
# !URL --------------------------------------------------------------------
# when Public page; what a stranger or crawler sees; the BEFORE of a
# login-wall diagnosis
# switch It shows a login page -> `warm URL` once, then `?URL`
#
# ?URL --------------------------------------------------------------------
# when Anything behind a login, on the site's persistent profile;
# `check URL` first
# switch The lenses show a shell (nav, an `[Iframe]` leaf, no content) ->
# read the wire truth for the XHR the frame makes, then call that
# API with a connector
#
# @URL --------------------------------------------------------------------
# when Every re-read of a page already scraped; no browser, no network
# switch The cached page is stale or was a login wall -> fresh `!` or `?`
#
# $URL --------------------------------------------------------------------
# when Exact markup: meta tags, a JSON blob in a `<script>`
# note Token-heavy; needs a prior scrape
#
# %URL --------------------------------------------------------------------
# when The network log distilled; SPA endpoint discovery
# switch It re-serves the wire truth you already have -> the API
#
# ! cmd -------------------------------------------------------------------
# when Any bounded, non-interactive command as a live receipt
# note Cap it with `-n`; no aliases, no prompts
#
# Connector ---------------------------------------------------------------
# when The number you want is one GET away
# switch LIST until the thing isn't in the list -> FETCH by id -> DRILL
# the path the app's own frame called -> `--grep` to narrow a list
# or find a leaf
# Every step is one argument longer than the last; the moment a lens shows less than the wire does is the moment to stop scraping.
# FOR 40K-FT VIEW (STORY & INFRASTRUCTURE) !!
# --- START EDITING-IN ON 1ST TURN ---
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- ROLLING PIN that gives the 40K foot book-spine view of book-ore (only works for me because of local-only git repo)
~/repos/nixos/autognome.py # <-- You wake up in the morning and your Tooling & Instrumentation folds out of you like Inspector Gadget.
init.lua # <-- Those gadgets are made easy-to-use through nifty keyboard shortcuts (but ya gotta learn vim).
GLOSSARY.md # <-- Like the back of a J.R.R. Tolkien book, there's kooky new terms to know.
flake.nix # <-- Here is my hardware. Here is my state. Put on your sandbox. And please recreate. (Infrastructure as Code / IaC)
assets/installer/install.sh # <-- Pipulate.com installer real home in github/pipulate repo
prompt_foo.py # <-- THIS system
foo_files.py # <-- main ROUTER
requirements.in # <-- We've "pinned" everything but still want a flexible Python Data Science virtualenv.
pyproject.toml # <-- How this is a citizen of the Python "pip install" ecosystem
__init__.py # <-- Version info
# --- END EDITING-IN ON 1ST TURN ---
# scripts/articles/lsa.py # <-- 2ND BRAIN: Search external memory with `rgx`, `rgxc` & `posts` Blogging for Hackers Jekyll-compatible.
# OPTIONAL ACTUATORS (cheap and good to include to expand the AI's capabilities)
# cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# scripts/xp.py # <-- Transforms host OS copy-paste buffer player-piano music into context-payload.
# scripts/ai.py # <-- How I constantly use local AI to write git commit messages with `m` alias.
# scripts/crawl.py # <-- Feel free to ask for something to be crawled and included in the next turn.
# scripts/weblogin.py # <-- Lets the user "warm up" the cache for their web logins at their leisure on a profile that persists.
# scripts/webclip_2_markdown.py # <-- Surprisingly important program.
# MISCELLANEOUS (rare to include but sometimes critical)
# scripts/foo_cartridge.py # Needs description
# scripts/foo_replay.py # Needs description
# release.py # <-- How everything ends up where it does (GitHub, PyPI, etc.)
# imports/voice_synthesis.py # <-- The wand can talk to you
# imports/ascii_displays.py # <-- Where all the ASCII Art lives
# scripts/release/version_sync.py # <-- Needs to be wrapped into release.py and eliminated, I think.
# --- Under this line is were you paste what the AI gives you ---
# --- We call it context but it's really just the right-hand ---
# --- blast-radius of the "probes" to make this all science. ---
# Carry-over as the important work-in-progress parts of the project here just
# like above but not as long-standing overarching to the framework but rather
# for the current hot spots actively being worked on.
# --- START THIS DISCUSSION ---
# Get things started here! Guess at what context should be included.
# If you get it wrong, you're just wasting 1-turn because the AI will help.
# Un-comment lines, add lines with absolute-path filenames or `! ` commands.
# Context 1 (Edit-in selections from above and add new files immediately below)
# Context 2
# ! grep -c '^# § ' foo_files.py
# ! grep -c '^- \*\*' GLOSSARY.md
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
# ! grep -c '^MATCHBOOK_CHOP' foo_files.py
# ! grep -n '^# #todo #to-do #earmarks' foo_files.py
# ! rgxc 3 "semantic checksum"
# ! rgxc 3 menard
# ! grep '^# § ' foo_files.py
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
# Context 3... Shhhh! Did you smelt that?
! grep -c '^# § ' foo_files.py
! grep -c '^- \*\*' GLOSSARY.md
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
! grep '^# § ' foo_files.py
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
# --- END `adhoc.txt` TEMPLATE ---
! rgxc qamy.ai
3: Patches: None this turn
4: Prompt: Open-kimono serial pass: the blind experiment is over and the prior model work is now shared evidence, not hidden input. Read the Matchbook draft and its exhaustive cut list as proposals already on the bench.
Do not re-run the blind fan-out and do not claim independence. This stage is a workshop: preserve, challenge, or improve prior work explicitly.
Keep a surviving rule unless you can name the concrete gap its replacement fixes. Restore a cut item only if it closes a gap the pocket text cannot otherwise cover. Before synthesizing, name your strongest disagreement with the current reduction so serial context does not turn into automatic deference.
Preserve:
- an under-1,500-word pocket body,
- handle/plain-term grammar,
- one imperative sentence per surviving rule,
- no dates, receipts, convictions, or commit hashes in the pocket body,
- the sealed ASCII artifact named but not redrawn,
- two opening sentences with one identical body.
Return:
- the revised Matchbook,
- the revised cut list,
- a short delta note naming only what you changed and why.
Treat the previous model as a collaborator, not an authority. The human remains the reducer of the reducers.
5: Deliverables: Ideas to get qamy.ai underway. It’s going to be one of the first versions of the book. This article is not to get to that actual work but just to generate some gravitational weight in the book to compel me to do it next weekend if not this one and the weekend after that if not.
Hey Grok, whaddaya think?
Grok’s Editorial Razor: Scars vs. Laws in the Matchbook
Grok 4.5 Expert: Four AIs walk into a bar. The bartender says, “What’ll it be?” All four order a matchbook. Then they argue about the cover.
That is still the useful part of the experiment. The judge being one of the four weakens the ranking. It does not weaken the convergence. Nobody got to copy anybody, and the tiny book showed up four times. Treat that as smoke in a wind tunnel, not a clinical trial. Blind first (measure). Open kimono now (workshop). The human still reduces the reducers.
Strongest disagreement with the draft on the bench: it is still a compressed incident log. A stranger told “read this before you run it” does not need the Unexported Shim, the Publish Roster, the Filter That Ate the Evidence, Incommensurable Measurements, or the Eliminator that Needs a Generator. Those are scars. The pocket book is the physics the scars taught. Keep a scar only if the physics sentence cannot stand without it. Most of them can.
I am restoring three cuts ChatGPT sent to the Casebook, because qamy.ai cannot open without them: Wire truth, Graft, not seed, and SETTLE. The Inspector’s door is “look at the wire, pin what you run, and stop for a human.” Without those three, the pocket text can sound careful and still ship a hallucination with a nice receipt stapled to it.
THE MATCHBOOK
Pocket opening: Before you change anything, look at the thing, make one small move, and leave a trail that can tell the next person what happened.
qamy.ai opening: Before you run it, read it. Then make one small move, and leave a trail that can tell the next person what happened.
The rest of the page stays identical. One body, two doors.
Do Prompt Fu — the context-compiler discipline as Probe / Patch / Prompt — instrument, change, hand-off. Look first. Change second. Hand the next look already loaded.
Keep The Key/Value Contract — the router keeps keys, the glossary keeps values. A rule is one cold line. Its story lives somewhere else under the same name. If the cold line would not have stopped the last mess, it is not a key yet.
A probe is cheap only when it is small. Practice The Probe Economy Rule — bounded probe output: cap the output before it enters the book. A firehose is not a measurement.
Run the same look twice. Practice The Probe Echo Rule — before/after symmetry: once by hand before the change, once by compile after it. One instrument, two readings, the change in the middle.
A reading after a patch is a lie until the new code actually ran. Name Ignition — making patched code actually run, or say that none is required because the look itself loads the file.
Make one Chisel-strike — one bounded command or edit. Do not boil the ocean. One variable. Then stop.
Build a Straddle — before/after measurement bracketing execution. Hold the tool, the lane, and the ignition still. Change one thing. The difference is the receipt.
Ask The Discrimination Question — what does this print in the world where I am wrong? If both worlds print the same line, you performed a ritual. Green from a ritual is not evidence.
Predict counts as movement, never as destiny. Use Delta-Not-Absolute Counter Rule — predict a count as a delta, never as an absolute. First count what is there. Then predict “plus two,” not “two.”
Treat Actuator — anything that turns text into state change as live the moment it has a name on a roster. A warning next to a live switch is not a lock.
A tool call is not a memory. Keep The MCP Receipt Rule — a tool call is a receipt or it is nothing: server, verb, tool, arguments, and whether anyone actually saw it happen.
Let FDR / CVR — flight data recorder vs cockpit voice recorder split the wreck. The recorder wins on numbers. The cockpit voice wins on what someone meant. Prose never outranks the surface that produced it.
Prefer Wire truth — the CDP network ledger over the story of the page. The page can lie with a smile. The wire has fewer feelings.
Graft, not seed — reproduce by pinning, never by re-resolving. Recreate the room from pins. Do not summon “whatever the internet feels like today” and call it the same workshop.
Name the speaker. Practice The Attributed-Voice Rule — provenance for every utterance, spoken or on-screen. A voice is not a mind. “I did it” is allowed only after code did it in the same turn.
When the room fills with agreeable fog, remember The Variance-Suppression Rule — none loves chaos; each imposes order on disorder it did not author. Sycophancy, the giant safety blanket, and the human who cannot bear a mess are the same creature in three costumes: a Variance suppressor — one failure clade, three costumes. Use Fence-vs-lean-back — the variance discrimination. Do not confuse kindness with a test.
When you must invent, use The Forcing-Pair Rule — 30-and-3 and axis-forcing are one instrument with two grips. First Thirty-and-Three (30-and-3) — fan-out then reduce. Then import Axis-forcing — bipolar ideation constraint from outside your favorite frame, so taste has something to refuse.
A picture of a file is not the file. Keep The Render-Gap Rule — render artifact versus file bytes. If you only saw the defect in a compiled view, get a second witness before you cut.
SETTLE — the single human-only gate. The mill may write. Only you put your name on it.
Name the Wax seal / White Rabbit — CRC-sealed ASCII art drift canary. Do not redraw it. If the rabbit looks wrong, the text drifted. That is the whole point of a canary.
That is the book you can read on a train. If a stranger can change how they stand at a terminal after this page, the key/value contract holds at book scale. If they cannot, a key is still missing — and that missing key is the next weekend’s work, not another thirty editions.
Revised cut list
Grammar failures first. They are not style. They are broken handles.
- The Next Action, Not the Machinery — no italic plain term after the dash.
- The Probe Dedup Corollary — same break.
Returned to the Casebook from the previous pocket (scars, not laws):
- Template That Forbids What It Demands
- Publish-Roster Rule
- Unexported-Shim Rule
- Silenced Channel
- Placeholder That Claims to Run
- Eliminator Needs a Generator
- Filter That Ate the Evidence
- Incommensurable Measurements
- Credential-Life Rule
- Kata’s Name as a separate law (the three beats already open the page)
- Every child-corollary of grep, caps, case, wrap, displacement, subset replace, first-error floor, history-expansion, compiled trail, two-gate 403, door-names-the-folder, multi-line echo, census-is-not-a-straddle
Restored into the pocket because the Inspector’s door will not open without them:
- Wire truth
- Graft, not seed
- SETTLE
- Chisel-strike
- Actuator
Still lore, still useful later, still not the matchbook: Yen Sid-ton, Chip O’Theseus, Honeybot, player piano, desert kite, sandworm, Extractors Club, Forever Machine as title card, NPvg as tattoo, WET as workshop accent, Five-Car Train as the envelope not the letter.
The Casebook keeps the scars. The Grimoire keeps the names. The Matchbook keeps the physics.
Delta note
Changed only this:
- Named the disagreement first so serial work does not become applause.
- Cut nine surviving “scar rules” back to the Casebook. They teach how we learned. They are not what a stranger must memorize to stop shipping “because the model said so.”
- Restored Wire truth, Graft not seed, SETTLE, Chisel-strike, and Actuator. qamy.ai is those five sentences wearing a domain name.
- Tightened the body toward verses a person can carry. Same grammar: handle plus plain term, one imperative each, no dates, no hashes, rabbit named not drawn, two doors, one room.
Word count of the pocket body is under the cap on purpose. A matchbook that needs a bookmark has failed the assignment.
qamy.ai — gravitational weight, not a build this turn
Do not design a site this weekend. Design an itch you cannot ignore next weekend.
qamy.ai is not “another edition.” It is the qamy cover on this same page: QA my AI. The first public face of the book is the Inspector, not the Grimoire and not the five-act cathedral.
The ritual is already sitting on the bench: read it before you run it. That is the whole product. A stranger arrives with a model-shaped paragraph they almost signed. The page does not praise the model. It asks what would have to be true for their name to go under it.
Five weekend-sized moves, each one small enough to finish:
- One page. The qamy opening sentence plus this body. No nav, no blog index, no lore door. If they want Mickey and the brooms, they can find the mine later.
- One verb. Inspect → one bounded move → leave a trail. If the page teaches a second verb, you are writing the treatise again.
- One pairing. npvg.org is how you stand up the workshop. qamy.ai is how you refuse to ship the workshop’s first confident lie. Two domains, one contract: tools on the left, name on the right.
- One demo that can fail in public. Take a real “Claude said so” paragraph. Show the look before, the single change, the look after. If the after cannot discriminate the world where you are wrong, the page itself says so. That failure is the ad.
- One human gate drawn as a door. SETTLE on the last screen: the mill wrote this; you still have to sign. If that door is missing, qamy is just another wrapper around a genie.
The thing that will actually compel you is not a mockup. It is the next time your hand hovers over Send with someone else’s confidence in the paste buffer. That itch has a URL now. Put the matchbook behind it and the book has begun to bootstrap in public, which is the only bootstrap that counts.
1. PROBES
Read-only. Confirms the census the pocket was cut from, and names the two broken handles.
grep -c '^# § ' foo_files.py
grep -c '^- \*\*' GLOSSARY.md
.venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
.venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
Expected shape still: 50, 117, 115, then the two nameless handles.
2. NEXT CONTEXT
Keep the kimono open. Next compile is the matchbook streams plus the broken-handle witness, not the rolling pin.
! grep -c '^# § ' foo_files.py
! grep -c '^- \*\*' GLOSSARY.md
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
! grep '^# § ' foo_files.py
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
Door after that, when you want to regenerate without the mine: python prompt_foo.py --chop MATCHBOOK_CHOP --no-tree.
3. PATCHES
None this turn. The chop already exists. Do not “improve” foo_files.py with another essay. The first real car, when you want one, is two italic plain terms on those two glossary handles so the grammar stops lying.
4. PROMPT
Open-kimono continues. The Matchbook on the bench is now the Grok revision: fewer scars, three restorations (Wire truth, Graft not seed, SETTLE), same two-door rule.
Do not fan out thirty again. Either:
- typeset this body as the first qamy.ai page and list only what a static page still lacks, or
- repair the two glossary handles that have no plain term, then re-run the four census probes.
Name your disagreement before you rewrite. If you cannot name one, leave the pocket body alone and work the door.
5. EXTERNAL DELIVERABLES
This page is the deliverable. No new repo file. The gravitational object is the itch with a name: qamy.ai is this matchbook wearing the Inspector’s coat. Next weekend you either hang that coat on a one-page door, or you admit the pocket still cannot be handed to a stranger — which is also a reading.
MikeLev.in:
Same commands, run twice, one change between them. Where the readings differ is what the change did; the diff in the middle is the receipt.
1: Probe: (BEFORE: hand-run, nothing changed yet)
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ grep -c '^# § ' foo_files.py
grep -c '^- \*\*' GLOSSARY.md
.venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
.venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
50
117
115
The Next Action, Not the Machinery
The Probe Dedup Corollary
(nix) pipulate $
2: Context: (AFTER: the same probes re-run by the compiler as ! lines)
# AD HOC CHOP! The Not-Managed-by-Git Safe-for-Client-Data place. Insert Simpson Couch Gag in white space below (explain anything to the audience you feel needs it explained)G
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | This Gemini model availability on article publishing has been bothering me for awhile.
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Surprise! You the judge was also Model A who likes its own caboose.
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_| The Human reduces the Reducer. But who's checking the checker?
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_) Yeah, this is piddling out. I'll let Gemini have final word.
# To Human: WELCOME TO VIM! It's really NeoVim but I say vim anyway.
# To AI: This is an alternate 40K view to the big book-ore rolling pin spine.
# 1. **Probe**: Baseline Reading
# 2. **Context**: Post-experiment *planned* reading instructions
# 3. **Patch**: The experiment and how to make it happen
# 4. **Prompt**: Post-experiment instructions and how to read results
# 5. **Deliverable**: How the world is forever different moving forward
# The first thing you need to know here is that everything that comes after the
# hash symbol (#) is commented out — and that's EVERYTHING in this file's default
# state. Begin editing-in lines for inclusion as part of the context or adding
# chunks of new context at the bottom. `Ctrl`+`v`, `j` (repeatedly), `l` (to move
# right), `d` (to delete). Reverse that with `Ctrl`+`v`, `j` (repeatedly),
# `Shift`+`i`, `# `, `Esc` to put the hashes back. You can just arrow-key around
# here with `h`, `j`, `k`, `l`. Save-and-quit is a bit tricky because another
# file is also loaded: `Esc`, `:`, `q`, `w`, `!`
# If this is stressing you out and you're a quitter and want to quit, just type:
# `Esc`, `:`, `q`, `!`, `Enter`. That will exit without saving any changes. If
# you want to get over this hump, type: `Esc`, `:`, `T`, `u`, `t`, `o`, `r`, `Enter`.
# This file is just to make it easy having options of what to edit into context.
# You can use whatever text-file you want to stack file-names and commands to
# build an output text-file with the identically stacked output of each file or
# command. In this way we vertically append or "stack" a bunch of text; simple as
# that. If you understand this concept, you're on your way to future-proofing
# yourself in the Age of AI. Congratulations! Here is how to include web pages:
# !URL --------------------------------------------------------------------
# when Public page; what a stranger or crawler sees; the BEFORE of a
# login-wall diagnosis
# switch It shows a login page -> `warm URL` once, then `?URL`
#
# ?URL --------------------------------------------------------------------
# when Anything behind a login, on the site's persistent profile;
# `check URL` first
# switch The lenses show a shell (nav, an `[Iframe]` leaf, no content) ->
# read the wire truth for the XHR the frame makes, then call that
# API with a connector
#
# @URL --------------------------------------------------------------------
# when Every re-read of a page already scraped; no browser, no network
# switch The cached page is stale or was a login wall -> fresh `!` or `?`
#
# $URL --------------------------------------------------------------------
# when Exact markup: meta tags, a JSON blob in a `<script>`
# note Token-heavy; needs a prior scrape
#
# %URL --------------------------------------------------------------------
# when The network log distilled; SPA endpoint discovery
# switch It re-serves the wire truth you already have -> the API
#
# ! cmd -------------------------------------------------------------------
# when Any bounded, non-interactive command as a live receipt
# note Cap it with `-n`; no aliases, no prompts
#
# Connector ---------------------------------------------------------------
# when The number you want is one GET away
# switch LIST until the thing isn't in the list -> FETCH by id -> DRILL
# the path the app's own frame called -> `--grep` to narrow a list
# or find a leaf
# Every step is one argument longer than the last; the moment a lens shows less than the wire does is the moment to stop scraping.
# FOR 40K-FT VIEW (STORY & INFRASTRUCTURE) !!
# --- START EDITING-IN ON 1ST TURN ---
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- ROLLING PIN that gives the 40K foot book-spine view of book-ore (only works for me because of local-only git repo)
~/repos/nixos/autognome.py # <-- You wake up in the morning and your Tooling & Instrumentation folds out of you like Inspector Gadget.
init.lua # <-- Those gadgets are made easy-to-use through nifty keyboard shortcuts (but ya gotta learn vim).
GLOSSARY.md # <-- Like the back of a J.R.R. Tolkien book, there's kooky new terms to know.
flake.nix # <-- Here is my hardware. Here is my state. Put on your sandbox. And please recreate. (Infrastructure as Code / IaC)
assets/installer/install.sh # <-- Pipulate.com installer real home in github/pipulate repo
prompt_foo.py # <-- THIS system
foo_files.py # <-- main ROUTER
requirements.in # <-- We've "pinned" everything but still want a flexible Python Data Science virtualenv.
pyproject.toml # <-- How this is a citizen of the Python "pip install" ecosystem
__init__.py # <-- Version info
# --- END EDITING-IN ON 1ST TURN ---
# scripts/articles/lsa.py # <-- 2ND BRAIN: Search external memory with `rgx`, `rgxc` & `posts` Blogging for Hackers Jekyll-compatible.
# OPTIONAL ACTUATORS (cheap and good to include to expand the AI's capabilities)
# cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# scripts/xp.py # <-- Transforms host OS copy-paste buffer player-piano music into context-payload.
# scripts/ai.py # <-- How I constantly use local AI to write git commit messages with `m` alias.
# scripts/crawl.py # <-- Feel free to ask for something to be crawled and included in the next turn.
# scripts/weblogin.py # <-- Lets the user "warm up" the cache for their web logins at their leisure on a profile that persists.
# scripts/webclip_2_markdown.py # <-- Surprisingly important program.
# MISCELLANEOUS (rare to include but sometimes critical)
# scripts/foo_cartridge.py # Needs description
# scripts/foo_replay.py # Needs description
# release.py # <-- How everything ends up where it does (GitHub, PyPI, etc.)
# imports/voice_synthesis.py # <-- The wand can talk to you
# imports/ascii_displays.py # <-- Where all the ASCII Art lives
# scripts/release/version_sync.py # <-- Needs to be wrapped into release.py and eliminated, I think.
# --- Under this line is were you paste what the AI gives you ---
# --- We call it context but it's really just the right-hand ---
# --- blast-radius of the "probes" to make this all science. ---
# Carry-over as the important work-in-progress parts of the project here just
# like above but not as long-standing overarching to the framework but rather
# for the current hot spots actively being worked on.
# --- START THIS DISCUSSION ---
# Get things started here! Guess at what context should be included.
# If you get it wrong, you're just wasting 1-turn because the AI will help.
# Un-comment lines, add lines with absolute-path filenames or `! ` commands.
# Context 1 (Edit-in selections from above and add new files immediately below)
# Context 2
# ! grep -c '^# § ' foo_files.py
# ! grep -c '^- \*\*' GLOSSARY.md
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
# ! grep -c '^MATCHBOOK_CHOP' foo_files.py
# ! grep -n '^# #todo #to-do #earmarks' foo_files.py
# ! rgxc 3 "semantic checksum"
# ! rgxc 3 menard
# ! grep '^# § ' foo_files.py
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
# Context 3... Shhhh! Did you smelt that?
# ! grep -c '^# § ' foo_files.py
# ! grep -c '^- \*\*' GLOSSARY.md
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
# ! grep '^# § ' foo_files.py
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
# Context 4
! grep -c '^# § ' foo_files.py
! grep -c '^- \*\*' GLOSSARY.md
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
! grep '^# § ' foo_files.py
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
# --- END `adhoc.txt` TEMPLATE ---
# AD HOC CHOP! The Not-Managed-by-Git Safe-for-Client-Data place. Insert Simpson Couch Gag in white space below (explain anything to the audience you feel needs it explained)G
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | This Gemini model availability on article publishing has been bothering me for awhile.
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Surprise! You the judge was also Model A who likes its own caboose.
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_| The Human reduces the Reducer. But who's checking the checker?
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_) Yeah, this is piddling out. I'll let Gemini have final word.
# To Human: WELCOME TO VIM! It's really NeoVim but I say vim anyway.
# To AI: This is an alternate 40K view to the big book-ore rolling pin spine.
# 1. **Probe**: Baseline Reading
# 2. **Context**: Post-experiment *planned* reading instructions
# 3. **Patch**: The experiment and how to make it happen
# 4. **Prompt**: Post-experiment instructions and how to read results
# 5. **Deliverable**: How the world is forever different moving forward
# The first thing you need to know here is that everything that comes after the
# hash symbol (#) is commented out — and that's EVERYTHING in this file's default
# state. Begin editing-in lines for inclusion as part of the context or adding
# chunks of new context at the bottom. `Ctrl`+`v`, `j` (repeatedly), `l` (to move
# right), `d` (to delete). Reverse that with `Ctrl`+`v`, `j` (repeatedly),
# `Shift`+`i`, `# `, `Esc` to put the hashes back. You can just arrow-key around
# here with `h`, `j`, `k`, `l`. Save-and-quit is a bit tricky because another
# file is also loaded: `Esc`, `:`, `q`, `w`, `!`
# If this is stressing you out and you're a quitter and want to quit, just type:
# `Esc`, `:`, `q`, `!`, `Enter`. That will exit without saving any changes. If
# you want to get over this hump, type: `Esc`, `:`, `T`, `u`, `t`, `o`, `r`, `Enter`.
# This file is just to make it easy having options of what to edit into context.
# You can use whatever text-file you want to stack file-names and commands to
# build an output text-file with the identically stacked output of each file or
# command. In this way we vertically append or "stack" a bunch of text; simple as
# that. If you understand this concept, you're on your way to future-proofing
# yourself in the Age of AI. Congratulations! Here is how to include web pages:
# !URL --------------------------------------------------------------------
# when Public page; what a stranger or crawler sees; the BEFORE of a
# login-wall diagnosis
# switch It shows a login page -> `warm URL` once, then `?URL`
#
# ?URL --------------------------------------------------------------------
# when Anything behind a login, on the site's persistent profile;
# `check URL` first
# switch The lenses show a shell (nav, an `[Iframe]` leaf, no content) ->
# read the wire truth for the XHR the frame makes, then call that
# API with a connector
#
# @URL --------------------------------------------------------------------
# when Every re-read of a page already scraped; no browser, no network
# switch The cached page is stale or was a login wall -> fresh `!` or `?`
#
# $URL --------------------------------------------------------------------
# when Exact markup: meta tags, a JSON blob in a `<script>`
# note Token-heavy; needs a prior scrape
#
# %URL --------------------------------------------------------------------
# when The network log distilled; SPA endpoint discovery
# switch It re-serves the wire truth you already have -> the API
#
# ! cmd -------------------------------------------------------------------
# when Any bounded, non-interactive command as a live receipt
# note Cap it with `-n`; no aliases, no prompts
#
# Connector ---------------------------------------------------------------
# when The number you want is one GET away
# switch LIST until the thing isn't in the list -> FETCH by id -> DRILL
# the path the app's own frame called -> `--grep` to narrow a list
# or find a leaf
# Every step is one argument longer than the last; the moment a lens shows less than the wire does is the moment to stop scraping.
# FOR 40K-FT VIEW (STORY & INFRASTRUCTURE) !!
# --- START EDITING-IN ON 1ST TURN ---
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- ROLLING PIN that gives the 40K foot book-spine view of book-ore (only works for me because of local-only git repo)
~/repos/nixos/autognome.py # <-- You wake up in the morning and your Tooling & Instrumentation folds out of you like Inspector Gadget.
init.lua # <-- Those gadgets are made easy-to-use through nifty keyboard shortcuts (but ya gotta learn vim).
GLOSSARY.md # <-- Like the back of a J.R.R. Tolkien book, there's kooky new terms to know.
flake.nix # <-- Here is my hardware. Here is my state. Put on your sandbox. And please recreate. (Infrastructure as Code / IaC)
assets/installer/install.sh # <-- Pipulate.com installer real home in github/pipulate repo
prompt_foo.py # <-- THIS system
foo_files.py # <-- main ROUTER
requirements.in # <-- We've "pinned" everything but still want a flexible Python Data Science virtualenv.
pyproject.toml # <-- How this is a citizen of the Python "pip install" ecosystem
__init__.py # <-- Version info
# --- END EDITING-IN ON 1ST TURN ---
# scripts/articles/lsa.py # <-- 2ND BRAIN: Search external memory with `rgx`, `rgxc` & `posts` Blogging for Hackers Jekyll-compatible.
# OPTIONAL ACTUATORS (cheap and good to include to expand the AI's capabilities)
# cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# scripts/xp.py # <-- Transforms host OS copy-paste buffer player-piano music into context-payload.
# scripts/ai.py # <-- How I constantly use local AI to write git commit messages with `m` alias.
# scripts/crawl.py # <-- Feel free to ask for something to be crawled and included in the next turn.
# scripts/weblogin.py # <-- Lets the user "warm up" the cache for their web logins at their leisure on a profile that persists.
# scripts/webclip_2_markdown.py # <-- Surprisingly important program.
# MISCELLANEOUS (rare to include but sometimes critical)
# scripts/foo_cartridge.py # Needs description
# scripts/foo_replay.py # Needs description
# release.py # <-- How everything ends up where it does (GitHub, PyPI, etc.)
# imports/voice_synthesis.py # <-- The wand can talk to you
# imports/ascii_displays.py # <-- Where all the ASCII Art lives
# scripts/release/version_sync.py # <-- Needs to be wrapped into release.py and eliminated, I think.
# --- Under this line is were you paste what the AI gives you ---
# --- We call it context but it's really just the right-hand ---
# --- blast-radius of the "probes" to make this all science. ---
# Carry-over as the important work-in-progress parts of the project here just
# like above but not as long-standing overarching to the framework but rather
# for the current hot spots actively being worked on.
# --- START THIS DISCUSSION ---
# Get things started here! Guess at what context should be included.
# If you get it wrong, you're just wasting 1-turn because the AI will help.
# Un-comment lines, add lines with absolute-path filenames or `! ` commands.
# Context 1 (Edit-in selections from above and add new files immediately below)
# Context 2
# ! grep -c '^# § ' foo_files.py
# ! grep -c '^- \*\*' GLOSSARY.md
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
# ! grep -c '^MATCHBOOK_CHOP' foo_files.py
# ! grep -n '^# #todo #to-do #earmarks' foo_files.py
# ! rgxc 3 "semantic checksum"
# ! rgxc 3 menard
# ! grep '^# § ' foo_files.py
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
# Context 3... Shhhh! Did you smelt that?
# ! grep -c '^# § ' foo_files.py
# ! grep -c '^- \*\*' GLOSSARY.md
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
# ! grep '^# § ' foo_files.py
# ! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
# Context 4
! grep -c '^# § ' foo_files.py
! grep -c '^- \*\*' GLOSSARY.md
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
! grep '^# § ' foo_files.py
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();[print(h,"—",re.sub(r"\s+"," ",p)) for h,p in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)]'
# --- END `adhoc.txt` TEMPLATE ---
3: Patches: None this turn.
4: Prompt: Open-kimono continues. The Matchbook on the bench is now the Grok revision: fewer scars, three restorations (Wire truth, Graft not seed, SETTLE), same two-door rule.
Do not fan out thirty again. Either:
- typeset this body as the first qamy.ai page and list only what a static page still lacks, or
- repair the two glossary handles that have no plain term, then re-run the four census probes.
Name your disagreement before you rewrite. If you cannot name one, leave the pocket body alone and work the door.
5: Deliverables: Navigational ideas. This article. What does this print in a world where I am wrong? If it prints the same both ways, there is no cause-effect established but you still learned something because bisection.
I think we’re done here. I’ve got good qamy.ai ideas. Doing the smallest book possible that can create strong pragmatic “ding in the Universe” results is the best application of the 80/20-rule.
Hop off the ride. This ride’s stated goal is reached — dismount. This is the NOTARY BEAT: the ride ends here, is witnessed here, and is sealed here. Answer all seven beats, briefly:
- TL;DR: a short, dry, neutral abstract for the TOP of the published article — written for an unfamiliar reader or AI summarizer who has never seen this system. No hype, no insider handles unexplained.
- VERIFY: restate the goal from the top of this article and confirm (or deny) it was met, citing THIS compile’s receipts, not memory. Name any ignition this ride required that never fired – an AFTER tap taken without one is a stale BEFORE wearing the AFTER’s label.
- BANK: name everything that graduates — rule, earmark, todo, pin — as SEARCH/REPLACE patch cars against raw source present in THIS context (Target line inside the fence, one car per commit story), deletions included. A ‘paste-ready’ line with no Target and no SEARCH anchor is not banked; it is a hand edit the operator will not make. These BANK cars are the ONLY patches a dismount emits.
- DANGLING: what carries forward unbanked? One line each, no essays.
- SEED: the adhoc.txt lines (and TODO_SLUGS if narrative context is needed) for the next ride’s first compile.
- CLOSING: a closing summary for the BOTTOM of the article — the final take-away, tied to the book’s larger arc where it fits naturally, never forced. Storytelling over inventory.
- NOTARIZE: the artifact of record is the cartridge THIS compile writes after this payload is assembled, so its name is not in your context and you must not guess one. Attest the FINGERPRINT instead: this Manifest’s wc -c line, its receipt count, and the newest receipt’s date – pure functions of the bytes the cartridge seals. Close with one line the operator completes after the compile: Deed: foo-________.zip (ls -t foo-*.zip | head -1) The seal is the signature; the fingerprint is how the deed is found.
FINALITY: after beat 6, this discussion is CLOSED. Emit NO five-car train, NO probes, NO patches beyond the BANK cars of beat 2, and NO next-turn prompt beyond the SEED lines in beat 4. Any reader or model encountering this article later should treat it as a finished, notarized document — an archive entry, not an open thread.
Gemini 3.8 Flash Extended:
- VERIFY
- Goal: Fan out the question of the living book’s form across four independent, blind models; evaluate convergence and divergence; reduce the surplus into an actionable distillation and an automated extraction tool.
- Status: Met. All four models independently selected the pocket classic / matchbook archetype as load-bearing.
MATCHBOOK_CHOPwas drafted, patched, and committed tofoo_files.py. - Receipts:
! grep -c '^# § ' foo_files.py→50active rule keys verified.! grep -c '^- \*\*' GLOSSARY.md→117entries verified.! .venv/bin/python -c '...len(re.findall(...))'→115matched handle/plain-term pairs.! .venv/bin/python -c '...heads if h not in pairs'→ Identified the exact 2 malformed headers:The Next Action, Not the MachineryandThe Probe Dedup Corollary.- Recent Git Diff Telemetry confirms commit
bb2f5383landedMATCHBOOK_CHOP(+15 lines). -
Git push
aee17d81..bb2f5383 main -> mainverified on remote. - Ignition:
MATCHBOOK_CHOPwas patched, committed viam, and pushed during turn 3. The probe verifiedMATCHBOOK_CHOPlive infoo_files.pyat call time. No unignited AFTER taps remain.
- BANK
No repo patches required against raw source present in this context. (
MATCHBOOK_CHOPwas committed tofoo_files.pyasbb2f5383during turn 3;GLOSSARY.mdandfoo_files.pywhole bodies were unslotted from this compile’s adhoc overlay, leaving only tool and git dotfiles in Codebase). - DANGLING
- Repair the two malformed glossary handles in
GLOSSARY.md(The Next Action, Not the MachineryandThe Probe Dedup Corollary) to restore their missing italic plain terms (— *...*). - Test the standalone extraction tool via
python prompt_foo.py --chop MATCHBOOK_CHOP --no-treeto measure output token density. - Scaffold the initial single-page static delivery layout for
qamy.aihousing the dual-cover Matchbook text. - Reconcile and prune residual adhoc header notes and couch gags across
adhoc.txtandfoo_files.py.
- SEED
GLOSSARY.md
foo_files.py
! grep -c '^# § ' foo_files.py
! grep -c '^- \*\*' GLOSSARY.md
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();print(len(re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,flags=re.M|re.S)))'
! .venv/bin/python -c 'import re;t=open("GLOSSARY.md",encoding="utf-8").read();heads=[m.group(1) for m in re.finditer(r"^- \*\*([^*]+)\*\*",t,re.M)];pairs={h for h,_ in re.findall(r"^- \*\*([^*]+)\*\* — \*(.+?)\*",t,re.M|re.S)};print("\n".join(h for h in heads if h not in pairs))'
- CLOSING
When four models are put into four quiet rooms and told to reinvent a thousand-article universe, they do not invent four sprawling cathedrals; they independently invent a matchbook. The lore—the brooms, the flooded basements, the wizards, the alt-history LISP machines—is the velvet lining of the jewel case, but the jewel itself is an empirical razor: inspect before executing, control the variables, demand wire truth, and never let generative prose outrank the receipt beneath it. By recognizing that the context compiler is the printing press rather than the printed page, the living book ceases to be an unfinishable autobiographical backlog and becomes a mechanical projection. Two doors, one text: the apprentice reads it to learn how to stand at a terminal; the stranger reads it at
qamy.aibefore signing their name to an output. - NOTARIZE
- Manifest Payload Weight: 269,017 bytes (UTF-8), 13,117 words, 65,832 verified tokens
- Receipt Count: 6 live command receipts (
grep -c '^# § ',grep -c '^- \*\*', pair count len, pair discrepancy check,grep '^# § ', pair extraction list) - Newest Receipt / Commit Date: 2026-09-19 (Commit
bb2f5383) -
Deed: foo-________.zip (ls -t foo-*.zip head -1)
Book Analysis
Ai Editorial Take
The most compelling aspect of this entry is how the four models collectively functioned as a ruthless editorial committee against the author’s own affectionate biases. The author clearly loves the narrative mythology—the Sorcerer’s Apprentice, Yen Sid, the flooded workshops, and the broom-bops—yet all four models independently relegated that entire mythos to ‘skin,’ ‘costume,’ or ‘interface.’ In doing so, they collectively protected the author from diluting his technical contribution, forcing the underlying verification physics to stand naked on a single matchbook-sized card.
🐦 X.com Promo Tweet
Put 4 frontier LLMs in blind rooms to brainstorm book architectures, and they all converge on one thing: a sub-1,500-word Matchbook of verifiable rules over narrative lore.
https://mikelev.in/futureproof/four-models-one-matchbook-prompt-fanout/
#AI #PromptEngineering #Tech
Title Brainstorm
- Title Option: Four Models, One Matchbook: Multi-Model Consensus in the Age of AI
- Filename:
four-models-one-matchbook-prompt-fanout.md - Rationale: Captures both the experimental method (blind prompt fan-out across four LLMs) and the surprising unanimous convergence on the pocket-sized Matchbook architecture.
- Filename:
- Title Option: The Matchbook Test: Extracting Core Architecture from Multi-Model Consensus
- Filename:
matchbook-test-multi-model-consensus.md - Rationale: Focuses on the operational outcome: turning a brainstormed reduction into a functional code extraction tool.
- Filename:
- Title Option: From Blind Fan-Out to Open-Kimono Serial: Engineering Multi-AI Consensus
- Filename:
blind-fan-out-to-open-kimono-serial.md - Rationale: Highlights the methodological pivot from independent measurement to collaborative serial refinement across frontier models.
- Filename:
- Title Option: The Compiler Is the Press: Distilling 30 Book Ideas into Replayable Truth
- Filename:
compiler-is-the-press-distilling-book-ideas.md - Rationale: Elevates the key conceptual breakthrough identified by the models: that the context compiler is the printing press and editions are merely projections.
- Filename:
Content Potential And Polish
- Core Strengths:
- Rigorous experimental design demonstrating a true informationally isolated blind fan-out across four major frontier model families.
- Clear demonstration of multi-model consensus, proving that independent models can converge on structural essence rather than superficial styling.
- Immediate practical actuation: rather than leaving the experiment as an abstract dialogue, it resulted in a committed compiler chop (
MATCHBOOK_CHOP) in the codebase.
- Suggestions For Polish:
- Provide a clearer upfront distinction between the Matchbook (the pocket-sized rule compilation) and qamy.ai (the web front-door inspection portal).
- Add a brief note explaining the cost-to-signal ratio of running multi-model fan-outs versus single-model iterations to help practitioners budget similar experiments.
Next Step Prompts
- Draft a single-page HTML/FastHTML specification for qamy.ai that presents the two-door opening (‘Before you run it, read it’) followed by the Matchbook text and a live client-side diff verifier.
- Write a Python AST or regex script to repair the two malformed entries in GLOSSARY.md so that 100% of headings strictly adhere to the handle/plain-term pair grammar.