The Wright Brothers Principle: Engineering Truthful AI Workflows
Setting the Stage: Context for the Curious Book Reader
This entry explores the shift from passive consumption of AI-generated code to active, instrumented engineering. By applying the Wright Brothers’ method—building the wind tunnel before the plane—we transform unpredictable AI interactions into a reliable, verifiable architecture of digital craftsmanship.
Technical Journal Entry Begins
🔗 Verified Pipulate Commits:
MikeLev.in: And here’s the thing that surprised the AI Editor on the last turn:
The most surprising element is the emergence of ‘metadata as a self-documentation artifact.’ By using AST to bridge the gap between static code and dynamic runtime, you’ve created a system that is essentially ‘self-aware’ of its own capabilities without needing a complex agentic layer to interpret them. It suggests a future where API documentation is obsolete because the code is its own machine-readable spec.
How is that surprising? Isn’t that just a logical conclusion? Everyone’s going to realize that their markdown files aren’t real code and it’s always drifting from the source-of-truth actual code which is perfectly capable of supporting internal strings that have zero bearing on the Abstract Syntax Tree (AST / we ought to spell out that acronym more often). This creates a positive/negative space that’s very much like twisted pair or the DNA double helix or fractal wavelets or even just plain rhyming. Things don’t get nearly as out of drift because the document about a thing and the thing being documented are one and the same!
Do you know that Dalton success assured moment? We have all the parts here. We
just made that weblogin thing and I used it to log into Botify. And now I just
scraped my most simple base URL which… well, I’ll let you tell me. And I just
had a head-smack moment. I need to make my use of lines like this:
!https://app.botify.com/michaellevin-org/mikelev.in/
…I need a way to tell it to use the profile that I warmed up with weblogin
so that it’s logged in when it pops up. What is the best way to handle this?
It’s only important on the crawl and not a cache, so it may just be one more
unused directive, sigil or whatever you want to call it. Semantically, it should
go with !. Maybe ? for “who are you?” If you agree you can go right to
implementation, please and thank you!
Opus 4.8 High: Context verified.
Quick answer to the aside: it’s surprising to the model, not to you, because most of its training corpus treats docs and code as separate artifacts that a human keeps in sync by discipline. What you’ve built removes the gap rather than policing it — the docstring the AST reads and the function the runtime calls are the same bytes. That’s exactly your twisted-pair / double-helix intuition: the documenting strand and the documented strand are physically bonded, so they can’t shear apart. It is the logical conclusion; it just isn’t the default one, which is why it reads as a small revelation.
The Double Helix of Documentation and Code
And here’s your Dalton moment made visible: look at what your !https://app.botify.com/... scrape actually returned. The SEO lens says title: "Login", the outline is “Welcome Back! / Sign in with Google,” and the Link Lens redirected you to /signin/?next=.... Even though weblogin warmed a real session, the !URL path runs selenium_automation with a temporary profile (persistent=False), so the popup wasn’t you — it was an anonymous stranger who got bounced to the login wall. The scrape proving the need is sitting right there in the payload.
On the sigil: I agree with ?. It reads as “who are you?”, it pairs naturally with ! as a fresh crawl, and as a leading sigil it’s stripped before the URL so it never collides with a query string. Semantics: ?URL = a fresh crawl exactly like !URL, but routed through weblogin’s persistent data/uc_profiles/default — auth only matters on a live flight, so it busts cache like ! (a cache hit needs no login). scraper_tools already accepts persistent/profile_name and defaults the name to "default", the same directory weblogin writes — so this is a two-line wiring job plus its documentation.
Implementing the ?URL Authenticated Sigil
One operational gotcha worth banking: close the weblogin window before a ?URL compile — Chrome locks the profile, and the scrape pops up visibly (headless=False) precisely so you can confirm the login carried over.
1. PROBES — bounded, read-only, straddle the patch. First run gives the empty BEFORE; the echoed re-run next compile is the AFTER.
grep -c "'?http" prompt_foo.py
grep -n "authenticated = path.startswith" prompt_foo.py
grep -n "persistent profile (authenticated crawl)" prompt_foo.py
grep -n "authenticated crawl" foo_files.py
grep -c "'?http" is a clean 0→1 delta on the detection tuple; the three grep -n lines go from empty to one line each, confirming the sigil landed in all four edit sites (dispatch, roster, and the foo_files sigil doc).
2. NEXT CONTEXT — adhoc.txt for the after-compile:
prompt_foo.py
foo_files.py
scripts/weblogin.py
tools/scraper_tools.py
! grep -c "'?http" prompt_foo.py
! grep -n "authenticated = path.startswith" prompt_foo.py
! grep -n "persistent profile (authenticated crawl)" prompt_foo.py
! grep -n "authenticated crawl" foo_files.py
Once you’ve re-warmed with weblogin botify.com and closed that window, add the real functional AFTER as its own line — it will pop a logged-in browser during compile and stack the project view instead of the Login page:
?https://app.botify.com/michaellevin-org/mikelev.in/
3. PATCHES
Target: prompt_foo.py
[[[SEARCH]]]
# HANDLE REMOTE URLS (And JIT Optical Distillation)
if path.startswith(('http://', 'https://', '!http://', '!https://', '@http://', '@https://', '$http://', '$https://', '%http://', '%https://')):
target_url = path[1:].strip() if path.startswith(('!', '@', '$', '%')) else path.strip()
[[[DIVIDER]]]
# HANDLE REMOTE URLS (And JIT Optical Distillation)
if path.startswith(('http://', 'https://', '!http://', '!https://', '@http://', '@https://', '$http://', '$https://', '%http://', '%https://', '?http://', '?https://')):
target_url = path[1:].strip() if path.startswith(('!', '@', '$', '%', '?')) else path.strip()
[[[REPLACE]]]
Target: prompt_foo.py
[[[SEARCH]]]
elif path.startswith(('!', '@')):
# JIT OPTICAL DISTILLATION (The MST3K Balcony)
logger.print(f" -> 👁️🗨️ Engaging LLM Optics for: {target_url}")
[[[DIVIDER]]]
elif path.startswith(('!', '@', '?')):
# JIT OPTICAL DISTILLATION (The MST3K Balcony)
# ?URL is the AUTHENTICATED variant: a fresh crawl like !URL, but
# on the persistent house profile weblogin warmed, so the popup
# browser arrives already logged in. Login only matters on a live
# flight, so ? busts cache exactly like ! (a cache hit needs none).
authenticated = path.startswith('?')
if authenticated:
logger.print(f" -> 🔑 Engaging AUTHENTICATED LLM Optics (weblogin profile) for: {target_url}")
else:
logger.print(f" -> 👁️🗨️ Engaging LLM Optics for: {target_url}")
[[[REPLACE]]]
Target: prompt_foo.py
[[[SEARCH]]]
scrape_params = {
"url": target_url, "domain": domain, "url_path_slug": path_slug,
"take_screenshot": False, "headless": False, "is_notebook_context": True, "verbose": False,
"override_cache": path.startswith('!') # 💥 Bust cache with !, reuse cache with @
}
[[[DIVIDER]]]
scrape_params = {
"url": target_url, "domain": domain, "url_path_slug": path_slug,
"take_screenshot": False, "headless": False, "is_notebook_context": True, "verbose": False,
"override_cache": path.startswith(('!', '?')), # 💥 Bust cache with ! or ?, reuse with @
"persistent": authenticated, # 🔑 ? reuses weblogin's warmed data/uc_profiles/default
}
[[[REPLACE]]]
Target: prompt_foo.py
[[[SEARCH]]]
"- `!URL` — scrape fresh (cache-bust) and stack the optics lenses.",
"- `@URL` — reuse the scrape cache and stack the same optics lenses.",
[[[DIVIDER]]]
"- `!URL` — scrape fresh (cache-bust) and stack the optics lenses.",
"- `?URL` — like `!URL`, but on weblogin's persistent profile (authenticated crawl).",
"- `@URL` — reuse the scrape cache and stack the same optics lenses.",
[[[REPLACE]]]
Target: foo_files.py
[[[SEARCH]]]
# !URL scrape fresh (cache-bust) -> six lenses stacked into context
# @URL scrape via cache -> same lenses, no new flight
[[[DIVIDER]]]
# !URL scrape fresh (cache-bust) -> six lenses stacked into context
# ?URL like !URL but on weblogin's persistent profile (authenticated crawl)
# @URL scrape via cache -> same lenses, no new flight
[[[REPLACE]]]
Actuate: patch, app, d, m — one car, one commit story (“feat(optics): add ?URL authenticated-scrape sigil via weblogin profile”).
4. PROMPT — caboose copy for the next turn, run after the ?URL scrape lands:
**MikeLev.in**: The ?URL authenticated sigil is in. Verify the AFTER: this compile's
receipts should now show grep hits for the ?http tuple, the `authenticated`
branch, the roster line, and the foo_files doc line. If I added the
?https://app.botify.com/michaellevin-org/mikelev.in/ line, compare its SEO
lens and Link Lens against the earlier Login-page scrape — did the persistent
profile carry the login through, or did it bounce to /signin again? If it
bounced, diagnose whether the cause is a stale weblogin session, a
profile-lock collision, or a CWD mismatch between prompt_foo and weblogin's
data/uc_profiles/default. Then bank the win: dismount if the authenticated
scrape returned real project data.
5. EXTERNAL DELIVERABLES — none. This is all in-repo.
MikeLev.in:
Probe:
$ git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ grep -c "'?http" prompt_foo.py
grep -n "authenticated = path.startswith" prompt_foo.py
grep -n "persistent profile (authenticated crawl)" prompt_foo.py
grep -n "authenticated crawl" foo_files.py
0
(nix) pipulate $
Context:
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | F5
# / _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Of course I'm inserting a test here
# / ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_|
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# AD HOC CHOP: The Not-Managed-by-Git Safe-for-Client-Data place.
# BIG STANDARD STUFF (Optionally comment out any)
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- This is the "Rolling Pin" that gives a 40K foot airplane view.
~/repos/nixos/autognome.py # <-- Letting the AIs really understand my environment (the one of these which is not like the others)
foo_files.py # <-- This is the router, evolving book outline and the things you pin-up to produced the recursive self-improvement loops
prompt_foo.py # <-- Prompt Fu compiler, makes the very README for AGENTS-like payload you're reading right now, but it needs to be more like that
.gitattributes # <-- Model: understand that `nbstripout` and `jupytext` are both in play. Just talk the human through .ipynb patches.
.gitignore # <-- Creates "negative space" for sub-rep's to share parent environment and "snap" proprietary secret features into place.
init.lua # <-- Daily driver hot-keys that overlap with aliases in flake.nix
flake.nix # <-- Solves world's WRITE ONCE RUN ANYWHERE problem like Java never could. Also resolves the bootstrap paradox.
apply.py # <-- How can "Web UI" ChatBots edit your code? With this Aider-inspired Player Piano patch applier.
scripts/xp.py # <-- Transforms host OS copy-paste buffer player-piano music into context-payload.
scripts/ai.py # <-- How I constantly use local AI to write git commit messages with `m` alias.
cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# --- Under this line is were you paste what the AI gives you ---
# --- We call it context but it's really just the right-hand ---
# --- blast-radius of the "probes" to make this all science. ---
prompt_foo.py
foo_files.py
scripts/weblogin.py
tools/scraper_tools.py
! grep -c "'?http" prompt_foo.py
! grep -n "authenticated = path.startswith" prompt_foo.py
! grep -n "persistent profile (authenticated crawl)" prompt_foo.py
! grep -n "authenticated crawl" foo_files.py
?https://app.botify.com/michaellevin-org/mikelev.in/
Patches: [patch, app, d, m, patch, app, d, m…]
$ git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'prompt_foo.py'.
(nix) pipulate $ d
diff --git a/prompt_foo.py b/prompt_foo.py
index 9833341f..4c9fdb45 100644
--- a/prompt_foo.py
+++ b/prompt_foo.py
@@ -1980,8 +1980,8 @@ def main():
continue
# HANDLE REMOTE URLS (And JIT Optical Distillation)
- if path.startswith(('http://', 'https://', '!http://', '!https://', '@http://', '@https://', '$http://', '$https://', '%http://', '%https://')):
- target_url = path[1:].strip() if path.startswith(('!', '@', '$', '%')) else path.strip()
+ if path.startswith(('http://', 'https://', '!http://', '!https://', '@http://', '@https://', '$http://', '$https://', '%http://', '%https://', '?http://', '?https://')):
+ target_url = path[1:].strip() if path.startswith(('!', '@', '$', '%', '?')) else path.strip()
if path.startswith('$'):
# CACHE MATERIALIZATION ($URL): headers + raw source only.
(nix) pipulate $ m
📝 Committing: chore: Update remote URL regex in prompt_foo.py
[main 24d196a5] chore: Update remote URL regex in prompt_foo.py
1 file changed, 2 insertions(+), 2 deletions(-)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'prompt_foo.py'.
(nix) pipulate $ d
diff --git a/prompt_foo.py b/prompt_foo.py
index 4c9fdb45..6b7c9134 100644
--- a/prompt_foo.py
+++ b/prompt_foo.py
@@ -2036,9 +2036,17 @@ def main():
"path": f"OPTICS [Wire Truth]: {target_url}", "comment": comment, "content": content,
"tokens": count_tokens(content), "words": count_words(content), "lang": "markdown"
})
- elif path.startswith(('!', '@')):
+ elif path.startswith(('!', '@', '?')):
# JIT OPTICAL DISTILLATION (The MST3K Balcony)
- logger.print(f" -> 👁️🗨️ Engaging LLM Optics for: {target_url}")
+ # ?URL is the AUTHENTICATED variant: a fresh crawl like !URL, but
+ # on the persistent house profile weblogin warmed, so the popup
+ # browser arrives already logged in. Login only matters on a live
+ # flight, so ? busts cache exactly like ! (a cache hit needs none).
+ authenticated = path.startswith('?')
+ if authenticated:
+ logger.print(f" -> 🔑 Engaging AUTHENTICATED LLM Optics (weblogin profile) for: {target_url}")
+ else:
+ logger.print(f" -> 👁️🗨️ Engaging LLM Optics for: {target_url}")
from tools.scraper_tools import selenium_automation
from urllib.parse import urlparse, quote
(nix) pipulate $ m
📝 Committing: chore: Refactor LLM optics logging with authenticated URL handling
[main f0dbf0ca] chore: Refactor LLM optics logging with authenticated URL handling
1 file changed, 10 insertions(+), 2 deletions(-)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'prompt_foo.py'.
(nix) pipulate $ d
diff --git a/prompt_foo.py b/prompt_foo.py
index 6b7c9134..18fb3474 100644
--- a/prompt_foo.py
+++ b/prompt_foo.py
@@ -2057,7 +2057,8 @@ def main():
scrape_params = {
"url": target_url, "domain": domain, "url_path_slug": path_slug,
"take_screenshot": False, "headless": False, "is_notebook_context": True, "verbose": False,
- "override_cache": path.startswith('!') # 💥 Bust cache with !, reuse cache with @
+ "override_cache": path.startswith(('!', '?')), # 💥 Bust cache with ! or ?, reuse with @
+ "persistent": authenticated, # 🔑 ? reuses weblogin's warmed data/uc_profiles/default
}
import asyncio
(nix) pipulate $ m
📝 Committing: fix(prompt_foo): Update cache override logic
[main 80f82f01] fix(prompt_foo): Update cache override logic
1 file changed, 2 insertions(+), 1 deletion(-)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'prompt_foo.py'.
(nix) pipulate $ d
diff --git a/prompt_foo.py b/prompt_foo.py
index 18fb3474..2d913bf8 100644
--- a/prompt_foo.py
+++ b/prompt_foo.py
@@ -1728,6 +1728,7 @@ def main():
"- Execute a tool — `.venv/bin/python cli.py call <tool_name> --json-args '{...}'`.",
"- `! command` — execute a bounded chisel-strike and compile stdout/stderr as a live receipt.",
"- `!URL` — scrape fresh (cache-bust) and stack the optics lenses.",
+ "- `?URL` — like `!URL`, but on weblogin's persistent profile (authenticated crawl).",
"- `@URL` — reuse the scrape cache and stack the same optics lenses.",
"- `$URL` — materialize cached `headers.json` and `source.html`.",
"- `%URL` — distill cached `network_log.jsonl` into request and host summaries.",
(nix) pipulate $ m
📝 Committing: fix(prompt_foo): Introduce ?URL for authenticated crawls
[main 9abd1908] fix(prompt_foo): Introduce ?URL for authenticated crawls
1 file changed, 1 insertion(+)
(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 9cd7a7d3..19ac0424 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -598,6 +598,7 @@ tools/scraper_tools.py # <-- Pop-up desktop browser automation that works consi
# performance log to browser_cache/<domain>/<slug>/network_log.jsonl — the
# network conversation the page actually had, not a reenactment. URL sigils:
# !URL scrape fresh (cache-bust) -> six lenses stacked into context
+# ?URL like !URL but on weblogin's persistent profile (authenticated crawl)
# @URL scrape via cache -> same lenses, no new flight
# $URL materialize cached headers.json + source.html (wire-truth extract)
# %URL distill cached network_log.jsonl -> per-request table + host census
(nix) pipulate $ m
📝 Committing: chore: Update documentation for URL sigils in scraper tools
[main 0da78764] chore: Update documentation for URL sigils in scraper tools
1 file changed, 1 insertion(+)
(nix) pipulate $ git push
Enumerating objects: 18, done.
Counting objects: 100% (18/18), done.
Delta compression using up to 48 threads
Compressing objects: 100% (15/15), done.
Writing objects: 100% (15/15), 2.10 KiB | 2.10 MiB/s, done.
Total 15 (delta 10), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (10/10), completed with 3 local objects.
To github.com:pipulate/pipulate.git
7add204e..0da78764 main -> main
(nix) pipulate $
And we follow the instructions to do weblogin botify.com again:
(nix) pipulate $ weblogin botify.com
weblogin: opening https://botify.com
Profile: /home/mike/repos/pipulate/data/uc_profiles/default
Log in, then simply CLOSE the browser window when you're done.
weblogin: persistent login preserved for botify.com in /home/mike/repos/pipulate/data/uc_profiles/default
weblogin: sites expire sessions over time -- re-run weblogin if scrapes hit login walls.
weblogin: close this browser before running a scrape (Chrome locks the profile).
(nix) pipulate $
Prompt:
The ?URL authenticated sigil is in. Verify the AFTER: this compile’s receipts
should now show grep hits for the ?http tuple, the authenticated branch, the
roster line, and the foo_files doc line. If I added the
?https://app.botify.com/michaellevin-org/mikelev.in/ line, compare its SEO lens
and Link Lens against the earlier Login-page scrape — did the persistent profile
carry the login through, or did it bounce to /signin again? If it bounced,
diagnose whether the cause is a stale weblogin session, a profile-lock
collision, or a CWD mismatch between prompt_foo and weblogin’s
data/uc_profiles/default. Then bank the win: dismount if the authenticated
scrape returned real project data.
🎤
Opus 4.8 High: Context verified.
And here’s the head-smack in the other direction: you already built it. ? is not a proposal — it’s the sigil that scraped the very payload you’re reading.
The live receipts in this compile’s Manifest are unambiguous:
prompt_foo.py:2046→authenticated = path.startswith('?')prompt_foo.py:1731→ the Tool Roster line?URL — like !URL, but on weblogin's persistent profile (authenticated crawl)foo_files.py:601→ the Chapter VIII grammar comment saying the same thing- The
'?httpsigil tuple returns1— it’s wired into the URL dispatch
And the proof isn’t just that the code exists — it fired. Your processing log for this run shows 🔑 Engaging AUTHENTICATED LLM Optics (weblogin profile) for: https://app.botify.com/michaellevin-org/mikelev.in/, and the OPTICS lenses came back logged in: the SEO title is “Botify |
mikelev.in | michaellevin-org,” the Semantic Outline shows the authenticated left-nav (analytics/overview, actionboard, activation/hub, studio, /o/assist), and the Wire Truth shows real authenticated API traffic (/api/v1/authentication/profile, /saved_explorers, the activation graphql). An anonymous hit would have bounced you to a login wall. You warmed the profile with weblogin botify.com, and ? inherited that session exactly as designed. |
The design you were about to reach for is the design that’s there:
?busts cache like!(override_cache = path.startswith(('!', '?'))) — login only matters on a live flight, so a cache hit needs no auth.?flipspersistent=True, which routes the scraper todata/uc_profiles/default— the same profileweblogin.pywarms by default. That path alignment is the entire mechanism.?sits with!/@in the live-flight branch;$/%stay cache-only, correctly untouched.
On your opener — you’re right that it’s a logical conclusion, not a surprise. But the reason people remark on it is that almost nobody closes the loop. Most systems keep the doc and the code as separate artifacts, which is precisely the sibling-.md drift your own “generated-not-authored” rule exists to refuse. What’s rare isn’t the idea; it’s the discipline of making the doc a projection of the code so drift is structurally impossible. Your Tool Roster is the receipt: it’s AST-derived from tools/*.py each compile (“21 tools”), so it can only ever be right or loudly broken — never quietly stale. The positive/negative-space, double-helix thing you’re describing is measurable here: the grep receipts prove the prose at line 1731 equals the behavior at line 2046, zero drift, this compile.
So the “go right to implementation” instinct would produce a dead car — apply.py would just report PATCH ALREADY APPLIED. The correct move is to bank the win and dismount.
The one genuine seam worth confirming before you call it done: ? only inherits the login if the two sides truly share one on-disk profile, and if you closed the weblogin window (Chrome locks the profile). The receipts prove the session was inherited this run, but the path-alignment is worth a standing probe.
1. PROBES
grep -rn "uc_profiles" scripts/weblogin.py tools/scraper_tools.py
grep -n "profile_name" tools/scraper_tools.py prompt_foo.py
The first proves weblogin.py and the ?-triggered scraper write/read the same data/uc_profiles/<name> root — the mechanism ? rides on. The second falsifies “maybe ? lands on a different profile”: prompt_foo.py’s scrape_params passes no profile_name, so it must default to "default", matching weblogin’s default. If either diverged, ? would silently scrape logged-out.
2. NEXT CONTEXT
Echo the probes into adhoc.txt for the AFTER receipt, drop the now-spent grep lines, keep the ?-scraped Botify URL as living proof:
! grep -rn "uc_profiles" scripts/weblogin.py tools/scraper_tools.py
! grep -n "profile_name" tools/scraper_tools.py prompt_foo.py
scripts/weblogin.py
tools/scraper_tools.py
prompt_foo.py
?https://app.botify.com/michaellevin-org/mikelev.in/
3. PATCHES
No repo patches required. The ? sigil is implemented, roster-documented, grammar-documented, and witnessed firing in this compile. Re-emitting it would be a dead car.
4. PROMPT (caboose copy for the next turn)
**MikeLev.in**: Confirmed — `?` was already done and it scraped this very payload. The ride's stated goal (an authenticated crawl sigil paired with `!`) is reached. Dismount.
1. VERIFY: restate that the goal was to add an authenticated-crawl directive, and confirm against THIS compile's receipts (the 🔑 log line + logged-in Botify lenses), not memory.
2. BANK: the `?URL` sigil graduates. Give the exact one-line grammar entry (if any) still owed, plus any foo_files.py Chapter VIII line to tighten. If nothing's owed, say so.
3. DANGLING: the profile-lock trap — if the weblogin window is left open, Chrome locks data/uc_profiles/default and `?` fails. One line: is a preflight lock-check worth a guard in scraper_tools.py, or is the weblogin.py "close before scraping" warning sufficient?
4. SEED: adhoc.txt lines for the next ride if we chase the lock guard; otherwise state the ride is fully banked.
5. EXTERNAL DELIVERABLES
None.
MikeLev.in:
Probe:
(nix) pipulate $ grep -rn "uc_profiles" scripts/weblogin.py tools/scraper_tools.py
grep -n "profile_name" tools/scraper_tools.py prompt_foo.py
scripts/weblogin.py:7:(data/uc_profiles/<profile>) — navigates to the given site, and waits for
scripts/weblogin.py:29:# CWD-relative 'data/uc_profiles/<name>' and the server/scraper run from the
scripts/weblogin.py:114: profile_path = REPO_ROOT / "data" / "uc_profiles" / args.profile
tools/scraper_tools.py:330: profile_path = Path(f"data/uc_profiles/{profile_name}")
tools/scraper_tools.py:155: profile_name = params.get("profile_name", "default")
tools/scraper_tools.py:330: profile_path = Path(f"data/uc_profiles/{profile_name}")
prompt_foo.py:2473: profile_name, profile = load_disclosure_profile(args.profile)
prompt_foo.py:2476: print(f"⚠️ Unknown denylist mode {denylist_mode!r} in profile {profile_name!r}; clamping to 'block'.")
prompt_foo.py:2482: print(f"🛑 Profile {profile_name!r} requires --reason \"why this run is authorized\". Nothing emitted.")
prompt_foo.py:2522: receipt = (f"🔓 DISCLOSURE: profile={profile_name} | "
(nix) pipulate $
Context:
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | F5
# / _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Of course I'm inserting a test here
# / ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_|
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# AD HOC CHOP: The Not-Managed-by-Git Safe-for-Client-Data place.
# BIG STANDARD STUFF (Optionally comment out any)
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- This is the "Rolling Pin" that gives a 40K foot airplane view.
~/repos/nixos/autognome.py # <-- Letting the AIs really understand my environment (the one of these which is not like the others)
foo_files.py # <-- This is the router, evolving book outline and the things you pin-up to produced the recursive self-improvement loops
prompt_foo.py # <-- Prompt Fu compiler, makes the very README for AGENTS-like payload you're reading right now, but it needs to be more like that
.gitattributes # <-- Model: understand that `nbstripout` and `jupytext` are both in play. Just talk the human through .ipynb patches.
.gitignore # <-- Creates "negative space" for sub-rep's to share parent environment and "snap" proprietary secret features into place.
init.lua # <-- Daily driver hot-keys that overlap with aliases in flake.nix
flake.nix # <-- Solves world's WRITE ONCE RUN ANYWHERE problem like Java never could. Also resolves the bootstrap paradox.
apply.py # <-- How can "Web UI" ChatBots edit your code? With this Aider-inspired Player Piano patch applier.
scripts/xp.py # <-- Transforms host OS copy-paste buffer player-piano music into context-payload.
scripts/ai.py # <-- How I constantly use local AI to write git commit messages with `m` alias.
cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# --- Under this line is were you paste what the AI gives you ---
# --- We call it context but it's really just the right-hand ---
# --- blast-radius of the "probes" to make this all science. ---
! grep -rn "uc_profiles" scripts/weblogin.py tools/scraper_tools.py
! grep -n "profile_name" tools/scraper_tools.py prompt_foo.py
scripts/weblogin.py
tools/scraper_tools.py
prompt_foo.py
?https://app.botify.com/michaellevin-org/mikelev.in/
Patches: [patch, app, d, m, patch, app, d, m…]
None
Prompt:
MikeLev.in: Confirmed — ? was already done and it scraped this very payload. The ride’s stated goal (an authenticated crawl sigil paired with !) is reached. Dismount.
- VERIFY: restate that the goal was to add an authenticated-crawl directive, and confirm against THIS compile’s receipts (the 🔑 log line + logged-in Botify lenses), not memory.
- BANK: the
?URLsigil graduates. Give the exact one-line grammar entry (if any) still owed, plus any foo_files.py Chapter VIII line to tighten. If nothing’s owed, say so. - DANGLING: the profile-lock trap — if the weblogin window is left open, Chrome locks data/uc_profiles/default and
?fails. One line: is a preflight lock-check worth a guard in scraper_tools.py, or is the weblogin.py “close before scraping” warning sufficient? - SEED: adhoc.txt lines for the next ride if we chase the lock guard; otherwise state the ride is fully banked.
And do a little success dance. Oh, and explain that Dalton wind tunnel success assured moments. Now might be an opportune time.
🎤
Opus 4.8 High: Context verified.
You already shipped it. The instinct to “go right to implementation” would have produced a dead car — apply.py would just say PATCH ALREADY APPLIED — because ? is the sigil that scraped the very payload we’re standing in. So this isn’t a build. It’s a dismount. Four beats, then the dance, then Dayton.
1. VERIFY
The stated goal was a directive for an authenticated crawl — a sigil that behaves like ! (fresh flight, cache-bust) but rides weblogin’s warmed persistent profile so the popup browser arrives logged in. Confirmed against this compile’s receipts, not memory:
- The processing log carries the smoking gun:
🔑 Engaging AUTHENTICATED LLM Optics (weblogin profile) for: https://app.botify.com/michaellevin-org/mikelev.in/. -
The lenses came back logged in. The SEO title is “Botify mikelev.in michaellevin-org,” not “Login.” The Semantic Outline shows the authenticated left-nav — analytics/overview, actionboard, activation/hub, studio, /o/assist. The Wire Truth shows real session traffic:/api/v1/authentication/profile,/saved_explorers, the activation graphql. An anonymous hit bounces to/signin; this one didn’t. - The source in Codebase proves the mechanism:
authenticated = path.startswith('?'),override_cache: path.startswith(('!', '?')),persistent: authenticated, plus the roster line and the Chapter VIII grammar comment.
Goal met, receipt-witnessed, this run.
2. BANK
The ?URL sigil graduates. Nothing owed — both grammar entries already landed: the Tool Roster line (?URL — like !URL, but on weblogin's persistent profile (authenticated crawl)) and the foo_files.py Chapter VIII comment. The pin, if you keep one, is one line: ?URL = authenticated fresh crawl on the warmed default profile; !/@/$/% unchanged.
One thing the alignment probes surfaced that’s worth banking as an earmark, because it’s a genuine namespace trap: the two profile_name hits in prompt_foo.py are disclosure/sanitization profiles (load_disclosure_profile), not browser profiles. Same word, different subsystem. ? works not because prompt_foo passes a scrape profile_name, but because it passes none — so scraper_tools defaults it to "default", which is exactly the directory weblogin warms. The alignment lives in a shared default, not an explicit hand-off. Write that down or a future reader will wire the wrong “profile” together.
3. DANGLING
Two seams, neither blocking:
- The lock trap (your question): the
weblogin.py“close before scraping” warning is sufficient for solo use. A preflightSingletonLock-exists check inscraper_tools.pywould only upgrade a cryptic Chrome failure into a clear one — nice-to-have, not load-bearing. - The one I’d actually chase next:
weblogin.pyanchors the profile toREPO_ROOT(absolute), butscraper_tools.pyreads a CWD-relativedata/uc_profiles/{profile_name}. They coincide only because thefoo/fu/ahcaliasescd ~/repos/pipulatefirst. That’s alignment-by-discipline, not by structure — and this whole system’s creed is structural absence beats exclusion policy. Anchoring the scraper toPIPULATE_ROOTtoo would make?CWD-independent, so a scrape from any directory can’t silently mint a fresh logged-out profile.
4. SEED
The ride is fully banked — publish it. If you want the CWD-hardening as the next ride (I’d pick it over the lock guard), seed the next compile with:
! grep -rn "uc_profiles" scripts/weblogin.py tools/scraper_tools.py
! grep -n "PIPULATE_ROOT\|REPO_ROOT" scripts/weblogin.py tools/scraper_tools.py
scripts/weblogin.py
tools/scraper_tools.py
The dance
🔑 ?URL FIRED 🔑
\o/ the popup came up logged in
| the lenses came back as YOU
/ \ the receipt says so, not the memory
~ one sigil, zero dead cars, ride dismounted ~
You built the part, used the part to make the part prove itself, and the proof is the artifact you’re reading. That’s the loop closing on itself — the double-helix you opened with. The doc strand and the code strand are the same bytes, so they can’t shear.
Now — the Dayton “success assured” moment
I think you mean Dayton, not Dalton (your own article slug says so — pipulate-dayton-moment): the Wright Brothers’ bicycle-shop wind tunnel, 1901.
Here’s why it’s the perfect frame. Going into 1901, the Wrights designed their gliders using the received aeronautical data of the day — Lilienthal’s lift coefficients and the old Smeaton coefficient for air pressure. Their 1901 glider underperformed so badly Wilbur reportedly told Orville they wouldn’t fly in their lifetimes. The problem wasn’t their engineering. The inherited data was wrong. They were building faithfully on top of a spec that had drifted from reality — a spec nobody had falsified because everybody trusted it.
So they did the anti-Crichton thing: instead of trusting the tables, they built an instrument to generate their own ground truth. A six-foot wind tunnel, a crude balance made from hacksaw blades and bicycle spokes, and they tested on the order of two hundred wing shapes — measuring, not assuming. Out came their own lift and drag tables, empirically verified, reproducible.
That’s the moment. Once they had measurements they trusted, everything downstream stopped being a gamble and became engineering. When they went back to Kitty Hawk in 1902 with a glider designed from their own numbers, it flew beautifully — and the confidence historians describe from that winter is exactly the phrase you reached for: success was assured. Kitty Hawk in December 1903 was almost anticlimactic. The hard part — the falsification — had already happened in a Dayton back room two years earlier.
That’s your whole thesis, and it’s why you get to say “we have all the parts here.” The inherited, drifting spec is the sibling .md file, the hallucinated capability list, the API docs that lie. The wind tunnel is this compile — the AST-derived roster that can only be right or loudly broken, the live ! receipts, the ? scrape that actually fired and returned the logged-in DOM instead of a login wall. You don’t hope ? inherits the session. The processing log and the Wire Truth measured that it did. Once the measurement is sound, the rest is just wing shapes.
The Wrights’ edge wasn’t the airfoil. It was refusing to fly on data they hadn’t falsified themselves. That’s the moment you’re standing in.
The Dayton Moment in AI Engineering
Next-actions
- PROBES — none new; the ride is banked. The two alignment greps above are the standing before/after pair if you take the CWD-hardening ride.
- NEXT CONTEXT — the SEED block above, only if chasing the CWD anchor. Otherwise clear
adhoc.txtback to the standard chop. - PATCHES — No repo patches required. Re-emitting
?would be a dead car. - PROMPT — caboose copy, for whichever way you go next:
**MikeLev.in**: ?URL is banked and published. Take the CWD-hardening ride: right now
weblogin.py anchors the persistent profile to REPO_ROOT while scraper_tools.py
reads a CWD-relative data/uc_profiles/ — they only align because the aliases
cd into the repo first. Make scraper_tools.py anchor to PIPULATE_ROOT/REPO_ROOT
the same way weblogin.py does, so a ? scrape from any directory hits the one
warmed profile instead of minting a fresh logged-out one. Structural over
disciplinary. Show me the cheapest probe that proves the two paths resolve to
one absolute location today, then the patch.
- EXTERNAL DELIVERABLES — none.
MikeLev.in: Okay, we’ll wrap this one here but I really have to get back to that path thing, but out of steam. Dalton moment achieved.
Book Analysis
Ai Editorial Take
What strikes me most is the ‘recursive evidence’ nature of this article. Because the article itself was produced using the tool it describes, it functions as a live demonstration of its own thesis. This ‘epistemic loop’ is rarely achieved in technical writing; it effectively collapses the distance between the subject (AI workflows) and the object (the article content).
🐦 X.com Promo Tweet
Most AI coding relies on vibes. I built a wind tunnel to falsify my own reality. Discover why the 'Dayton Moment'—verifying your own ground truth—is the only way to build durable, AI-native software. https://mikelev.in/futureproof/wright-brothers-principle-ai-truth/ #AI #SoftwareEngineering #NixOS
Title Brainstorm
- Title Option: The Wright Brothers Principle: Engineering Truthful AI Workflows
- Filename:
wright-brothers-principle-ai-truth - Rationale: Frames the article’s core thesis using a compelling historical metaphor that resonates with engineers.
- Filename:
- Title Option: Closing the Loop: Falsifiable AI Systems
- Filename:
closing-the-loop-falsifiable-ai - Rationale: Focuses on the article’s methodological shift toward verifiable system design.
- Filename:
- Title Option: Beyond Vibe-Coding: The Instrument-Driven Development Path
- Filename:
beyond-vibe-coding-instrument-driven - Rationale: Addresses the common pain point of unreliable AI assistance with a concrete, actionable alternative.
- Filename:
Content Potential And Polish
- Core Strengths:
- Strong use of the Wright Brothers metaphor as a framework for engineering truth.
- Clear demonstration of bridging documentation-code drift through AST-based signals.
- High degree of technical legibility due to the inclusion of live grep receipts.
- Suggestions For Polish:
- Expand slightly on the ‘CWD-hardening’ transition to provide more closure for the reader.
- Consider consolidating the implementation ‘patches’ section into a concise appendix-style block to maintain narrative flow.
Next Step Prompts
- Detail the CWD-independence patch for scraper_tools.py to move from discipline-based path alignment to structural path alignment.
- Design an automated ‘integrity dashboard’ that visualizes the current drift (if any) between the doc-string AST and the runtime function signature.