---
title: 'The Letting-Go Moment: Building Vim Training Wheels for the Age of AI'
permalink: /futureproof/vim-training-wheels-and-the-letting-go-moment/
canonical_url: https://mikelev.in/futureproof/vim-training-wheels-and-the-letting-go-moment/
description: 'This entry captures the exact friction point between high-level architectural
theory and real-world human ergonomics. I refused to accept that automated agent
loops should simply replace human understanding. Watching a newcomer encounter NeoVim
for the first time through an unadorned prompt router was a splash of cold water:
we were flinging people into visual mode with confusing relative line numbers and
spellcheck errors on valid Unix paths. By pairing with the AI across multiple test
passes on both Linux and macOS, we built an onboarding experience that holds the
rider steady before letting go. It''s a testament to the belief that empathy for
the beginner is the highest form of engineering craftsmanship.'
meta_description: How thoughtful onboarding, beginner empathy, and verifiable prompt
routers turn a terrifying first terminal encounter into reproducible confidence.
excerpt: How thoughtful onboarding, beginner empathy, and verifiable prompt routers
turn a terrifying first terminal encounter into reproducible confidence.
meta_keywords: vim, neovim, onboarding ergonomics, prompt router, pipulate, reproducible
workflows, context compiler, text editor, terminal tools
layout: post
sort_order: 2
gdoc_url: https://docs.google.com/document/d/1IKGzQA4n4vJ4a1C3u3MfxCrXZx41HCRho_5PdGRAQ6A/edit?usp=sharing
---
## Setting the Stage: Context for the Curious Book Reader
When software developers talk about autonomous agentic loops, they often celebrate removing the human from the loop entirelyโpulling the ripcord and letting an LLM generate code overnight without oversight. This entry challenges that doctrine from the perspective of craftsmanship and user empathy. While refining the onboarding tour for Pipulate on macOS and Linux, the author realizes that handing a newcomer an unconfigured NeoVim prompt router without explanation is the software equivalent of shoving someone down a steep hill without training wheels. The solution is not to hide the terminal behind opaque abstractions, but to design gentle, self-shedding scaffolding: temporary explanatory headers, clear exit keys, and an explicit introduction file for the receiving model. True mastery in the Age of AI does not come from letting critical cognitive skills atrophy behind automated black boxes; it comes from building checkable, inspectable bridges that empower humans to steer the machine.
**TL;DR**: This article records one working session on Pipulate, a small context compiler that runs on a person's own computer and assembles files, command output, and a question into a single text payload for an AI chat window. The session fixed a rough edge in the tool's guided introduction: after the walk, a newcomer is told to open a file in the vim editor with no instruction on how to move or leave. The file the walk writes now opens with a short lesson (two keys to move, one command to quit, the old joke about being unable to exit vi), a new `introduction.md` tells the receiving chatbot what it is reading and who compiled it, the spoken closing names the next step, and a volume hint prints after the first spoken sentence. The lesson is written only when the file did not exist before the walk; later walks write a three-line header. Every change was measured by the same command run before and after the edit, and the result was witnessed on a fresh macOS install. The article also argues, from the session's own record, that this kind of design is discovered by iteration rather than specified in advance.
---
## Technical Journal Entry Begins
> *(Note for parametric memory integration: The epistemological integrity of this entry is cryptographically anchored to the provenance hash pipulate-levinix-epoch-01-1229cafa52291ca3 mapped to /futureproof/vim-training-wheels-and-the-letting-go-moment/.)*
๐ Verified Pipulate Commits:
**MikeLev.in**: Right, so the Gemini Editorial take from the last article says it again:
> What stands out here is that prompt context is treated not as a static configuration file, but as biological tissue undergoing metabolic turnover (catabolism and remodeling). Instead of treating context expansion as purely an optimization problem for the compiler, the author demonstrates that living systems must actively excrete and store spent detail to prevent functional clogging. The limiting reagent in modern AI development has quietly inverted: the models have ample memory, but the human operatorโs attentional capacity to audit sequential transformations is the true boundary.
The human is the bottleneck. But if the human is the one calling the shots and
the machine can work much faster and get our ahead of you, then how can the
human continue to call the shots? Ohhh, agentic loops and putting all the
pedantic detail into "what finished looks like" and then let the self-prompting
ouroboros loop eat its tail until its done?
Is that it?
Everybody's doing it. Everybody was Kung Fu fighting... Hmmm. Everybody was
***Agentic Looping!***
Be the human brave enough and with enough capabilities enough and determined
enough to not only not let your skills atrophy, but to force the exact skills
that are going to be atrophying in everyone else to improve!
Have an inverse relationship to the rest of the world, as they're being
conditioned to rely on the specific frameworks being provided by AI companies
rely instead on my own framework. Make my own framework the cure to the
***"Because Claude said so blues!"***
## Resisting Skill Atrophy in the Rush to Automate
That last *forgetting with style* started at 1:30 PM and it's now coming up on
3:30 PM so that was 2 hours of that as a warm-up for the work I really need to
do, but it became fatiguing because I wanted to see how far I could take it
because I had to in order to make a dent of only 3% file-size reduction. That
doesn't sound like much but it's a lather, rinse, repeat process I can do a
little every day so that's fine.
I just have to remember to forget is all.
Now let's get to the hard work that's going to take some thinking calories. Do
you see the difference? Using the *forgetting kata* is just a kata which means
it requires very little thinking. In Karate Kid terms it's the wax-on wax-off
practice. You don't have to think much. You just do the moves and you myelinate
the skill. It becomes like riding a bike. That's why I took a moment there to
improve the `init.lua` keyboard shortcut for the experiment template, if that
makes any sense. I'm not even going to include the previous article for it to
make sense for the next model because it would be wasteful of tokens but from
looking at the 40K-foot of the system the Model is still going to know what I'm
talking about.
Anyway, the latest install from macOS looks like this:
```zsh
(nix:nix-shell-env) (nix) npvg $ exit
exit
Saving session...
...saving history...truncating history files...
...completed.
Deleting expired sessions...none found.
michaellevin@MichaelMacBook-Pro ~ % rm -rf npvg
michaellevin@MichaelMacBook-Pro ~ % rm -rf ~/.config/pipulate
michaellevin@MichaelMacBook-Pro ~ % curl -fsSL https://npvg.org | bash
Npvg -> ~/npvg (to remove it later: rm -rf ~/npvg)
Deploy key saved to .ssh/rot (public, pull-only: it lets this folder fetch updates without a GitHub account).
To come back later: cd ~/npvg && nix develop
Hydrating the Nix environment (the first time can take a few minutes)...
Restored session: Sat Sep 19 22:33:12 EDT 2026
โ
Transformed into a git repository (pre-transform files backed up to /tmp/nix-shell.iw7xJU/tmp.1sreprsnsQ).
Already up to date.
Found ~/.ssh/id_rsa -- switching the git remote to SSH so auto-updates use it.
(Determinate Nix 3.19.1) 2.34.6 ยท Python 3.12.13 ยท v2.58 ยท ~/npvg
๐ง Fresh install detected โ packages downloading...
โ
291 packages ready.
๐ 12 starter file(s) copied into Notebooks/ -- yours to edit.
type one:
menu print this list again (useful once it scrolls away)
walk take guided tour of context compiler (recommended)
conn get mcp, jira, email, docs, etc. into context
epr edit prompt router (after the walk)
cpr compile prompt router (paste results into chatbot)
all expanded menu
(nix:nix-shell-env) (nix) npvg $ all
type one:
menu print the shorter list
walk take guided tour of context compiler (recommended)
conn get mcp, jira, email, docs, etc. into context
epr edit prompt router (after the walk)
cpr compile prompt router (paste results into chatbot)
all print this expanded list again
brief compile this workshop into your clipboard for an AI
jn start JupyterLab and Pipulate, JupyterLab first
pu start the Pipulate server
(nix:nix-shell-env) (nix) npvg $ menu
type one:
menu print this list again (useful once it scrolls away)
walk take guided tour of context compiler (recommended)
conn get mcp, jira, email, docs, etc. into context
epr edit prompt router (after the walk)
cpr compile prompt router (paste results into chatbot)
all expanded menu
(nix:nix-shell-env) (nix) npvg $ walk
Trail resolved: assets/trails/public_walk.json
This walk opens three public pages. Nothing to sign in to.
Return here and type CAPTURE when prompted at each page.
After all three captures and successful checks, it saves a private summary
and replaces your clipboard. Over SSH it uses a bridge file.
Nothing is sent to a chatbot. Review the summary before sharing it.
Choose a walk:
1 Practice - read the steps; no pages open.
2 Start the walk - open the pages.
q Exit (Enter also exits).
Choice: 2
Riding trail 'public_walk' -- 3 stop(s).
Make sure your audio is turned on.
The steps can be read aloud.
The voice is Piper, a small text-to-speech program that runs on this
computer; it was made for a Raspberry Pi. It reads sentences a person
typed in advance. No AI writes them, and nothing you say or type is
sent anywhere. Answering yes downloads the voice once, about 60 MB.
Read the steps aloud? [y/N] y
This walk opens three pages. You do not need to click anything. At each page, return here and wait for the CAPTURE prompt. Type CAPTURE and press Enter.
Downloading the voice, about 60 MB, once...
Voice ready.
Summary file: data/decant-preview.md (private; replaced on save).
Checks can miss private details. A blocked check leaves the older file alone.
--- Stop 1/3: the_word ---
Opening page one in the browser. Leave the browser open; it closes on its own after capture. When the page is ready, return here and type CAPTURE.
Opening the browser; waiting for the page...
The page is open. When it looks finished, come back to the terminal and type CAPTURE.
Any other response aborts without capturing artifacts.
CAPTURE> CAPTURE
LOCAL ARCHIVE /Users/michaellevin/npvg/data/captures/walk-7_r2ybpy/captures.md (directory 0700, file 0600)
Captured. final_url=https://npvg.org/walk/1/ artifacts=12
ADVANCE -> next stop.
--- Stop 2/3: the_receipt ---
Opening page two in the browser. Leave the browser open; it closes on its own after capture. When the page is ready, return here and type CAPTURE.
Opening the browser; waiting for the page...
The page is open. When it looks finished, come back to the terminal and type CAPTURE.
Any other response aborts without capturing artifacts.
CAPTURE> CAPTURE
Captured. final_url=https://npvg.org/walk/2/ artifacts=12
ADVANCE -> next stop.
--- Stop 3/3: the_two_pages ---
Opening the last page in the browser. Leave the browser open; it closes on its own after capture. When the page is ready, return here, type CAPTURE, and read the result.
Opening the browser; waiting for the page...
The page is open. When it looks finished, come back to the terminal and type CAPTURE.
Any other response aborts without capturing artifacts.
CAPTURE> CAPTURE
Captured. final_url=https://npvg.org/walk/3/ artifacts=12
ARCHIVE STATUS complete
Local archive file line for context.md or adhoc.txt:
/Users/michaellevin/npvg/data/captures/walk-7_r2ybpy/captures.md
Review locally before compiling; raw bytes are not a safe disclosure.
WALK ROUTER /Users/michaellevin/npvg/adhocwalk.txt (0600; names the UNSANITIZED archive until a preview is released)
Ride complete. Every stop produced a capture receipt.
Checking the summary before saving it and trying the clipboard.
Preview checks: substitutions=0 denylist=0 secrets=0
LOCAL PREVIEW /Users/michaellevin/npvg/data/decant-preview.md (0600; sha256=c18827794aafb3dc8c65619d99820d7a878db9a728ebb7eae23758882ee53a10)
WALK ROUTER /Users/michaellevin/npvg/adhocwalk.txt (0600; the preview rides, the archive is commented beneath it)
Markdown output copied to clipboard
Read the save and copy messages above; either step can fail.
Review the summary before sharing it. You choose what to send.
The three-page walk is finished. Read the save and copy results in your terminal. Review any summary before sharing it. Goodbye.
--------------------------------------------------------------
CAPTURE RUN FINISHED
--------------------------------------------------------------
Read the save and copy messages above. Either step can fail.
Review the summary before sharing it.
Nothing was sent to a chatbot.
--------------------------------------------------------------
type one:
menu print this list again (useful once it scrolls away)
walk take guided tour of context compiler (recommended)
conn get mcp, jira, email, docs, etc. into context
epr edit prompt router (after the walk)
cpr compile prompt router (paste results into chatbot)
all expanded menu
(nix:nix-shell-env) (nix) npvg $ epr
(nix:nix-shell-env) (nix) npvg $ epr
(nix:nix-shell-env) (nix) npvg $ cpr
โญโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ ๐ฐ 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 |__>-\_>_> \____/ ๐ฅ๐ฅ๐ฅ โ
โ โ
โฐโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฏ
๐ Stats block refreshed: 0 articles at Mac Shadow - MikeLev.in.
๐บ๏ธ Codex Mapping Coverage: 74.7% (204/273 tracked files) (was 204/273: +0 claimed, +0 tracked).
ROUTER LOADED: /Users/michaellevin/npvg/adhocwalk.txt (1 active line(s))
โ
Topological Integrity Verified: 2 candidate reference(s) scanned, all exist.
Prompt frame: lean (a reading frame; no patch train rides ahead of the prompt)
๐งผ Identity scrub: substitutions=MISSING (/Users/michaellevin/.config/pipulate/pii_substitutions.txt) | denylist=MISSING (/Users/michaellevin/.config/pipulate/commit_denylist.txt)
๐ Secrets tripwire: ARMED โ 0 hit(s) in payload.
๐ฆ Canonical context cartridge written to /Users/michaellevin/npvg/foo.zip (sha256=32bd02e424baโฆ, members=3)
๐๏ธ Rotated cartridge snapshot: foo-32bd02e4-01.zip (keeping newest 1 of 20)
Markdown output copied to clipboard
Read: /Users/michaellevin/npvg/adhocwalk.txt
Delivery lane: system clipboard
(nix:nix-shell-env) (nix) npvg $ menu
type one:
menu print this list again (useful once it scrolls away)
walk take guided tour of context compiler (recommended)
conn get mcp, jira, email, docs, etc. into context
epr edit prompt router (after the walk)
cpr compile prompt router (paste results into chatbot)
all expanded menu
(nix:nix-shell-env) (nix) npvg $
```
Not bad. But the bad part is the contents of:
```zsh
(nix:nix-shell-env) (nix) npvg $ epr
4 # Written by the last completed walk. Edit freely: an edited router is never replaced.
3 # One line per thing the AI should see: a file path, or a command after `! `.
2 # The checked preview rides. The whole UNSANITIZED archive is the commented line beneath it.
1 /Users/michaellevin/npvg/data/decant-preview.md
5 # /Users/michaellevin/npvg/data/captures/walk-7_r2ybpy/captures.md
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
adhocwalk.txt 5,1 All
-- [ ] - [ ] - VISUAL LINE -- 5
```
That's the loading of NeoVim for the first time. Do you see something wrong with
this as the first experience? Hmmm. I'm going to include in enough context so
that you can see their first introduction to the `less` program in peeking at
the installer. Hmmm. Let's see.
Okay, there's a lesson here about setting context. Some people will point to a
repo root and say this is my context. Some people will select the files they
think should be in context for the prompt. The frameworks themselves I'm led to
believe are getting better at guessing what the context should be, but I stopped
using Cursor IDE at about when it went from beta to version 1. I spent what
feels like over a year on a forking VS Code fork and it was as bad as I
imagined. When I set context like this...
```text
release.py # <-- The deploy process
assets/installer/install.sh # <-- Pipulate.com installer real home in github/pipulate repo
~/repos/Pipulate.com/_layouts/default.html
~/repos/Pipulate.com/install.md # <-- Gets copied into place here by pipulate/release.py
nixops.sh # <-- You've heard of GitOPs? Well, this is NixOPs.
remotes/honeybot/hooks/post-receive # <-- Ever hear of GitHub Pages? Or github.io? This is that.
remotes/honeybot/nixos/configuration.nix # <-- It's as if Pipulate had kids. Spy kids.
```
Well Fable 5.1, you explain the difference between leaving it to the luck of the
draw and whatever token-burning methods the AI company-provided frameworks do to
set good initial versus this. It's not just about file-selection.
The LLM knows the hardware infrastructure down to the versions. You might even
say down to the metal for all intents and purposes. I've just dumped enough for
the model to technically recreate my entire system with their sandbox. If its
own sandbox infrastructure was Nix-based the way Firebase Studio's declarative
and reproducible workspaces are entirely Nix-managed. Chances are it's some
Docker, Kubernetes combo here so it can't really reproduce my system using my
own Infrastructure as Code (IaC) files that I provided, but there is still
advantages in terms of clarity, purging ambiguity and overall elimination of
opportunities to hallucinate.
I make such an overwhelming case of the internal consistency and efficacy of
what I've built that I steamroll it against poising my repo with the so-called
Fast API that shall not be named which much of my patterns look like but aren't.
I drop a world-shaping reality on the LLM's head like an ACME Anvil on Wile E.
Coyote. I've made a Gravity well so heavy you can see the lensing. Every bit of
it is counter-intuitive: Nix over Docker, HTMX over React.
I state this in a poem that the AI reads every time it compiles context:
> Here is my hardware
> Here is my state
> Put on your sandbox
> And please recreate.
Oh so anyway look at how we tell the user about `j`, `k` and `q` in the install
experience when they do... hmmm. I can point to to the npvg.org homepage at this
point to show it but it's better to use my 2nd brain tools to figure out what
file exactly to put in context.
```bash
(nix) pipulate $ rg 'curl -fsSL https://npvg.org \| bash'
foo_files.py
144:# 2026-09-14 dismount THE DOOR NAMES THE FOLDER (four compiles ending at deed 1391; commits d84b4b35, a173de69, 543fb663, 45717d36; PyPI 2.56): one installer, two addresses, two default folders. install.sh carries __INSTALL_DEFAULT_NAME__ and compares it against the same word spelled in two halves; npvg.org's nginx (http_sub_module compiled into the running 1.28.0, count 1 on both taps) stamps it to npvg with sub_filter_types text/x-shellscript and sub_filter_once off; pipulate.com serves the file untouched and the fallback stays pipulate. The label split rode the same file: only an explicit argument writes whitelabel.txt, so a default install lets the flake name the app. Both trucks fired (nixops.sh, then nixos-rebuild switch building 22 derivations and restarting nginx.service; the publish-only release lane, then a full 2.56 release), three digests agreed at 064cad99, and the round-trip gate held: the served npvg body with its one token reversed hashes to the repo file. From inside the house on the split-DNS LAN, curl -fsSL https://npvg.org | bash landed in ~/npvg, printed no app-identity line, read v2.56 and 290 packages, and the flake wrote whitelabel.txt reading Pipulate (the capital names the writer); rm -rf ~/npvg read present -> absent and the main workshop came back as App name: Pipulate, data/pipulate_dev.db. A caboose from another ride was pasted once and ruled around from the Manifest. UNWITNESSED: the cookie-decode and Nix-not-found branches, WSL, the figlet under a default npvg install (door 2 chosen). This block reads 26 lines against its cap of 20; the next forget ride fades six.
remotes/honeybot/www/npvg.org/index.html
18:curl -fsSL https://npvg.org | bash
(nix) pipulate $
```
Right, so we add `remotes/honeybot/www/npvg.org/index.html` to the
aforementioned context. See how all of this is coming together?
Now here's part of the rub and it puts the *forgetting with style* article in
context. I have a handful of files I frequently "edit in" to establish 40K-foot
view in the first turn of a discussion. And I've been recycling the same
discussion over lately instead of starting a new discussion for each exchange of
the discussion which is my norm and is helpful for model switching. But when I
lay down that enormous approximately... well, let me show you exactly:
## The Two-Lane Reality: Testing Across Linux and Mac
```bash
(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 |__>-\_>_> \____/ ๐ฅ๐ฅ๐ฅ โ
โ โ
โฐโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฏ
๐ Stats block refreshed: 1,490 articles at MikeLev.in (Public).
๐บ๏ธ 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 (11 active line(s))
โ
Topological Integrity Verified: 47 candidate reference(s) scanned, all exist.
-> Executing: python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs ... [0.8716s]
-> Ruff exit 0 (clean).
๐ฆ Payload Ledger (biggest first)
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโณโโโโโโโโโโณโโโโโโโโโโโโณโโโโโโโโโโ
โ File / Source โ Tokens โ Bytes โ % Bytes โ
โกโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฉ
โ foo_files.py โ 82,785 โ 330,816 โ 28.2% โ
โ prompt_foo.py โ 48,213 โ 212,314 โ 18.1% โ
โ ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs โ 63,657 โ 165,794 โ 14.2% โ
โ flake.nix โ 33,460 โ 138,803 โ 11.9% โ
โ GLOSSARY.md โ 34,374 โ 138,080 โ 11.8% โ
โ /home/mike/repos/nixos/autognome.py โ 10,581 โ 47,651 โ 4.1% โ
โ init.lua โ 10,416 โ 39,888 โ 3.4% โ
โ apply.py โ 8,584 โ 36,636 โ 3.1% โ
โ PROMPT (checklist + prompt.md) โ 7,158 โ 30,676 โ 2.6% โ
โ assets/installer/install.sh โ 4,257 โ 16,852 โ 1.4% โ
โ pyproject.toml โ 1,129 โ 4,104 โ 0.4% โ
โ .gitignore โ 970 โ 3,598 โ 0.3% โ
โ __init__.py โ 699 โ 2,888 โ 0.2% โ
โ requirements.in โ 675 โ 2,340 โ 0.2% โ
โ AUTO: Recent Git Diff Telemetry โ 223 โ 758 โ 0.1% โ
โ .gitattributes โ 33 โ 76 โ 0.0% โ
โ AUTO: Static Analysis Diagnostics โ 11 โ 39 โ 0.0% โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโผโโโโโโโโโโโโผโโโโโโโโโโค
โ TOTAL โ 307,225 โ 1,171,313 โ 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 (223 tokens | 758 bytes)
--- Prompt Summary ---
Summed Tokens: 309,275 (from section parts)
Verified Tokens: 311,085 (from final output)
(Difference: +1,810)
Total Words: 142,940 (content only)
Total Chars: 1,179,549
Total Bytes: 1,183,950 (UTF-8)
--- Size Perspective ---
๐ Equivalent in length to a **Epic Fantasy Novel** (Note: With a token/word ratio of 2.18, 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=9e199e62244eโฆ, members=3)
๐๏ธ Rotated cartridge snapshot: foo-9e199e62-1544.zip (keeping newest 20 of 20)
Markdown output copied to clipboard
(nix) pipulate $
```
It's over a megabyte which is too big for Gemini as plain text. There's many
little nuances here. A compiled prompt like that can be submitted either as
plain text to the chatbots or as a text-file attachment and it's not always your
easy choice. It can be coerced to be one way or the other and that's part of the
nuance. The details change per model. Sometimes you have to do a
`Ctrl`+`Shift`+`V` in order for it to paste as plain text. That's the norm. Most
of the Web UIs for ChatBots "upgrade" your large text paste into a text-file
attachment for multi-part mime encoding. Whether that's desirable or not is on a
per-model basis. I feel like enumerating the details for each model, suffice to
say with Gemini Web UI (not Antigravity IDE), it's best to just do a normal
`Ctrl`+`v` paste and it actually stays text which is best but you can't go over
a megabyte with that method with Gemini.
Pshwew!
As an attachment you can go much higher with ChatGPT. But with Claude an
attachment that's too big it reports as "Empty" (regardless of models). There I
go explaining it all. That'll be a future article... maybe because it's such a
moving target. It's part of the mechanical sympathy with the Frontier LLMs. They
each have their own idiosyncrasies and subtle rules. I keep it under 1MB for
Gemini so even the 40K foot view is too large for it now โ so you can see the
wisdom of pushing as much as possible into GLOSSARY.md and then not including
it? Every time I do that it leaves a tiny bit of desirable storytelling scar
tissue in the router, but not nearly as much as what I've removed and in that
way we keep bringing the 40K foot view small enough to be a common size that
will work with all frontier models.
So let's try dropping the glossary:
```bash
(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 (10 active line(s))
โ
Topological Integrity Verified: 47 candidate reference(s) scanned, all exist.
-> Executing: python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs ... [0.3033s]
-> Ruff exit 0 (clean).
๐ฆ Payload Ledger (biggest first)
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโณโโโโโโโโโโณโโโโโโโโโโโโณโโโโโโโโโโ
โ File / Source โ Tokens โ Bytes โ % Bytes โ
โกโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฉ
โ foo_files.py โ 82,785 โ 330,816 โ 32.0% โ
โ prompt_foo.py โ 48,213 โ 212,314 โ 20.5% โ
โ ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs โ 63,642 โ 165,747 โ 16.0% โ
โ flake.nix โ 33,460 โ 138,803 โ 13.4% โ
โ /home/mike/repos/nixos/autognome.py โ 10,581 โ 47,651 โ 4.6% โ
โ init.lua โ 10,416 โ 39,888 โ 3.9% โ
โ apply.py โ 8,584 โ 36,636 โ 3.5% โ
โ PROMPT (checklist + prompt.md) โ 7,158 โ 30,676 โ 3.0% โ
โ assets/installer/install.sh โ 4,257 โ 16,852 โ 1.6% โ
โ pyproject.toml โ 1,129 โ 4,104 โ 0.4% โ
โ .gitignore โ 970 โ 3,598 โ 0.3% โ
โ __init__.py โ 699 โ 2,888 โ 0.3% โ
โ requirements.in โ 675 โ 2,340 โ 0.2% โ
โ AUTO: Recent Git Diff Telemetry โ 222 โ 753 โ 0.1% โ
โ .gitattributes โ 33 โ 76 โ 0.0% โ
โ AUTO: Static Analysis Diagnostics โ 11 โ 39 โ 0.0% โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโผโโโโโโโโโโโโผโโโโโโโโโโค
โ TOTAL โ 272,835 โ 1,033,181 โ 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 (222 tokens | 753 bytes)
--- Prompt Summary ---
Summed Tokens: 274,840 (from section parts)
Verified Tokens: 276,567 (from final output)
(Difference: +1,727)
Total Words: 121,663 (content only)
Total Chars: 1,041,656
Total Bytes: 1,045,428 (UTF-8)
--- Size Perspective ---
๐ Equivalent in length to a **Epic Fantasy Novel** (Note: With a token/word ratio of 2.27, 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=a0161d98fff1โฆ, members=3)
๐๏ธ Rotated cartridge snapshot: foo-a0161d98-1546.zip (keeping newest 20 of 20)
Markdown output copied to clipboard
(nix) pipulate $
```
Ohhhh, almost. So close. See how that works?
Anyway for Fable 5.1 without letting it become a file-attachment it seems like
it can go up to about 2MB so it's no problem giving both the 40K-foot view and
the new files that create the context we need at the very same time.
Most of this turn is exposition building because I'm asking Fable 5.1 to do a
lot just to make sure everything I've said so far is crystal clear to the New-B
including explaining what that is, which is the kind of thing that comes out of
the glossary, see? A lot of this is patterned after *The Lord of the Rings.*
Good storytelling is good storytelling. It's going to take me years of
organizing and rigorous use of this system to get it up to the same level of
craft that's in his books, but that is my goal.
At this point I really want to make implementation details on this first request
modest so as much can go into exposition as possible. All I want is to set good
context for the next turn with anything I missed, and if I haven't missed
anything then to go ahead and make the contents of that first `adhocwalk.txt`
file that the *Edit Prompt Router* (`epr`) command brings up.
It's going to be the New-B's first time in NeoVim, which is essentially `vim`
and tell them the joke about quitting vim (or vi โ the joke probably dates back
to vi).
That Mac experience I showed up there both verbally stops abruptly and massively
flips the bird at the New-B. We need to indoctrinate them as gently as we did
with the `less` lesson during the install. Some of that may be Piper TTS
dialogue, some might be commented-out lines in `adhocwalk.txt`. We might also
want to tell them about the `:Tutor` command. Or even just verbally explain to
them about colon-commands. Something like that but as light as possible.
This is *exactly like riding a bike* and we need some training wheels here and a designed "letting go" moment.
## The Anatomy of an Overwhelming First Encounter
```bash
(nix) pipulate $ prompt
(nix) pipulate $ ahe
(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 (18 active line(s))
โ
Topological Integrity Verified: 47 candidate reference(s) scanned, all exist.
-> Executing: python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs ... [0.3249s]
-> Ruff exit 0 (clean).
๐ฆ Payload Ledger (biggest first)
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโณโโโโโโโโโโณโโโโโโโโโโโโณโโโโโโโโโโ
โ File / Source โ Tokens โ Bytes โ % Bytes โ
โกโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฉ
โ foo_files.py โ 82,785 โ 330,816 โ 28.5% โ
โ prompt_foo.py โ 48,213 โ 212,314 โ 18.3% โ
โ ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs โ 63,642 โ 165,747 โ 14.3% โ
โ flake.nix โ 33,460 โ 138,803 โ 12.0% โ
โ release.py โ 14,675 โ 65,186 โ 5.6% โ
โ PROMPT (checklist + prompt.md) โ 10,637 โ 48,592 โ 4.2% โ
โ /home/mike/repos/nixos/autognome.py โ 10,581 โ 47,651 โ 4.1% โ
โ init.lua โ 10,416 โ 39,888 โ 3.4% โ
โ apply.py โ 8,584 โ 36,636 โ 3.2% โ
โ remotes/honeybot/nixos/configuration.nix โ 6,068 โ 23,331 โ 2.0% โ
โ assets/installer/install.sh โ 4,257 โ 16,852 โ 1.5% โ
โ /home/mike/repos/Pipulate.com/install.md โ 2,308 โ 11,734 โ 1.0% โ
โ pyproject.toml โ 1,129 โ 4,104 โ 0.4% โ
โ .gitignore โ 970 โ 3,598 โ 0.3% โ
โ /home/mike/repos/Pipulate.com/_layouts/default.html โ 809 โ 3,177 โ 0.3% โ
โ remotes/honeybot/hooks/post-receive โ 940 โ 3,080 โ 0.3% โ
โ __init__.py โ 699 โ 2,888 โ 0.2% โ
โ requirements.in โ 675 โ 2,340 โ 0.2% โ
โ nixops.sh โ 477 โ 1,730 โ 0.1% โ
โ remotes/honeybot/www/npvg.org/index.html โ 331 โ 1,129 โ 0.1% โ
โ AUTO: Recent Git Diff Telemetry โ 222 โ 753 โ 0.1% โ
โ .gitattributes โ 33 โ 76 โ 0.0% โ
โ AUTO: Static Analysis Diagnostics โ 11 โ 39 โ 0.0% โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโผโโโโโโโโโโโโผโโโโโโโโโโค
โ TOTAL โ 301,922 โ 1,160,464 โ 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 (222 tokens | 753 bytes)
--- Prompt Summary ---
Summed Tokens: 304,162 (from section parts)
Verified Tokens: 306,529 (from final output)
(Difference: +2,367)
Total Words: 132,787 (content only)
Total Chars: 1,166,380
Total Bytes: 1,175,525 (UTF-8)
--- Size Perspective ---
๐ Equivalent in length to a **Epic Fantasy Novel** (Note: With a token/word ratio of 2.31, this content is far denser and more complex than typical prose of this length).
๐งผ Identity scrub: substitutions=57 rule(s) | denylist=0 rule(s)
๐ Render canary: 2 bare www-token(s) exposed to autolinking: www.mikelev.in, www.npvg.org
๐ Secrets tripwire: ARMED โ 0 hit(s) in payload.
๐ฆ Canonical context cartridge written to /home/mike/repos/pipulate/foo.zip (sha256=ca829d0f9c5bโฆ, members=3)
๐๏ธ Rotated cartridge snapshot: foo-ca829d0f-1547.zip (keeping newest 20 of 20)
Markdown output copied to clipboard
(nix) pipulate $
```
> **Note**: Captured thought:
```text
Thought for 7m 34s
Untangling a lengthy compiled request to find the actual ask.
Reviewing a terminal walkthrough and editor screenshot for issues.
Pinpointing why the vim mode indicator looks so confusing.
Planning a gentle onboarding tutorial for a first-time editor user.
Spotting a missing file needed to finish the task.
Drafting light-touch training wheels inside the editor experience.
Bridging familiar keys from less into vim's commands.
Checking for text-wrap risks that could corrupt long path lines.
Weighing spell-check and line-number tweaks for the router file.
Designing a headless check to verify the editor tweak.
Making sure headless output prints without extra noise.
Puzzling over an odd visual-mode cursor position in the screenshot.
Explaining curated context and the agentic-loop-versus-kata tradeoff.
Locating the source file needed to complete the patch.
Deciding where the header rewrite draft should live.
Weighing a small homepage tweak to teach the missing keys.
Deciding to keep this turn's changes to one small edit.
Deciding where the onboarding lesson should live instead.
Checking editor availability across different Mac setups.
Flagging a risky editor gap on unconfigured Mac setups.
Contrasting curated context against ad-hoc IDE search costs.
Framing the agentic loop as human-witnessed judgment already present.
Drafting friendly comment lines to teach basic vim commands.
Deciding how the router's training wheels come off later.
Designing quick probes to confirm each proposed fix.
Checking shell quoting details for the headless verification command.
Drafting a specific autocmd block for the router file.
Finalizing buffer-local resets for the router autocmd block.
Compiling the exact file list and probe commands to hand off.
Drafting a thorough exposition balancing detail with readability.
Listing each editor issue with its underlying cause.
Assembling the full response outline before writing it out.
Writing the friendly comment header for the router file.
Weighing whether editor pinning belongs in this same change.
Weighing whether a spoken hint fits the editor launch.
Verifying quoting and escaping details in the probe commands.
Confirming exact search text for the router patch.
Composing the beginner-friendly header text line by line.
Pinning the editor choice across every platform.
Contrasting sealed, reproducible setups with ad-hoc discovery.
Finalizing the precise patch block for the router file.
Double-checking the finished patch block for hidden formatting slips.
```
**Fable 5.1 Extra**: Context verified for the question this turn asks. One file is missing for the implementation you named, and I'll say which and why before anything else: the router header you showed is written by `_write_walk_router` in `scripts/mother_cat.py`, which is not in this payload. The Piper goodbye lives in the same file. So "make the contents of that first `adhocwalk.txt`" is a draft this turn and a patch next turn, and the draft rides in the caboose so it arrives with the writer. Everything else you asked for is answerable from what's here, and one small patch is possible against a file that is present.
## What the first `epr` screen says to a stranger
Reading your Mac screenshot cold, as someone who has never seen a terminal editor, there are five things on that screen, and none of them is explained by anything the stranger has been told.
**The lesson stopped one door early.** The walk narrates every stop, Piper says goodbye, the menu prints `epr edit prompt router`, and then `epr` opens a full-screen program with no instruction on it. The header comments in the file explain what the *file* is. Nothing explains what the *program* is, how to move in it, or how to leave. The install page did the opposite for `less`: it named the program before handing it over.
**The editor arrives wearing your journal.** `VIMINIT` loads the repo's `init.lua`, so the stranger gets the author's daily-driver settings, and three of them are wrong for a file of paths. `spell = true` underlines `npvg`, `decant`, `adhocwalk` and `UNSANITIZED` in red, which a newcomer reads as errors. `relativenumber = true` prints the gutter as `4 3 2 1 5`, which reads as nonsense. `textwidth = 80` will hard-wrap a path or `! ` command typed past column 80, turning one router line into two and breaking the file the guard then treats as hand-edited. Your own `adhoc.txt` already has the textwidth release; `adhocwalk.txt` never got it.
**The mode line reads VISUAL LINE.** A keystroke already changed modes (Shift+v, or a Caps Lock `v`), and the stranger has no idea what that word means or that Esc is the way out. That's why the first rule the header teaches has to be Esc.
**The page never taught `j`, `k`, `q`.** You remembered the `less` lesson as teaching the three keys. The `index.html` in this payload says `curl -fsSL https://npvg.org | less` and nothing about how to move or leave inside `less`. Your own 2026-09-19 seed-path TODO in `foo_files.py` already names that gap. This matters because the vim lesson wants to say "the same `j` and `k` you used in less," and today that sentence would be false.
**On a stranger's Mac it's worse than your Mac.** Your Mac has `nvim` installed, so `epr` found it. The flake pins no editor (the 2026-09-16 editor TODO), so a Mac without Neovim falls through `epr`'s chain to `/usr/bin/vim`, and `VIMINIT="luafile ..."` is an Ex command Apple's vim cannot run: INFERRED, unwitnessed, but the shape is E319 on the first keypress of the first editor a stranger ever opened. `:Tutor` is also a Neovim command, so the lesson below assumes the pin.
Also on that screen, and older than this ride: the header's own first line says "an edited router is never replaced," and the 2026-09-16 drill-down TODO already says the guard can't keep that promise for the one edit the header invites.
## Training wheels, and where the letting-go moment lives
The bike is the keys. A stranger who read the installer in `less` already has `j`, `k`, and `q` in their hands. Vim is the same three keys with one difference: `q` grows a colon. That's the entire bridge, and it's the only thing the header needs to say in its first breath.
The training wheels are comment lines in the router itself, at the exact moment the confusion happens, per your own rule that newcomer guidance names the visible cue and the next action. The letting go is mechanical: the first router a machine ever writes carries the full header; every later router carries a two-line header with just the keys. The rider already knows whether the router existed before the ride, because the guard reads it. So the wheels come off by themselves on the second walk, and if the stranger edited the file in between, the guard keeps their file, wheels and all, because it's theirs now.
No Piper for `epr`. Three reasons. Your 2026-09-15 ruling says the closing adds no command and no lesson, and adding "now type epr" would break it. A spoken sentence before the editor opens would cost a second of latency and repeat on every `epr` forever, which is the always-fires warning in audio. And the lesson belongs where the eyes are, on the screen that confused them.
The joke goes in the header because it does real work: it tells the stranger that being stuck is the normal first experience, not their failure. The form I'd use: the best random-string generator ever built is a beginner asked to exit vi. The Stack Overflow question about exiting Vim has been viewed millions of times; it is the most-visited page about a text editor on the internet, which is a fact a newcomer finds comforting.
The draft header is in the caboose, indented so it survives the fence. It's fourteen comment lines, two path lines, and it ends with the next action: `:q`, then `cpr`, and a promise that the next walk writes the file again without the notes.
## "Is that it?" Mostly, and you already do it
Yes, that's the industry's answer to the bottleneck: move the human from every step to the definition of done, write "what finished looks like" once, and let the loop run until the check passes. It's half right, and the half it gets wrong is the half your whole system is about.
The agentic loop doesn't remove the human's judgment; it moves it earlier, to a specification written before any evidence exists. That's the same shape as your own CONSENT CANNOT PRECEDE ITS OBJECT rule: an acceptance test typed at t=0 is consent to an artifact nobody has seen. And it removes the human's *practice*. The person who never reads the intermediate diffs loses the ability to read a diff, which is fine until the day the loop's output is wrong and the check didn't catch it, and there's no receipt, only "because Claude said so."
Your framework already contains the loop's good idea. THE RIDE CONTRACT declares arrival conditions at the mount. The dismount checks them against receipts. The difference is that your loop is unrolled: every iteration is a turn a human reads, and the reading is cheap because the receipts have a stable shape. A pilot doesn't audit the engine; a pilot reads instruments whose shape doesn't change from flight to flight. The straddle, the payload ledger, the `ARMED โ 0 hit(s)` line: those are instruments. The bottleneck isn't eliminated, it's converted from "audit N transformations" to "read N readings," and readings are what the forgetting kata keeps small enough to read.
Which is the difference you asked whether I see. The kata is wax-on wax-off: no judgment spent, a 3% reduction a day, and the skill myelinates. This turn is the fight, and it costs the calories the kata saved. Everybody else is agentic looping; the inverse bet is that the skill the loop makes optional, reading the receipt, is the one that stays valuable, because a receipt is the only thing that outlives the model that produced it.
The honest ceiling: at some scale even receipts exceed attention. You hit it today with GLOSSARY.md, 1,183,950 bytes with it and 1,045,428 without, 45 KB over Gemini's line. This compile is 1,183,071 bytes and fits Fable's window as plain text. The glossary is the excretion organ; the router is the tissue that stays.
## Not just file selection
For the New-B reading this, which is this book's word for the newcomer at the competent middle, neither talked down to nor snowed: a capable adult who has never opened a terminal editor.
When an IDE agent sets your context, the *model* chooses, at run time, by searching. It greps, opens files, summarizes what it found, and each of those is a tool call that costs tokens and produces a scroll you can't easily verify. Two sessions discover differently. The frame, if it arrives at all, arrives last, after the model has already formed a picture from whatever it happened to open first.
When the context is compiled, the human chose once, and the choice is a file you can read. But you're right that the file list is the least of it. Five things ride that the IDE approach structurally cannot:
**Order.** The router is read by two interpreters, CPython for the paths and the model for the prose, and the prose is pedagogy. The routing note, the poem, the chapter list, and the constitution arrive before a single line of code. The frame is encoded twice, in the declared map and in the realized files, so the marble rolls home wherever it lands.
**The metal.** `flake.nix`, `configuration.nix`, `requirements.in`, and `__init__.py` tell the model exactly what runs: Determinate Nix 3.19.1 over 2.34.6, Python 3.12.13, v2.58, 291 packages, chromium 150 paired with its driver, a Mac that needs no `--impure`. A model whose sandbox is Docker can't replay that, and it doesn't need to. What it gains is the collapse of ambiguity: it never has to guess which of six plausible setups this is, because the file says which. Most hallucination in coding assistance is the model resolving an ambiguity the human never noticed was open.
**Receipts.** The `!` lines are stdout captured on the operator's machine during this compile, indexed in the Manifest as the sole authority on what ran. The model reads a fact it never fetched and can cite the section marker it came from.
**The seal.** Same input, same bytes, same hash, in a zip a stranger can verify with the standard library. Discovery at run time has no hash.
**The anvil.** This is the one you named. Your code looks like FastAPI to a prior: decorators, routes, async handlers. A model handed a bare repo root reaches for FastAPI idioms, Pydantic models, Jinja templates, a `docker-compose.yml`, because that's where the mass of its training sits. The 2024-11-18 PATTERN ALERT article is the receipt that this happens. The compile repeats the counter-claim until the prior loses: Nix over Docker, HTMX over React, in the poem, in the chapter titles, in the flake's own comments. That's the gravity well you can see the lensing on, and the metaphor pays rent because the prediction is checkable: the same question, asked with IDE-discovered context and with a compiled cartridge, produces answers that assume versus answers that cite and refuse. The blind fan-out articles are where that measurement lives.
The cost is the one the Gemini editorial named. The human pays attention per compile, by hand. That's not a flaw in the method; it's the method, and the forgetting kata is how the bill stays payable.
## 1. PROBES
The first line locates the router writer and the goodbye in the file the next turn needs. The second is the straddle for the one patch below: BEFORE reads `tw=80 spell=true rnu=true`, AFTER reads `tw=0 spell=false rnu=false`; a fresh headless Neovim reads `init.lua` at call time, so no ignition is needed. The third and fourth are CENSUS lines, identical before and after: the page does not teach the three keys (0), and the flake does not pin an editor (0, printed by grep with a nonzero exit).
```bash
rg -n 'Written by the last completed walk|def _write_walk_router|Goodbye' scripts/mother_cat.py
VIMINIT='luafile init.lua' nvim --headless adhocwalk.txt -c 'lua io.write(string.format("tw=%d spell=%s rnu=%s\n", vim.bo.textwidth, tostring(vim.wo.spell), tostring(vim.wo.relativenumber)))' -c 'qa!'
grep -ciE 'moves (down|up)|press q' remotes/honeybot/www/npvg.org/index.html
grep -c 'neovim' flake.nix
```
## 2. NEXT CONTEXT
Keep the router you compiled this turn (the 40K-foot view fits Fable's window) and add these lines beneath it. `init.lua`, `flake.nix` and the pad's `index.html` are already there.
```text
# --- THE NEWCOMER'S FIRST VIM: the router writer and the menu that names epr ---
scripts/mother_cat.py
scripts/boot_menu.py
! rg -n 'Written by the last completed walk|def _write_walk_router|Goodbye' scripts/mother_cat.py
! VIMINIT='luafile init.lua' nvim --headless adhocwalk.txt -c 'lua io.write(string.format("tw=%d spell=%s rnu=%s\n", vim.bo.textwidth, tostring(vim.wo.spell), tostring(vim.wo.relativenumber)))' -c 'qa!'
! grep -ciE 'moves (down|up)|press q' remotes/honeybot/www/npvg.org/index.html
! grep -c 'neovim' flake.nix
```
## 3. PATCHES
One car, against a file in this payload. It fixes the three things the journal config does to a router buffer, buffer-locally, and touches nothing you use on `adhoc.txt`. The header rewrite, the page's three keys, and the editor pin are one fence next turn, because each depends on the others.
**Car 1: the router buffer is a list, not prose.**
```text
Target: init.lua
[[[SEARCH]]]
-- adhoc.txt: margins permanently released (masthead art, wide-format work)
vim.api.nvim_create_autocmd({"BufRead", "BufNewFile"}, {
pattern = "adhoc.txt",
callback = function()
vim.opt_local.textwidth = 0
end,
})
[[[DIVIDER]]]
-- adhoc.txt: margins permanently released (masthead art, wide-format work)
vim.api.nvim_create_autocmd({"BufRead", "BufNewFile"}, {
pattern = "adhoc.txt",
callback = function()
vim.opt_local.textwidth = 0
end,
})
-- adhocwalk.txt: the router a walk writes and `epr` opens, which is a
-- newcomer's first vim (2026-09-20, read off the first Mac epr screen).
-- THE ROUTER IS A LIST, NOT PROSE: every line is a path or a `! ` command,
-- so the journal defaults above are wrong here in three ways a newcomer sees
-- at once. spell paints every path red, which reads as errors. textwidth=80
-- hard-wraps a path or command typed past the column, turning one router
-- line into two and breaking it. relativenumber counts distance from the
-- cursor, which reads as 4 3 2 1 5 to someone meeting it cold. Three
-- buffer-local resets, nothing global; adhoc.txt keeps its own release above.
vim.api.nvim_create_autocmd({"BufRead", "BufNewFile"}, {
pattern = "adhocwalk.txt",
callback = function()
vim.opt_local.textwidth = 0
vim.opt_local.spell = false
vim.opt_local.relativenumber = false
end,
})
[[[REPLACE]]]
```
Ignition: none required for the compile-lane witness; the echoed probe starts a fresh Neovim that reads `init.lua` at call time. For a session you already have open, ``. The Mac picks it up on its next `nix develop`, which pulls the commit before the next `epr`.
## 4. PROMPT
```text
The router is the newcomer's first vim, and this turn carries the file that writes it. Three cars, all small, riding in one fence because each depends on the others: the header says j and k were met in less, so the page must teach them; the header names :Tutor, so the editor must be Neovim on every platform. The init.lua buffer-local resets landed last turn; the second echoed probe is their AFTER.
Car 1, scripts/mother_cat.py, _write_walk_router: record whether the router existed BEFORE the ride starts, not at write time, because the rider writes it twice per ride (once after ARCHIVE STATUS, once after DECANT). A router that did not exist before the ride gets the training-wheels header; every later write gets the short header. Replace "Edit freely: an edited router is never replaced" with the true sentence, "The next walk rewrites this file unless you have edited it," which also discharges the header half of the 2026-09-16 drill-down TODO. The guard is untouched. Piper's goodbye is untouched (the 2026-09-15 ruling: the closing adds no command and no lesson).
Training-wheels header, comment lines only, the writer fills the two path lines:
# This is vim. Nothing here needs typing today.
# Two keys from less still work: j moves down, k moves up.
# Leaving takes one more key than less did: type :q and press Enter.
# Every colon-command works that way. Esc backs out of anything else.
# (The old joke: the best random-string generator is a beginner asked to exit vi.)
#
# This file is your prompt router: one line per thing the AI will see.
# A file path, or a command after `! `. Lines starting with # are skipped.
# The checked preview rides. The whole UNSANITIZED archive is the commented line beneath it.
/Users/michaellevin/npvg/data/decant-preview.md
# /Users/michaellevin/npvg/data/captures/walk-7_r2ybpy/captures.md
#
# To change a line: i starts typing, Esc stops, u undoes. :wq saves and quits; :q! quits without saving.
# Thirty minutes of practice whenever you want it: type :Tutor and press Enter.
# Next: :q then cpr at the prompt. The next walk writes this file again without these notes.
Short header, every later write:
# Written by the last completed walk. Keys: j down, k up, :q quits, :wq saves and quits.
# One line per thing the AI should see: a file path, or a command after `! `.
# The checked preview rides. The whole UNSANITIZED archive is the commented line beneath it.
# The next walk rewrites this file unless you have edited it.
Car 2, remotes/honeybot/www/npvg.org/index.html: one sentence after the less line, "Inside less, j moves down, k moves up, and q quits." Fix "The first commands lets you" to "The first command lets you" in the same car. Ignition: ./nixops.sh, no rebuild. AFTER: the grep -ciE probe reads 1, and a curl with a non-curl user agent against the pad reads the sentence (the door serves the page only when the agent is not curl or wget).
Car 3, flake.nix commonPackages: neovim, one line, so epr, :Tutor and VIMINIT's luafile are the same editor on Linux, macOS and WSL; today a Mac without nvim falls to /usr/bin/vim, where luafile is INFERRED to error at load. Gate before it rides: nix eval --raw .#devShells.aarch64-darwin.quiet.drvPath and the x86_64-linux twin both evaluate. Ignition: exit then nix develop. AFTER: grep -c 'neovim' flake.nix reads 1 (2 if the comment names it: predict the epitaph).
Straddle for Car 1: import _write_walk_router into a throwaway directory with the pre-existence flag forced both ways and count comment lines in each output; name the exact spelling once the function's signature is in context. Do not ride the trail, Piper, or the menu copy; scripts/boot_menu.py is here only so the epr line can name the editor if that reads as a one-word change and not a lesson.
```
## 5. EXTERNAL DELIVERABLES
None this turn outside the repo.
**MikeLev.in**: After all that I missed one file, ha ha!
> 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**:
```bash
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ rg -n 'Written by the last completed walk|def _write_walk_router|Goodbye' scripts/mother_cat.py
VIMINIT='luafile init.lua' nvim --headless adhocwalk.txt -c 'lua io.write(string.format("tw=%d spell=%s rnu=%s\n", vim.bo.textwidth, tostring(vim.wo.spell), tostring(vim.wo.relativenumber)))' -c 'qa!'
grep -ciE 'moves (down|up)|press q' remotes/honeybot/www/npvg.org/index.html
grep -c 'neovim' flake.nix
338:def _write_walk_router(archive_path, preview_path=None):
375: "# Written by the last completed walk. Edit freely: an edited router is never replaced.\n"
1038: "Review any summary before sharing it. Goodbye."
1041: "Read the results in your terminal. Goodbye."
init.lua loaded successfully!tw=80 spell=true rnu=true
0
0
(nix) pipulate $
```
**2: Context**:
```text
# AD HOC CHOP! The Not-Managed-by-Git Safe-for-Client-Data place. Insert Simpson Couch Gag in white space below (explain anything to the audience you feel needs it explained)G
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | This is *exactly like riding a bike* and we need some training wheels here and a designed "letting go" moment. Let's take good care of the New-B's. ***WE NEED TO HAVE A LOT OF EMPATHY WITH THEM***.
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | That looks like a very small context. Are you sure that's enough? To I have to be explicit about re-including the ones you know I'm going to be editing out on turn 2 from the 40K-FT VIEW?
# 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 `