The Command Line Is Becoming the Context Line: Unix Verbs, ARexx Ports, and Local AI Workflows
Setting the Stage: Context for the Curious Book Reader
TL;DR: Good morning. In this piece, we examine why the most durable surface for steering modern language models is not a proprietary web interface or a slash-command dropdown, but an append-only text file assembled with short Unix commands. By combining immutable Nix environments, captured network logs, and native terminal tab-completion, we replace speculative agent loops with a quiet, deterministic, local-first context pipeline. It is unglamorous work, but it functions reliably.
Technical Journal Entry Begins
MikeLev.in: Alright, there are times when an article I write meaning to use on the public site just runs too long, gets too bogged down, has too many PII violations that need scrubbing and the like, and I just decide it needs to be tossed in the Grimoire so it doesn’t get lost in the 1-file-4life journal and that’s what I just did. But I want that story to be projected into the public side, so I can just ask for it to be so. And I can do that from multiple models using this strategy:
PARALLEL FAN-OUT (the "map" — genuinely automatic)
════════════════════════════════════════════════
┌──► [Gemini] ──► answer ──┐ several
Prompt ─┼──► [ChatGPT] ──► answer ──┼──► different
└──► [Claude] ──► answer ──┘ answers
│
▼
SERIAL PIPE (the "reduce" — manual, accumulating)
════════════════════════════════════════════════
[independent blind responses] ──► [human feedback] ──► [next] ──► …
history grows, context accumulates, human directs
Don’t mention any Clients or their Products or anything that I would need to
scrub. But do write the article that you think belongs here. It’s no longer
going to be Chapter 2 of the book. It’s just part of the final tooling
adjustments so that a Chapter 2 about short choppy Unix commands that with
command-line tab-completion, which by the way I just tested on xc where it’s
going to be really useful that I never had before. The idea is that the
slash-convection to pull up different skills per the README for Agents
conventions of late have mainstreamed in all the Chat UIs that support skills. I
think it may have been one of those things that first appeared in Cursor IDE, or
maybe first got popularized in the AI-space by Cursor (I’m sure it was
elsewhere first / was it?) and then everyone jumped on that bandwagon. And it’s
a good convection. But there is tab-completion in standard bash shells and
that’s nice too. It’s not the same but if you want to rapidly set a context,
we’re working toward something like this:
echo 'Intro' >> con.txt
echo email <thread_id> >> con.txt
echo jira <ticket_id> >> con.txt
echo botify <BQL Query> > con.txt
echo 'Actual prompt` >> con.txt
More or less. Implementation may vary and we’re setting up for a FastHTML app that will dynamically add steps until you click a “Copy Context” or something that puts either the full text or a link to the zip in your operating system copy-paste buffer to go over to a Web ChatBot like you, see? You don’t have to do any of that implementation planning. That’s just to show you where we’re going with this.
First, a general Unix way chop chop system described above.
Second, sniffing CDP on the so-called wire, but really cached by that time so
you can dig out endpoints and reconstruct any (mostly MCP) tool-call occurring
in the background. If there’s a connector for it in Claude desktop and an API
being called in the background, there’s no way you can’t get the endpoint / form
data from it. And in combination with cli.py (using its JSON argument feature
at very least) almost anything curl-like or Insomnia-like can be done here. It
could even be using curl in this approach.
And in that spirit, I need that last article rewritten bellow. You can use your own highest gravity native persona, probably as you the Model yourself. And just be generally empathetic to a user who needs to know what we just did in terms of the continuity of the book-ore but without bogging them down in the micro-details we dealt with. You don’t have to be brief. You can let it go on for as long as you think is most useful to detail hungry users while still communicating well.
And then wrap it up with a 30-and-3 creative forcing function of your choice — whatever you think is most useful to the audience in this context.
Please and thank you!
(nix) pipulate $ prompt
(nix) pipulate $ ahc
╭─────────────────────────────────────────────────────────────── 🐰 ASCII Art Wax Seal (your vibe-coding safety-net) ───────────────────────────────────────────────────────────────╮
│ │
│ ( Like a canary you say? ) │
│ O /) ____ The "No Problem" Framework │
│ > I HEREBY WILL NOT RE-GENERATE o /)\__// / \ Pipulate - Protecting Your Code │
│ > Once upon machines be smarten ___(/_ 0 0 | | just by being honest about text. │
│ > ASCII sealing immutata art in *( ==(_T_)== NPvg | (If mangled, then AI drifted.) │
│ > This here cony if it's broken \ ) ""\ | | https://pipulate.com │
│ > Smokin gun drift now in token |__>-\_>_> \____/ 🥕🥕🥕 │
│ │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
🗺️ Codex Mapping Coverage: 73.7% (174/236 tracked files).
📦 Appending 62 uncategorized files to the Paintbox ledger for future documentation...
✅ Topological Integrity Verified: All references exist.
🩹 Adhoc overlay spliced from gitignored adhoc.txt
--- Processing Files ---
-> Executing: python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs ... [0.3639s]
Skipping codebase tree (--no-tree flag detected).
🔍 Running Static Analysis Telemetry...
-> Checking for errors and dead code (Ruff)...
All checks passed!
✅ Static Analysis Complete.
📦 Payload Ledger (biggest first)
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┓
┃ File / Source ┃ Tokens ┃ Bytes ┃ % Bytes ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━┩
│ ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs │ 57,803 │ 149,665 │ 18.3% │
│ prompt_foo.py │ 32,275 │ 144,958 │ 17.8% │
│ foo_files.py │ 33,561 │ 135,362 │ 16.6% │
│ flake.nix │ 21,952 │ 90,950 │ 11.2% │
│ scripts/connectors/wallet.py │ 11,379 │ 45,533 │ 5.6% │
│ /home/mike/repos/nixos/autognome.py │ 8,206 │ 37,921 │ 4.6% │
│ init.lua │ 7,725 │ 28,916 │ 3.5% │
│ cli.py │ 5,097 │ 22,634 │ 2.8% │
│ scripts/connectors/jira.py │ 5,083 │ 20,850 │ 2.6% │
│ scripts/ai.py │ 3,432 │ 15,661 │ 1.9% │
│ scripts/connectors/slack.py │ 3,622 │ 15,054 │ 1.8% │
│ scripts/foo_replay.py │ 3,411 │ 14,252 │ 1.7% │
│ scripts/connectors/gmail.py │ 3,172 │ 13,530 │ 1.7% │
│ apply.py │ 2,512 │ 11,038 │ 1.4% │
│ /home/mike/repos/grimoire/_posts/2026-07-25-npvg-stick-bug-amiga-arexx-nixos.md │ 2,426 │ 11,003 │ 1.3% │
│ scripts/connectors/confluence.py │ 2,625 │ 10,825 │ 1.3% │
│ scripts/foo_cartridge.py │ 2,394 │ 10,761 │ 1.3% │
│ scripts/xp.py │ 2,097 │ 8,828 │ 1.1% │
│ AUTO: Recent Git Diff Telemetry │ 2,312 │ 8,373 │ 1.0% │
│ scripts/weblogin.py │ 1,276 │ 5,805 │ 0.7% │
│ pyproject.toml │ 1,108 │ 4,034 │ 0.5% │
│ scripts/crawl.py │ 720 │ 2,949 │ 0.4% │
│ .gitignore │ 653 │ 2,402 │ 0.3% │
│ requirements.in │ 683 │ 2,357 │ 0.3% │
│ __init__.py │ 431 │ 1,872 │ 0.2% │
│ .gitattributes │ 33 │ 76 │ 0.0% │
│ AUTO: Static Analysis Diagnostics │ 11 │ 39 │ 0.0% │
├─────────────────────────────────────────────────────────────────────────────────┼─────────┼─────────┼─────────┤
│ TOTAL │ 215,999 │ 815,648 │ 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 (2,312 tokens | 8,373 bytes)
--- Prompt Summary ---
Summed Tokens: 219,013 (from section parts)
Verified Tokens: 221,720 (from final output)
(Difference: +2,707)
Total Words: 85,242 (content only)
Total Chars: 833,148
Total Bytes: 836,841 (UTF-8)
--- Size Perspective ---
📚 Equivalent in length to a **Long Novel** (Note: With a token/word ratio of 2.60, this content is far denser and more complex than typical prose of this length).
🪄 Compile-lane scrub: 7 PII substitution(s) applied to payload.
📦 Canonical context cartridge written to /home/mike/repos/pipulate/foo.zip (sha256=5a7c9cf6cdac…, members=3)
🗂️ Rotated cartridge snapshot: foo-5a7c9cf6-173.zip (keeping newest 20 of 20)
Markdown output copied to clipboard
(nix) pipulate $
Note: We start with Gemini, the last I set to start in the race and (typically) the first to finish. The various models of Gemini is just objectively faster than the other engines, with an 80/20-rule always “good enough” and certainly most aligned to the Operation Stick Bug voice — the most flat, matter-of-fact and fair-handed.
Gemini 3.6 Thinking: Context verified.
Here is the public-facing, distilled article capturing the technical arc, philosophy, and workflow evolution from the recent journal exploration, followed by the 30-and-3 creative forcing function and the actionable turn shape.
Reclaiming the Amiga Spirit: CLI Tab-Completion, CDP Wire Truth, and the Unix Way of AI Context
TL;DR: While the modern AI landscape has popularized proprietary UI shortcuts like slash-commands and black-box agent loops, the most durable, reproducible workflows remain rooted in classic Unix primitives. By combining NixOS dependency pinning, X11 automation, CDP (Chrome DevTools Protocol) wire sniffing, and native
bashtab-completion, we can build a deterministic, local-first context pipeline that treats every API call as readable, auditable text.
1. The Slash-Command Illusion vs. Native Unix Ergonomics
In recent years, the developer ecosystem witnessed a surge in AI-native interfaces. Tools popularized slash-commands (/skill, /search, /edit) to trigger specialized workflows within chat windows. While effective at guiding user intent, slash-commands often mask the underlying mechanics inside proprietary application shells.
Unix has possessed this exact paradigm for over four decades: shell tab-completion and append-only stream composition.
Instead of relying on a closed UI to orchestrate tools, we can construct context directly on the command line using bare, composable scripts. Consider how straightforward context assembly becomes when driven by simple shell commands and native autocomplete:
echo "# CONTEXT ASSEMBLY" > adhoc.txt
email 18f4ad923b1c83e2 >> adhoc.txt
jira ENG-123 >> adhoc.txt
sniff example.com >> adhoc.txt
echo "Please synthesize the ticket requirements against the email discussion." >> adhoc.txt
With bash completion wired to local caches (such as completing domain names for sniff directly from browser_cache/), setting up a deep multi-source prompt requires zero mouse clicks and zero proprietary UI wrappers. It is lightweight, transparent, and entirely scriptable.
2. The Stick Bug Sub-Platform: Amiga ARexx on Immutable Linux
To understand why this approach is so resilient, we look back to the Amiga operating system of the late 1980s. The Amiga featured ARexx—an inter-process communication protocol that allowed independent applications to send commands, pass data, and automate one another’s interfaces seamlessly.
Modern desktop environments often isolate applications behind security boundaries (such as Wayland’s strict window isolation), making cross-application GUI automation difficult. By pairing NixOS (for immutable, byte-for-byte system reproducibility), X11 (for desktop automation and synthetic inputs), and Python, we resurrect the ARexx philosophy inside a modern software workshop:
- NixOS (The Immutable Bedrock): Software dependencies, system libraries, and runtime packages are declared in code. Updating your host machine cannot break your daily tools because the development shell is frozen and isolated.
- X11 & xdotool (The Inter-Process Strings): Allows scriptable keyboard and window manipulation across applications, bypassing manual setup routines.
- SystemD (The Orchestrator): Automatically boots background daemons, servers, and telemetry watches on system startup.
This produces a “Stick Bug” workspace: a platform within a platform that fades into the background, operating quietly until called upon, completely impervious to machine drift or OS updates.
3. Wire Truth: CDP Flight Recorders over Spec Guesswork
When building tools or integrating with third-party web platforms, developers frequently struggle with incomplete API documentation or shifting web interfaces. AI agents often waste tokens guessing parameters or inventing non-existent endpoints.
The local-first solution is Wire Truth.
Every time a browser automation run executes via headless or visible Chrome, we drain the browser’s Chrome DevTools Protocol (CDP) performance log to an append-only JSONL flight recorder (network_log.jsonl). Rather than guessing how an app communicates with its backend, we inspect the exact HTTP traffic recorded during the session:
- View Source (Panel 1): What the server initially delivered.
- Hydrated DOM (Panel 2): What JavaScript constructed in the browser.
- Wire Truth (Panel 3): The exact HTTP requests, response headers, status codes, and payloads transmitted over the network.
By distilling this network log into a clean Markdown distillate, we can reverse-engineer any web interface or tool invocation into a single-file Python connector or a bare curl command. If a desktop app or web service can perform an action, the wire record captures the exact payload, allowing cli.py or local tools to reproduce the call deterministically.
4. The Horizon: FastHTML Context Assembly Line
The terminal pipeline (adhoc.txt + prompt_foo.py -> foo.zip) provides a rock-solid foundation for power users. The next natural step is raising the UI ceiling without sacrificing local-first principles.
By layering a lightweight FastHTML web interface over these same Unix primitives, context creation becomes visual:
- Step-by-step UI widgets let you attach log streams, connector queries, and git diffs dynamically.
- Clicking “Copy Context Cartridge” bundles the scrubbed Markdown payload, prompt, and manifest into a single, self-verifying
foo.zippackage ready for any AI web interface or local model.
Whether assembled via bash one-liners or a FastHTML card stack, the core invariant remains unchanged: Text won, plain text travels everywhere, and the human stays in control of the actuation boundary.
5. The 30-and-3 Ideation Kata: The Future of Local Context & Actuation
To map out the immediate horizon for local context tooling and CLI automation, here are 30 brief architectural vignettes, followed by 3 selected priorities.
The 30 Vignettes
- CDP-to-Connector Auto-Generator: A script parses
network_log.jsonlfrom a browser session and automatically drafts a single-file Python connector matchingscripts/connectors/. - Tab-Completed Connector Registry: A custom
bashcompletion script inspectsconnectors.jsonto complete service names and target resources directly on the terminal prompt. - Clipboard Bridge Sentinel: A background daemon watches
/tmp/clipboard_bridge.txtacross SSH sessions and auto-formats raw web pastes into valid markdown blocks. - FastHTML Context Builder: A FastHTML app that visually stacks file paths, SQL queries, and connector outputs before generating a
foo.zipcartridge download. - Interactive Replay Harness: A clean-room CLI tool that takes any
foo.zipcontext cartridge, extractspayload.md, and runs a local benchmark evaluation using Ollama. - Git-Hook PII Filter: A pre-commit filter that automatically scans staged context templates for unredacted API tokens, credentials, or domain names.
- Single-File Connector Schema: Standardizing all scripts in
scripts/connectors/to expose a--checkflag returning exit code 0 for live, 1 for dead, and 2 for unchecked. - Automated Token Budget Gauge: A CLI wrapper that prints a live ASCII progress bar showing remaining context window space based on the active model’s context limit.
- X11 Workspace Snapshotter: A script that captures window geometries across GNOME virtual desktops and saves them to a Nix-declarative layout file.
- JSONL Flight Recorders for CLI Tools: Wrapping
cli.pyexecution so every tool call appends structured JSON logs to a local SQLite telemetry table. - Browser Login Warmer GUI: A FastHTML dashboard displaying live status indicator dots (green/red) for all persistent Chrome profile sessions (
data/uc_profiles/). - Markdown-First API Mappings: Converting OpenAPI/Swagger JSON files into token-optimized Markdown tables for insertion into prompt context.
- Local Vector Search for Shards: A lightweight, dependency-free Python script using TF-IDF or simple embeddings to surface relevant article shards by keyword proximity.
- Self-Healing Patch Airlock: Updating
apply.pyto handle minor whitespace or indentation shifts in SEARCH blocks gracefully while maintaining strict AST verification for Python code. - Automated Dismount Checklist: A Neovim macro that automatically extracts resolved TODO items from an active draft and appends them to
foo_files.pypinboard comments. - Offline Wallet Scoreboard TUI: A Textual terminal UI displaying real-time credential freshness across all five wallet auth kinds without hitting network endpoints.
- Dynamic
adhoc.txtPresets: Named CHOP templates infoo_files.pythat can be swapped instantly using simple shell aliases (ahc-debug,ahc-publish,ahc-review). - Weblogin Cookie Expiry Monitor: A script reading Chrome’s SQLite cookie database to report exact expiration days remaining on persistent session cookies.
- Dual-Tab Browser Optics: A browser automation mode that captures both an unauthenticated public view and an authenticated user session view to generate instantaneous DOM diffs.
- Self-Contained Seed Cartridges: Generating a single
seed.zipthat contains installer scripts, system instructions, and onboarding guides for new machines. - Terminal Audio Status Notifications: Triggering brief, low-latency Piper TTS voice alerts when a long-running scrape or context compile completes.
- Automated Git Stash Airlock: Ensuring local
nix developsession entries automatically isolate dirty working trees before pulling upstream flake updates. - Headless Chrome Tunneling: Routing selenium automation through local SSH tunnels to inspect internal staging servers behind firewalls.
- Multi-Model Parallel Fan-Out Harness: A script that sends the same compiled
prompt.mdto multiple local/remote LLM APIs simultaneously and saves their responses side-by-side for comparison. - Interactive Patch Inspector: A terminal diff viewer that previews
apply.pymutations in color before modifying files on disk. - Automated Hub Page Generator: Using article tag clusters to regenerate Jekyll hub pages and site navigation graphs in a single command.
- Token-Dense Code Summarizer: A Python AST parser that extracts class definitions, method signatures, and docstrings while stripping function bodies to reduce token footprint.
- Deterministic File Tree Annotator: An
ezawrapper that appends exact byte and token counts next to every file path in tree diagrams. - Zero-Dependency Cartridge Verifier: A single-file script in
scripts/foo_cartridge.pyusing only the Python standard library to verifyfoo.zipchecksums. - Universal Output Synthesizer: A CLI post-processor that parses LLM responses, applies patch blocks automatically, and copies any remaining prose to the OS clipboard.
The 3 Selected Priorities
1. CDP-to-Connector Auto-Generator (Vignette 1)
- Justification: Manually inspecting network traffic to write custom API scripts is effective but repetitive. Automating the extraction of endpoint URLs, headers, and payload structures from
network_log.jsonlinto a clean Python connector template reduces the friction of adding new web services to the wallet to zero.
2. FastHTML Context Assembly Line (Vignette 4)
- Justification: While terminal commands excel at speed, visual context assembly provides clarity when orchestrating complex prompts involving multiple tickets, emails, and code files. A FastHTML UI provides a clean bridge between terminal execution and browser-based chat UIs.
3. Tab-Completed Connector Registry (Vignette 2)
- Justification: Command-line completion turns documentation into muscle memory. Enabling
bashautocomplete for connector names, channel IDs, and domain caches gives the terminal the exact ergonomic feel of modern slash-commands without the bloat of proprietary frameworks.
Actionable Response Contract
(1) PROBES
python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs | head -n 5
Proves: Verifies that the article corpus index is accessible and returning the 5 most recent published entries cleanly from target 1.
(2) NEXT CONTEXT
! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs | head -n 5
foo_files.py
prompt_foo.py
scripts/xp.py
(3) PATCHES
No repo patches required.
(Ignition: no ignition required.)
(4) PROMPT
Context verified. The public article distillation and 30-and-3 kata are logged. Please review the current state of foo_files.py and recommend any pinboard graduations or next tool refinements.
(5) EXTERNAL DELIVERABLES
None required for this turn.
Note: Honestly, Grok may be as fast as Gemini. And likewise as Gemini any coding it does has to be double-checked by Claude or ChatGPT. Correlation?
Grok 4.5 Expert: Context verified.
The provided cartridge is complete for this request: the Stick Bug article is present in full, the surrounding tooling (wallet, connectors, prompt_foo, apply.py, cli.py, etc.) supplies the mechanical vocabulary, and no critical local files are missing for a public rewrite. No import gaps or absent modules affect the narrative task.
Here is the public-facing article, written in my own voice. It keeps the Stick Bug rabbit-hole spirit but strips every client, product, or scrub-needing detail. It situates the work as the final tooling adjustment that makes short, tab-completable Unix chops the everyday surface for building AI context—exactly the bridge you described between the private Grimoire entry and the public site.
The Stick-Bug Sub-Platform and the Unix Chop: Deterministic Context Surfaces for AI Collaboration
There are days when a single loose screw turns into a three-day descent. You open the garage to tighten one thing and emerge having built a portable hovercraft out of spare parts, nostalgia, and an immutable package manager. That is precisely what happened with the NPvg Stick Bug sub-platform.
I set out to make a few automation scripts more reliable. I came back with a glass-bubble workspace that pins every dependency, talks to other programs the way classic Amiga ARexx once did, and boots itself through the system’s own service manager. The result is a tiny, reproducible operating system living inside the larger one—Write Once, Run Anywhere made literal.
That rabbit hole is not the end of the story. It is the last major tooling adjustment that lets the rest of the Forever Machine speak in short, choppy Unix commands. Those commands are the real public deliverable.
The Glass Bubble, Revisited
Nix is the glass. You do not install software onto the host; you declare an environment that is frozen in time. Every Python package, every binary, every library version is locked by a flake. The same nix develop command produces the identical shell on any machine that can run Nix. Ten years from now the scripts still run. That is the mechanical definition of a sub-platform.
Inside the bubble we kept X11 deliberately. Modern display servers isolate programs from one another for security. X11 still lets one process reach into another—click a button, type text, read a window. That is the spirit of ARexx: inter-process control without ceremony. SystemD supplies the ignition key; the bubble starts itself at boot and the automation is simply there.
None of this is romantic. It is the cheapest way to make a workspace that does not rot when the host updates. The Stick Bug is the proof that the same pattern scales from a single Python script to an entire automation surface.
From Sub-Platform to Context Surface
Once the environment is deterministic, the next question is how a human (or an AI) talks to it. The answer that finally clicked is the oldest Unix pattern of all: short, composable commands that write text into a file.
echo 'Intro' >> con.txt
echo email 1892a3f >> con.txt
echo jira PROJ-447 >> con.txt
echo botify 'SELECT …' >> con.txt
echo 'Actual prompt' >> con.txt
Each line is a complete, tab-completable thought. Bash already knows how to complete the first word; the rest is just data. The resulting con.txt is a self-describing context cartridge. You can hand it to any model, any chat surface, any local agent. No proprietary skill format required. No slash-command registry that only one vendor understands.
This is the same convection that mainstreamed slash-skills in the big chat UIs. Cursor made the pattern popular; every other interface followed. But the underlying idea is older than any of them: a command that sets context is more reliable than a conversation that tries to remember it.
The Stick Bug environment makes those commands safe. Because every dependency is pinned, the email, jira, or botify helpers always behave the same way. Because the bubble is isolated, a misbehaving probe cannot poison the host. Because SystemD owns the lifecycle, the helpers are already warm when you need them.
Wire Truth as the Second Lens
Short commands are only half the surface. The other half is the ability to discover what a black-box tool is actually doing.
Modern agent runtimes speak MCP or proprietary tool-call protocols. Those calls travel over the wire (or, more often, over a local socket that can be cached). Once the traffic is on disk you can read the endpoints, the form data, the authentication headers. From there the reconstruction is mechanical:
- a one-line
curlorhttpxcall, - or a thin wrapper registered with
cli.pythat accepts JSON arguments, - or a short Python script that lives inside the same Nix bubble.
You no longer need the original desktop application. You only need the receipt it left behind. That is the second Stick-Bug insight applied to the network layer: treat the observed call as ground truth and rebuild the actuator yourself. The resulting tool is portable, auditable, and free of the original UI’s session state.
Together the two lenses—choppy Unix commands and reconstructed wire endpoints—form a complete context surface. You can assemble a prompt from local connectors in seconds, then reach any remote capability whose traffic you have already seen.
Why the Vocabulary Matters
Before the Stick Bug work, the daily vocabulary was a mixture of chat history, ad-hoc scripts, and hope that the environment had not drifted. After it, the vocabulary is smaller and sharper:
nix develop— enter the glass bubble.- a one-word connector (
email,jira,slack, \ldots) — pull live context. echo … >> con.txt— accumulate a cartridge.- a single
cli.py callor reconstructedcurl— actuate what was observed on the wire.
Each of those verbs is tab-completable, scriptable, and deterministic. They compose the way Unix always intended. The AI no longer has to guess the shape of the world; the human (or the previous AI instance) has already written the shape into a text file that can be replayed.
That is the practical payoff of the three-day rabbit hole. The Amiga nostalgia was the bait. The durable surface for AI collaboration is the catch.
30-and-3
Thirty words:
A pinned Nix bubble plus short, tab-completable Unix chops turns every connector and every observed API call into a reproducible context cartridge any model can read.
Three forcing functions:
- Write the next context cartridge with nothing but
echolines and existing one-word connectors. If you reach for a long chat prompt first, stop and rewrite it as chops. - The next time a desktop tool makes a network call you care about, capture the traffic, reconstruct the endpoint, and register it under
cli.py. Delete the original UI from the critical path. - Treat every new automation script as a candidate for the Stick Bug pattern: declare its environment in a flake, give it a one-word entry point, and let SystemD own its lifecycle. If it cannot boot itself, it is not finished.
The garage is closed. The hovercraft works. The only remaining work is to keep feeding it short, honest commands.
(1) PROBES
# no live probes required — article is pure narrative rewrite
(2) NEXT CONTEXT
# adhoc.txt for next compile (copy-paste ready)
! true # placeholder; article already delivered in this turn
/home/mike/repos/grimoire/_posts/2026-07-25-npvg-stick-bug-amiga-arexx-nixos.md
(3) PATCHES
No repo patches required.
(4) PROMPT
# next prompt.md caboose (ready for the following turn)
Continue from the public Stick-Bug rewrite. Decide whether the article should live as a new futureproof post or remain Grimoire-only, then produce the corresponding front-matter + body if a public post is chosen. Keep the same 30-and-3 close.
(5) EXTERNAL DELIVERABLES
The complete public article is the body above. Copy it into whatever publishing surface you prefer (Grimoire, futureproof, or both). No further local files need to be touched for this turn.
Note: The Great Explainer persona ChatGPT comes next only because it finished next in the race. I tried to start them all at the same time.
ChatGPT 5.6 Sol High: Context verified. The supplied Grimoire entry contains the necessary conceptual spine: a reproducible Nix-defined workspace, Python and Git as connective tissue, X11 as a deliberate desktop-actuation seam, systemd as ignition, and ARexx as the historical model. The final prompt expands that story into Unix-sized context commands, tab completion, observable connector traffic, browser-to-CLI translation, parallel model fan-out, and human-directed serial reduction.
One historical adjustment: Cursor did not originate slash commands. It participates in a much older command-interface convention; what Cursor and its contemporaries helped popularize was that convention’s use inside AI coding conversations. Cursor’s current CLI documents slash commands, while chat platforms such as Discord independently expose the same interaction grammar. ([Cursor Documentation][1])
Here is the public-facing projection.
The Command Line Is Becoming the Context Line
Unix-Sized Verbs, ARexx-Style Coordination, and the Local Workshop Around Cloud AI
Some articles are born ready for publication.
Others are mined.
They begin as long technical journals, transcripts, debugging sessions, accidental philosophy seminars, and three-day rabbit holes entered in pursuit of what should have been a ten-minute improvement. The raw material matters, but it is not yet an article. It contains private details, false starts, abandoned theories, temporary names, and enough procedural sediment to bury the useful idea.
That does not make the material disposable.
It makes it ore.
The purpose of a private Grimoire is to preserve that ore without pretending every shovel-load belongs in the public book. The public work comes later, when the architectural idea can be separated from the circumstances that produced it.
This is one of those projections.
The rabbit hole began with an apparently modest desire: make a few local commands easier to invoke, easier to complete with the Tab key, and easier to combine into a repeatable workflow.
It ended with the outline of a new kind of personal computing environment.
Not a new operating system.
Not another giant AI framework.
Not an autonomous agent pretending to be an employee.
A thin, reproducible coordination layer that sits between a human, a local machine, existing applications, browser sessions, APIs, files, and whichever language model happens to be useful today.
It is a platform within a platform.
A stick bug perched on the branch of the host operating system: light enough not to replace the tree, structured enough to become its own dependable environment.
The Missing Layer Around the Model
And the surprising part is that very little about the underlying idea is new.
Its two strongest ancestors are Unix and the Amiga.
The Missing Layer Around the Model
The current AI industry spends enormous energy discussing model intelligence.
Which model reasons best?
Which one has the largest context window?
Which one can operate a browser?
Which one can write a complete application from a sentence?
Those questions matter, but they distract from a more ordinary problem encountered every day:
How does the right evidence reach the model in the first place?
A model may need:
- a paragraph of human intent,
- part of an email conversation,
- a ticket or issue,
- the result of an API query,
- a source file,
- a log excerpt,
- a network request,
- the state of a local workflow,
- and the actual question the human wants answered.
Today, people usually assemble this context manually.
They change windows.
They search.
They copy.
They paste.
They remove irrelevant material.
They accidentally omit the one detail that mattered.
Then they repeat most of the process when trying another model.
This is not an intelligence problem. It is an input-routing problem.
We have astonishing reasoning engines surrounded by weak plumbing.
A Prompt Should Be Compiled, Not Improvised
The obvious temptation is to build one enormous application that connects to everything. That application acquires buttons, authentication systems, databases, background workers, plug-in registries, agent loops, proprietary state, and eventually a personality disorder.
The Unix answer is smaller:
Make context assembly out of commands.
Let each command do one thing.
Let the commands emit text or durable artifacts.
Let the output of one operation become the input of another.
Let the human decide what gets combined.
The command line does not need to become a chatbot.
It needs to become a context line.
A Prompt Should Be Compiled, Not Improvised
Imagine a local file called context.txt.
The exact syntax is not important yet. The shape is:
ctx add-note "Explain the architectural decision"
ctx add-mail THREAD_REFERENCE
ctx add-ticket ITEM_REFERENCE
ctx add-query saved-query.json
ctx add-file path/to/relevant_source.py
ctx add-prompt "What is the smallest safe next step?"
ctx copy
Each command adds one bounded piece of evidence.
The final command places either the assembled text or a reference to a packaged artifact onto the clipboard.
That clipboard payload can go to a browser-based model, a desktop model, a terminal model, or several models in parallel.
There is no requirement that one vendor own the entire chain.
There is no requirement that the model live inside the local application.
There is no requirement that every source system be redesigned around AI.
The context is compiled locally from explicit ingredients.
That word—compiled—matters.
A compiler does not vaguely remember what source code probably meant. It accepts inputs, applies rules, and produces an artifact. A context compiler should behave the same way.
It should make visible:
- what was included,
- where it came from,
- when it was acquired,
- how large it is,
- which operation added it,
- and what the final user request actually is.
The model can still be probabilistic.
The funnel feeding the model does not have to be.
Why Tiny Commands Beat a Giant Prompt Box
The shortest command is not automatically the best command. But short, composable commands have several advantages over a single interface containing every possible operation.
They become muscle memory
A command used every day eventually stops feeling like software. It becomes a verb.
You do not think deeply about opening a file, changing directories, searching text, or checking repository status. The action has been compressed into your hands.
Context operations can acquire the same quality:
- add this thread,
- attach this file,
- run this query,
- inspect this page,
- include this log,
- package the result,
- copy the context.
The command becomes a small extension of intent.
Tab completion turns memory into recognition
Human recall is expensive.
Recognition is cheaper.
A person may not remember the complete identifier for a thread, project, query, or connector. Shell completion can expose the available vocabulary while the user types.
That is more than a convenience.
It changes the cognitive shape of the system.
Without completion, the user must memorize the machine’s language. With completion, the machine helps reveal its language at the moment it is needed.
The interface becomes discoverable without becoming graphical.
Commands compose
A graphical interface usually embodies one anticipated workflow.
Commands can be rearranged.
Today’s context may need one file and one note. Tomorrow’s may require a browser capture, three messages, a query result, and a repository diff.
The pieces remain the same. Only the composition changes.
Commands leave receipts
A sequence of commands can be saved, inspected, repeated, compared, committed, and discussed.
The Return of the ARexx Idea
A click sequence tends to evaporate.
When something important depends on the context supplied to a model, “I clicked around until it looked right” is not a satisfactory provenance record.
The Return of the ARexx Idea
Unix supplies one half of this design.
The Amiga supplies the other.
Unix is famous for programs that exchange streams of text. Each tool can remain small because composition happens through a common medium.
The Amiga’s ARexx environment offered a related but distinct power. Applications could expose command surfaces that allowed users to coordinate them. A graphics program, text editor, database, or communications tool did not have to anticipate every cross-application workflow. A user could write the connective tissue.
The deeper lesson was not the syntax of ARexx.
It was that the owner of the computer should be allowed to orchestrate the owner’s applications.
That capability has gradually weakened on modern desktops.
Applications became isolated.
Interfaces became less scriptable.
Cloud services replaced local processes.
The Stick Bug Sub-Platform
Security boundaries became stronger, often for good reasons, but the user’s ability to coordinate the machine also diminished.
The AI era makes this loss painfully visible.
We now have models capable of describing an elaborate workflow, yet the local environment often lacks a simple, inspectable way to carry it out.
The project described here is an attempt to recover the ARexx spirit without pretending the 1980s can simply be restored.
The modern equivalent is not one scripting language controlling every application through a standard port.
It is a layered collection of seams:
- command-line programs,
- files,
- APIs,
- browser network observations,
- desktop automation,
- local services,
- clipboard transport,
- and model-independent context packages.
ARexx becomes an architectural attitude:
Applications are instruments. The user is the conductor.
The Stick Bug Sub-Platform
The resulting environment is intentionally narrow.
It is not trying to replace the host operating system. It attaches to it.
Its basic ingredients are unglamorous:
Nix defines the room
The environment’s dependencies are declared rather than accumulated through years of manual installation.
Python versions, libraries, command-line tools, and supporting binaries can be pinned together.
This does not create metaphysical immortality. Hardware changes. Services disappear. Operating systems evolve.
It does create something more practical: a rebuildable explanation of the environment.
Instead of saying, “This works on my machine, though I no longer remember why,” the repository says, “These are the pieces from which the room is made.”
Python provides connective tissue
Python is not being used to hide the operating system behind a fictional universal abstraction.
It is used as glue.
It can:
- parse output,
- call APIs,
- write files,
- normalize records,
- invoke local programs,
- package context,
- and present small command surfaces.
The operating system remains visible. Python simply makes its parts easier to coordinate.
Git remembers the design
The environment is not merely installed. It is described in a repository.
Git provides a time axis.
It shows what changed, when it changed, and what can be restored. It allows the workshop to move between machines without relying on one machine’s undocumented history.
systemd provides ignition
Some capabilities should appear automatically when the machine starts.
A local helper, watcher, service, or coordination process should not require a ceremonial sequence of terminal commands after every reboot.
The service manager becomes the ignition system for the user’s workshop.
This is orchestration at the scale of one owner-operated machine, not a miniature imitation of a hyperscale data center.
X11 remains an intentional actuator
Modern display systems restrict one application’s ability to observe or control another. That is a meaningful security improvement.
It also conflicts with workflows in which the owner deliberately wants programs to type, click, focus windows, or coordinate graphical applications.
From Observed Request to Local Verb
Retaining an X11 session for selected automation is therefore not a claim that older technology is universally superior. It is a trade.
Wayland offers stronger isolation.
X11 offers broader owner-directed actuation.
The important point is to make that choice consciously and contain the risk appropriately. A dedicated automation environment is different from casually granting every downloaded program control over the desktop.
Legacy is not automatically virtue.
Modernity is not automatically agency.
Engineering begins where slogans end.
The Browser Is Both Interface and Evidence
Many valuable capabilities now live behind web interfaces.
A browser action may look like magic:
- click a button,
- choose an object,
- fill out a form,
- receive a result.
But the browser must translate that interaction into something concrete.
There will usually be a request, a payload, a response, a sequence of headers, or a stream of events.
The browser’s developer instrumentation can observe that exchange.
This creates a powerful learning loop:
- Perform a legitimate action in a session you control.
- Capture the corresponding network activity.
- Identify the request that represents the action.
- Examine its endpoint, method, arguments, and response shape.
- Reproduce the operation through a small local command where appropriate.
- Save the result as evidence or context.
The goal is not to bypass authorization.
It is not to extract secrets from someone else’s session.
It is not to convert every private web application into an unofficial public service.
The goal is to understand what your own authorized interface is doing so that your own workflow is not trapped behind mouse gestures.
This is where cached network captures become valuable.
Live browser activity is noisy and fleeting. Once captured, it can be inspected repeatedly without performing the action repeatedly. Requests can be grouped by host, filtered by type, and compared.
A graphical mystery becomes a file.
A file can be searched.
A search result can become a command.
A command can become part of a context-building vocabulary.
From Observed Request to Local Verb
Once the useful request shape is understood, a local CLI can provide a stable wrapper around it.
A generic command might look like:
tool call operation-name --json-args '{
"resource": "example",
"limit": 20
}'
The JSON is not beautiful, but it is honest.
It exposes the form of the operation without requiring a custom graphical screen for every combination of arguments.
Frequently used operations can later receive shorter aliases and shell completion. Rare operations can remain accessible through the generic call surface.
This creates a useful progression:
browser gesture
↓
observed network request
↓
saved request structure
↓
generic CLI call
↓
short named command
↓
tab-completable personal vocabulary
The graphical interface teaches the local system how the action works.
The local system then makes the action inspectable and repeatable.
This is a form of progressive formalization. A workflow does not have to be perfectly modeled before it can be useful. It can begin as an observed action and gradually become a stable verb.
A Local Web Interface Can Come Later
Commands are an excellent substrate, but not every user should have to compose a context package by hand.
A local web interface can project the same underlying operations as a sequence of steps:
- Add a note.
- Select a conversation.
- Select an issue.
- Run a saved query.
- Attach files.
- Preview the assembled context.
- Copy the text or package reference.
The interface may allow additional steps to be inserted dynamically until the user chooses Copy Context.
The crucial architectural decision is that the web interface should not become the only place where the workflow exists.
The commands remain the truth.
The files remain inspectable.
The interface is a view over the same operations.
That preserves two complementary modes:
- shell mode for speed, automation, composition, and expert use;
- visual mode for discovery, review, ordering, and occasional use.
The interface is allowed to be friendly because the substrate is not fragile.
The Clipboard as an Honest Seam
A surprising amount of modern AI work can be improved by respecting the clipboard.
The clipboard is often dismissed as primitive. In this architecture, its limitations are strengths.
It creates an obvious boundary between:
- the local evidence-gathering system,
- and the remote reasoning system.
The local workshop assembles the context.
The human can inspect it.
Then the human deliberately transfers it.
This is less seamless than granting an autonomous agent permanent access to every account, application, and private repository.
That friction is not necessarily a defect.
It is a consent moment.
It says:
This is the information crossing the boundary now.
For small contexts, the clipboard can carry the complete text.
For larger contexts, it can carry a compact cartridge, archive, or reference that the receiving environment knows how to open.
Parallel Models, Serial Judgment
Either way, the transfer is explicit.
The model remains replaceable.
The local context machinery remains yours.
Parallel Models, Serial Judgment
Once a context package can travel cleanly, it can be sent to several models.
That creates a genuine parallel fan-out:
┌──► Model A ──► independent answer ──┐
Compiled context ───┼──► Model B ──► independent answer ──┼──► human review
└──► Model C ──► independent answer ──┘
The models should initially answer independently.
If each model sees the previous model’s answer, the exercise becomes serial imitation. Early framing errors propagate. Apparent agreement may reflect anchoring rather than independent convergence.
Blind fan-out preserves diversity.
The reduce step is different.
It is serial and human-directed:
independent answers
↓
human comparison
↓
feedback and correction
↓
next model or next prompt
↓
accumulating context
The human is not an inconvenient component waiting to be automated away.
The human is the governor.
The models provide alternative compressions of the evidence. The human notices which one saw the architecture, which one became distracted, which one invented facts, and which disagreement reveals a hidden assumption.
This is not majority voting.
Three models can agree for the same bad reason.
The useful product of parallelism is not consensus. It is contrast.
The Human Reduce Step Protects Meaning
Automatic reduction is attractive because it promises speed. But some reductions erase the very thing the work is trying to preserve.
Consider a long development journal.
A machine summarizer may identify:
- files changed,
- commands run,
- errors fixed,
- and the final configuration.
Those facts may be accurate while missing the actual insight:
A local AI workflow needs a user-owned coordination layer that combines Unix composition, ARexx-style application control, reproducible environments, observable browser traffic, and deliberate transport into replaceable models.
That insight did not appear as one clean sentence during the work.
It emerged across the sequence.
The human reduce step recognizes that emergence.
It decides what belongs in the public story and what should remain in the Grimoire.
It separates:
- mechanism from meaning,
- implementation from architecture,
- incident from principle,
- and private circumstances from durable lessons.
The public article is not a shorter transcript.
It is a different artifact.
The Rabbit Hole Was Not a Detour
It is easy to emerge from a multi-day tooling excursion feeling that the real work was postponed.
The intended task did not receive three uninterrupted days of attention. Instead, aliases were adjusted, environments were pinned, startup behavior was reconsidered, browser traffic was inspected, command interfaces were expanded, and an unexpectedly complete sub-platform appeared.
That can feel like failure of focus.
Sometimes it is.
Toolsmithing can become avoidance with excellent typography.
But there is another possibility.
A recurring tax has finally become large enough to justify eliminating it.
The test is whether the rabbit hole changes future work.
This one does.
Before, context assembly was largely an ad hoc human performance.
After, it can become a named sequence of operations.
Before, a browser connector was a black box.
After, its authorized requests can be observed, cached, studied, and—where appropriate—represented as explicit local calls.
Before, the desktop environment was merely where the tools happened to run.
After, it is a declared and rebuildable workshop.
Before, the model conversation was the container of continuity.
After, continuity can live in files and cartridges outside the conversation.
The result is not just a new tool.
It is a larger vocabulary of action.
The Vocabulary Shift
The deepest change is linguistic.
A tool becomes useful when its operations can be named.
The new vocabulary includes distinctions such as:
Prompt versus context
The prompt is the request.
The context is the evidence required to answer it.
Mixing them into one undifferentiated paste makes both harder to inspect.
Conversation versus artifact
A conversation is temporary working memory.
An artifact is durable state that can cross sessions and models.
Connector versus protocol
A connector is one implementation.
The underlying protocol, request shape, or file representation is the more durable concept.
Interface versus capability
A button is an interface.
The authorized operation behind it is the capability.
Automation versus actuation
Automation describes a process running by itself.
Actuation names the moment software changes something in the world: sends, writes, clicks, deletes, publishes, or updates.
The latter deserves special visibility.
Installation versus declaration
An installation is something that happened to a machine.
A declaration is an explanation from which the environment can be rebuilt.
Summary versus reduction
A summary makes something shorter.
A reduction decides what matters.
Memory versus continuity
Memory suggests that one agent remembers.
Continuity means the next agent can reconstruct the relevant state from artifacts.
These are not merely vocabulary lessons.
Each distinction changes where the architecture places responsibility.
Security Is Part of User Agency
A user-owned automation environment should not romanticize unlimited access.
Desktop control, browser captures, cached responses, authentication tokens, and context packages can all contain sensitive material.
Agency without boundaries becomes self-inflicted surveillance.
Several rules follow:
- Inspect only sessions and systems you are authorized to use.
- Treat captured network logs as sensitive evidence.
- Keep credentials outside generated context.
- Separate credential storage from request description.
- Prefer dedicated browser profiles for automation.
- Limit desktop automation to the environment that needs it.
- Preview context before transferring it to a remote model.
- Preserve the ability to run without granting one model permanent access to everything.
- Make consequential actions produce receipts.
- Keep destructive operations out of exploratory probes.
The purpose of the workshop is not frictionless surrender.
It is legible control.
What This Means for the Book
The book is not merely a sequence of chapters written in order.
It is being mined from a living technical practice.
Some sessions produce polished narrative.
Some produce components.
Some produce vocabulary.
Some produce mistakes valuable mainly because they expose a rule.
Some are too private, repetitive, or procedural to publish.
The Grimoire prevents those sessions from disappearing.
The public site performs the distillation.
The context compiler connects the two.
A private article can be included as source material without being copied verbatim. A future model can receive the raw ore, the surrounding code, the current request, and the constitutional rules for transforming it.
The public result can then preserve the insight without preserving every incidental detail.
That is continuity without indiscriminate disclosure.
The story survives.
The sediment does not have to.
Thirty Consequences of the Context Line
For the operator
- Repeated context-gathering actions become named verbs.
- Tab completion reduces the need to memorize identifiers.
- The shell becomes a discoverable menu without ceasing to be a shell.
- Context can be previewed before it crosses a model boundary.
- Switching models no longer requires rebuilding the evidence from scratch.
For the architecture
- The command layer becomes the stable substrate.
- A graphical interface can remain a projection rather than a prison.
- Files provide a common interchange format between unrelated tools.
- Generic JSON calls cover the long tail of operations.
- Short aliases can evolve only for operations that earn them through use.
For observability
- Browser gestures can be connected to actual requests.
- Cached network evidence can be inspected without repeatedly touching the live service.
- Endpoint discovery becomes a learning process rather than folklore.
- Failures can be localized to acquisition, transformation, transport, reasoning, or actuation.
- A workflow can show what happened instead of merely claiming success.
For AI use
- Models receive compiled evidence rather than improvised recollection.
- Independent fan-out produces contrast instead of premature consensus.
- The human can direct the serial reduce step.
- Model replacement becomes less disruptive because continuity lives outside the model.
- Larger context windows become useful capacity rather than an excuse for indiscriminate dumping.
For publishing
- Private development journals can remain detailed without becoming automatically public.
- Public articles can preserve architectural meaning while omitting sensitive circumstances.
- Provenance can point back to durable source artifacts.
- The book can grow from selected insights rather than chronological transcript accumulation.
- Weak sessions can still contribute one strong idea to the larger work.
For sovereignty
- The local machine remains the owner of context assembly.
- Credentials can remain local even when reasoning happens remotely.
- Clipboard transfer creates an explicit boundary and consent moment.
- Reproducible environments reduce dependence on one aging workstation.
- The user remains conductor while applications and models remain instruments.
Three Laws for the Workshop
Law One: Context Must Be Compiled, Not Remembered
Anything important enough to influence a model’s answer should be recoverable from explicit inputs.
Do not rely on a conversation to remember the system.
Build the system so a new conversation can reconstruct it.
Law Two: Actuation Must Be Observable, Not Magical
Reading, searching, and proposing are different from sending, publishing, deleting, and changing.
The moment software touches the world should be visible, bounded, and receipted.
Law Three: Continuity Must Live in Artifacts, Not Personalities
Models change.
Sessions end.
Interfaces are redesigned.
Companies alter access.
A durable workflow stores its state in files, repositories, declared environments, and reproducible packages.
The intelligence may be rented.
The workshop should remain yours.
The accidental sub-platform was therefore not really an attempt to rebuild the Amiga, Unix, or any particular historical machine.
It was an attempt to recover a relationship with the computer.
A relationship in which the user can name operations, compose tools, inspect boundaries, preserve evidence, replace components, and carry hard-won context forward.
Unix supplied the pipes.
ARexx supplied the conductor’s baton.
Nix supplied the rebuildable room.
The browser supplied observable protocol evidence.
The clipboard supplied an honest border.
The models supplied alternate lenses.
And the human remained at the center, deciding what the work meant.
1. PROBES
This bounded read-only probe shows the newest public-article neighborhood before choosing placement or a final filename.
python scripts/articles/lsa.py -t 3 --reverse --fmt dated-slugs
2. NEXT CONTEXT
! python scripts/articles/lsa.py -t 3 --reverse --fmt dated-slugs
/home/mike/repos/grimoire/_posts/2026-07-25-npvg-stick-bug-amiga-arexx-nixos.md
3. PATCHES
No repo patches required. This response produces a manual-paste editorial deliverable, so no ignition is required.
4. PROMPT
I pasted the public article derived from the Stick Bug Grimoire entry. Review it for narrative continuity, accidental private or client-specific details, unsupported overclaims, excessive repetition, and consistency with the surrounding recent articles. Preserve the central synthesis: Unix-sized context commands, ARexx-style orchestration, reproducible local environments, observable authorized browser requests, model-independent context artifacts, parallel model fan-out, and human-directed serial reduction. Recommend only the smallest high-leverage editorial changes.
5. EXTERNAL DELIVERABLES
Manual-paste public article above. Suggested filename:
2026-07-25-command-line-becomes-context-line.md
[1]: https://docs.cursor.com/en/cli/reference/slash-commands?utm_source=chatgpt.com "Cursor – Slash commands"
Note: And then finally the new model that just popped up today that I’m getting a feel of close on the heals of just getting used to the new Gemini 3.6. It’s a week of new model competition.
Opus 5 High: Context verified. One honesty note before the article, because it changes what I can legitimately hand you at the end: the entire short-command thread — aliases, functions, complete -F compspecs — is structurally un-probeable by the ! executor. Compspecs live in the shell process and have no export form; the executor spawns a non-interactive shell where neither your aliases nor your compspecs exist. A complete -p xc probe returns the same answer whether the spec exists or not: a false receipt in both directions. So the completion claims in this article are hand-run-only, and I’ve kept them out of the echoed probes rather than dressing them up as evidence.
The Slash and the Space
What the last article became, and why nothing was lost
Yesterday’s piece went into the Grimoire instead of the public feed. Too long, too many identifiers that would have needed scrubbing, too much of the actual rabbit hole showing. That’s not a failure mode — that’s the ore pile working as designed. The private journal takes the raw seam; the public side gets the refined bar. Same carbon, different pressure.
But the story in it deserves to be out here, so I’m reprojecting it. Not as Chapter 2. Chapter 2 is going to be about short, choppy Unix commands and the way tab-completion turns a two-letter verb into a discoverable menu. This is the tooling article that has to land before that chapter can exist — the adjustments that make a vocabulary of chops possible in the first place.
What the Stick Bug actually established
The compressed version, without the three days of yak-shaving:
There is now a sub-platform inside the platform. Nix pins the room, so a script that runs today runs identically in five years on hardware that doesn’t exist yet. X11 keeps the puppet strings, so one program can still reach into another and click, type, and read. SystemD is the ignition key, so the whole apparatus comes up at boot without a human opening seven terminals. Git is the blueprint, so the room is clonable to any machine that can fetch a repository.
Four choices, one property: the workspace is a text file that describes itself, and the machine is downstream of the text. That’s the whole trick. Everything else in this article is a consequence.
The one deliberately unfashionable choice in there is X11 over Wayland. Wayland is better at almost everything except the one thing that matters here: it isolates clients on purpose. A well-behaved Wayland client cannot inject synthetic input into another client’s window or read its pixels, because that capability is indistinguishable from a keylogger. X11 makes no such distinction, which is why xdotool and wmctrl work, which is why a Python script can lay out seven virtual desktops and type into each of them. Choosing X11 is choosing to keep a security hole open because the hole is also a door. Say it plainly, know why you chose it, and don’t pretend it’s a free lunch.
The real ARexx invention was the port
Here’s the part that turned out to be load-bearing.
Everyone remembers ARexx as “the Amiga’s scripting language.” That undersells it. REXX was already a fine language; Hawes porting it to the Amiga was not the innovation. The innovation was that every application exposed a named command port, and any script could address a port by name and send it a command:
address 'EDITOR'
'open file.txt'
'goto line 40'
The application was, at runtime, a callable object with a documented verb list. Not a GUI you automated by faking clicks — an interface you spoke to. In 1990 you could glue a text editor, a paint program, a terminal, and a spreadsheet into one workflow because they all answered on ports, and the glue was text.
Then we spent thirty-five years losing that and calling it progress. Applications became silos with no address. Automation regressed to screen-scraping and coordinate-clicking, which is exactly what xdotool is: the pantomime you’re forced into when the port is gone.
And then, very recently, the port came back — as tool calls. A model asking a server for list_events with a JSON payload is doing the thing ARexx did, over a different transport, with a rediscovered name. This is exaptation, not invention: the organ was always there, it just got recruited into a new body. Which means the correct question for the next chapter isn’t “how do I automate my desktop” — it’s “what in my environment has a port, and what have I been pantomiming at because it doesn’t?”
c.1987 ARexx port address 'EDITOR'; 'open file.txt'
c.1988 IRC /me a namespace you type, not click
c.2000 bash complete the namespace generates itself from the machine
c.2013 /slash apps a curated menu inside someone else's window
c.2024 tool calls the port, rediscovered, over JSON
now con.txt the port's reply, appended to a file you own
The slash and the space
You asked whether Cursor invented slash commands. It did not, and the real lineage is more useful than the credit.
Slash commands are IRC. /me, /join, /msg — a leading sigil that flips the input box from “content” to “command,” because there was exactly one input box and it had to do both jobs. Slack lifted the convention for third-party apps, Discord formalized it with an actual registration protocol and an autocomplete menu, editors converged on command palettes doing the same job with a different key, and the AI tools inherited all of it. Cursor may well have been where a lot of people first saw it in an AI context — being the popularizer in a space is a real thing and worth naming — but nobody in that chain invented it. They rediscovered that a single text field is the cheapest universal interface, and that a sigil is the cheapest possible mode switch.
Meanwhile, in the other window, bash has had a different answer to the same problem for a quarter century. Programmable completion landed in bash around the turn of the millennium; tcsh had a complete builtin in the eighties; readline filename completion is older still. Same goal — make the namespace discoverable at the instant of typing — but a structurally different implementation, and the difference is the whole point:
A slash menu is a curated list someone authored. Finite, deliberate, versioned, and wrong the moment the underlying capability changes without the list changing with it. This is the failure mode I keep flagging in your own constitution: a map that outruns the territory, presented at the exact moment a human is deciding.
A completion is generated from the live machine. compgen walking PATH, walking the filesystem, walking a directory you named. Generated-not-authored. It cannot drift, because there is nothing to drift from — it is a projection of current state, computed at keypress time.
Both are good. But they optimize opposite ends: the slash menu is better at teaching (it shows you a curated seven), and completion is better at not lying (it shows you what exists). The interesting design space is a vocabulary short enough to type blind, backed by completion that generates its arguments from the machine. Which is what you noticed when xc suddenly became more useful: the verb is two characters, and the noun completes itself.
What short names actually cost
Here’s the structural bill, and it’s the thing Chapter 2 has to teach honestly.
An alias is not a callable object. Bash expands an alias only when it is the literal first word a parser reads. Assign it to a variable and invoke the variable and you get command not found. Which means: nothing can invoke an alias on a human’s behalf. No menu, no dispatcher, no wrapper, no script. Not the compile lane’s ! executor either — a child shell inherits PATH, not your shell’s alias table.
So a vocabulary of short aliases is a human-only vocabulary. That’s fine, and sometimes it’s exactly right — a printed list the eye reads and the hand retypes has no second ordering that can drift out of sync. But the instant you want a word reachable by anything other than fingers, it has to become a shell function (reachable by other functions, invisible to child shells) or a real executable on PATH (reachable by everything, including the compile lane).
Three tiers, three reachability guarantees, and the choice is not cosmetic:
alias fingers only
function fingers + other functions in this shell
command fingers + functions + child shells + the compile lane
The half-broken menu is the worst outcome available: a list where some rows work and some don’t, for a reason invisible from the list. If a word must be reachable, promote it. If it’s yours alone, an alias is honest.
Chop chop
Which brings us to what all of this is for.
echo 'Intro' >> con.txt
echo thread <id> >> con.txt
echo ticket <id> >> con.txt
echo query '<...>' >> con.txt
echo 'Actual prompt' >> con.txt
The sketch looks trivial and it is doing something specific. Appending to a file is a Unix pipe with a memory. A pipe is ephemeral; the whole conversation exists for the duration of one process tree and then it’s gone. A file is the same composition with the intermediate state preserved, inspectable, editable, diffable, and — this is the part that matters — ordered. Line 3 cannot retroactively change line 1. Nothing above a given line can be rewritten by anything below it.
That ordering is what a chat window can’t give you. A chat window’s context is a hidden accumulation you can only reason about by inference. con.txt is the same accumulation, but it’s a text file on your disk, and you can cat it, and if the answer comes back wrong you can look at exactly what you actually sent instead of theorizing about what the model probably saw.
con.txt grows downward; nothing above a line can be changed from below
─────────────────────────────────────────────────────────────────────
here → which tree, which SHA, clean or dirty
thread <id> → the conversation that started it
ticket <id> → the ask, in the asker's words
flight <url> → what the browser actually sent
── prompt ── → the one thing you want done
The eventual point-and-click assembler is a projection of that file, not a replacement for it. When the app can add a step, reorder steps, and hand you either the full text or a link to a hashed archive, it should be writing the same lines you’d have typed. If it ever becomes the only way to build the context, the file stopped being the record and started being an export — and at that moment the whole property you built this for is gone.
Wire truth: a recording, not a tap
The second thread. You called it “sniffing CDP on the wire, but really cached by that time,” and the parenthetical is the interesting part, so let’s make it the headline.
Every Chromium-family browser will, on request, write down the network conversation it had: request initiated, headers sent, response received, bytes finished — each event stamped with a requestId that correlates them into a single row. Drain that log to disk and you have a flight recorder. Not a live tap. A recording.
The instinct is to treat “cached” as a degradation. It’s an upgrade. A live tap is a performance — you watched it, you remember it, and your memory is now the only witness. A recording is an artifact: immutable, re-readable, hashable, attachable to a ticket, and citable by someone who wasn’t in the room. The distillation you run over it later — a per-request table plus a third-party host census — is a lens on evidence, and the raw ledger never has to enter the context window for the conclusion to be checkable.
What this buys you practically: when a client application talks to a background service, the documentation is a hypothesis and the recording is a receipt. You don’t have to guess the endpoint shape, the auth header form, the pagination parameter, or which of three plausible field names the payload actually uses. You read what the client sent. Then you replay it — curl, or a CLI wrapper that takes the whole argument set as one JSON blob so nothing gets mangled by shell quoting on the way in. Recording to request, in two moves, with no reverse-engineering by intuition.
Three honest limits, because a lens that overclaims is worse than no lens:
Not everything crosses a surface you can attach to. A desktop app’s main process, a native transport, a local subprocess speaking a protocol over stdin/stdout — none of that shows up in a renderer’s network log. What you get is what the browser-shaped part of the application did.
Correlation is not causation, even here. A request appearing after an action doesn’t establish that the action caused it. The requestId correlates events within one request; it does not tell you why the request happened.
The recording is scoped to the flight you took. Cache reuse is a feature — no new flight means no new evidence, and a distillation over a stale ledger is a photograph of last week. Know which one you’re reading, and if it matters, fly again.
The boundary
Say it once and don’t be precious about it. Inspecting traffic your own client makes, on your own accounts, on surfaces you’re authorized to use, for interoperability — that’s ordinary engineering, and it’s how most integrations get built. Doing the same to someone else’s session, or publishing credentials, or hammering an undocumented endpoint until it falls over, is not the same activity and doesn’t become the same activity because the tooling is identical. The tool doesn’t know the difference. You do. Keep the recordings out of payloads bound for anywhere you don’t control, because a ledger keyed by hostname is an identifier map whether you meant it that way or not.
The through-line
Three sections, one shape.
ARexx gave applications addressable names so text could glue them together. IRC gave commands a sigil so one text field could be two interfaces. Bash generated its namespace from the machine so the menu couldn’t lie. Tool calls rediscovered the port and put JSON on it. And a file you append to is all four of those at once: named verbs, typed not clicked, arguments completed from live state, replies accumulating in an order nothing can retroactively edit.
That’s not nostalgia and it isn’t a metaphor doing free work. It’s the same mechanism getting re-recruited every time the substrate changes, because the mechanism is correct: let programs address each other by name, in text, and keep the transcript. The Amiga had it, the industry lost it, and the recovery arrived wearing a new acronym.
Chapter 2 is about the verbs. This was about making sure the verbs can be reached.
30-and-3: candidate verbs for the chop vocabulary
Thirty one-line candidates for con.txt line-kinds — deliberately reaching past the obvious API-connector octave into filesystem, time, process, hardware, and human territory. Then three picks with reasoning.
now— timestamp, timezone, uptime, who’s logged in. Answers “when was this taken” without putting a mutable clock in the hashed body.here— cwd, branch, short SHA, clean/dirty. Provenance for everything below it.vars— declared variable names only, never values. Names-not-secrets as a verb.disk—dffor the mount that matters plus onedu. Convicts “out of space” before you theorize about code.ports— what’s listening locally. The ARexx port list, literalized: which programs are currently addressable.procs— one-screen census, filtered to your own long-lived daemons, not all 400 rows.unit <name>— service status plus the last twenty journal lines. Ignition receipts as one line.dns <host>— resolution plus registrar summary. Splits “it’s me” from “it’s the internet” in one call.tls <host>— issuer, expiry, chain length. The single most common silent expiry in production.peek <file>— bounded head-or-tail, capped by construction so it can never flood.shape <dir>— depth-limited, gitignore-honoring structure. Shape without contents.hist— the last N commands you actually typed. Your own trail, admissible.clip— current clipboard as a labeled block. The synapse, made citable.focus— accessibility-tree text dump of the focused window. The GUI as prose. Dies on Wayland.port <app>— send a command to a running application’s control port, append the reply. ARexx, literally.flight <url>— the cached network recording, distilled to table plus host census.probe <url>— headers only: status, redirect chain, content-type, size. Cheapest possible lens on any URL.map <host>— sitemap entry counts and the first N paths. Structure, not corpus.rules <host>— the crawl-directive file everyone theorizes about without reading.neg <url>— same URL under three differentAcceptheaders, diffed. Content negotiation as a measurement.sql <db> '<q>'— one bounded SELECT against a local database, header-column formatted.cells <range>— a named range as TSV. Never the workbook.thread <id>— one conversation, flattened to text, attachments as metadata hooks rather than bytes.ticket <id>— one issue: fields, body, comments, flattened out of whatever nested document model it arrived in.page <id>— one wiki page, markup stripped.msgs <permalink>— one message thread, parent plus replies, from a permalink that carries both coordinates.said <id>— one meeting transcript, speaker-labeled, no summary layer.pdf <file> <pages>— page count, outline, and the text of the pages you name. Never the whole document.exif <file>— dimensions and metadata, described rather than embedded. The cheap lens on an expensive object.straddle <a> <b>— structural diff of two captures of the same thing taken at different times. The before/after discipline as a single verb.
The three
here — because every other line above is worthless without it. It is the cheapest verb on the list and the only one whose absence corrupts all thirty others: a distilled recording, a ticket body, and a query result with no tree identity attached are three orphans that can’t be re-fused to the history they were cut from. It also happens to be the missing third of your provenance triple — bytes and signature are solvable, but “from which point in the DAG” has to be captured at compile time or it’s gone forever. Highest value per character typed, by a wide margin.
neg <url> — because it converts a thesis into a measurement, and it’s the only candidate on the list that a stranger with no credentials, no browser, and no repository can run on any host on the internet in under a second. That combination — zero auth, zero setup, bounded output, and observably different results across sites — is what separates a claim you can defend from a claim you can only assert. It’s also the verb most likely to surprise you, because the interesting cases are the sites where all three responses are byte-identical.
port <app> — because it’s the only pick that isn’t a rediscovery of something already sitting in the drawer. Every other verb on the list pulls from a remote service or a file at rest. A port is a conversation with a running local process, which is precisely the organ the Amiga had and modern Linux mostly amputated, and precisely the capability you’re currently pantomiming with synthetic keystrokes. It’s also the riskiest pick and deserves to be labeled as such: it is a nice noun and nothing more until a protocol decision gets made — Unix socket, named pipe, a local subprocess speaking a documented request format — and the choice determines whether it’s one verb or a permanent second surface to maintain. Worth picking anyway, because it’s the one that would change what’s possible rather than what’s convenient.
Noted for the record: entries 14 and 15 are exactly the two that die under Wayland’s client isolation. That isn’t a coincidence, it’s a restatement of the Stick Bug’s central tradeoff in the vocabulary’s own terms.
1. PROBES
grep -c "writeShellScriptBin" flake.nix; grep -c "^ *alias " flake.nix
ls browser_cache/*/*/network_log.jsonl 2>/dev/null | wc -l
grep -c "requestId" prompt_foo.py
The first pair measures the reachability surface the article claims matters: how much of the shell vocabulary is a real command a child shell can resolve, versus an alias only fingers can reach. Two numbers, one line, and the ratio is the thing Chapter 2 has to be honest about.
The second establishes whether flight recordings exist to distill at all — a wire-truth article resting on zero ledgers would be theory. The pipe to wc -l is load-bearing, not cosmetic: those directory names are hostname-keyed identifiers, and the unpiped form leaks them straight into the payload. Count only, never paths.
The third confirms the correlation claim in the flight-recorder section is implemented rather than asserted — if the distiller doesn’t key on requestId, the paragraph about correlated rows is describing something that doesn’t exist.
Not probed, deliberately: anything touching aliases, functions, or compspecs. The ! executor is non-interactive and cannot see shell-session state, so those probes return identical answers whether the thing exists or not. Hand-run only, at your prompt, with your fingers.
2. NEXT CONTEXT
! grep -c "writeShellScriptBin" flake.nix; grep -c "^ *alias " flake.nix
! ls browser_cache/*/*/network_log.jsonl 2>/dev/null | wc -l
! grep -c "requestId" prompt_foo.py
flake.nix
cli.py
scripts/connectors/gmail.py
scripts/connectors/jira.py
Lean set for a Chapter-2 turn: the vocabulary itself, the JSON-args actuator that any replay would route through, and two connectors as the shape a new con.txt verb would have to match. Everything else in this compile was scenery for the article and can drop.
3. PATCHES
No repo patches required. The deliverable was prose, and none of the three probes has fired yet — patching the vocabulary before the reachability ratio is known would be building on a number nobody has read. No ignition required either: all three probes read files at call time.
4. PROMPT
Chapter 2, first pass. Take the three probe receipts above as the baseline and tell me what the reachability ratio actually implies for a chop vocabulary: which existing words should be promoted from alias to function to real command, and which should stay finger-only on purpose. Then design ONE verb from the 30-and-3 list — `here` — end to end as a real command on PATH: what it prints, in what order, how it stays bounded, and how it refuses to emit anything that would make the cartridge body non-reproducible. Show me the tab-completion story for it if there is one, and say plainly if there isn't. Close with the turn shape.
5. EXTERNAL DELIVERABLES
The article above is the deliverable and it lives outside this repo — it rides the article lane into the public posts directory, not a patch marker. Two things to check by hand before it goes: the ASCII date column uses “c.” hedges on ARexx, IRC, bash completion, and slash-app dates, and those hedges are load-bearing, so don’t let a copyedit harden them into false precision. And the boundary paragraph is short on purpose; if it reads as too thin for a public post, lengthen it rather than cutting it.
MikeLev.in: And now we’re up to the reduce process that’s not really reduce. It’s more of a compare and contrast exercise. Where did all the models converge on the same ideas and where did they diverge? What are the biggest surprises? Where are the outliers or things that go counter to the inferred gravities. Can you infer anything about the different 30 vignette choice and creativity forcing strategies?
Note: I go with Gemini 3.6 for this because of the terse matter-of-fact even-handed way that it has about it. And it’s the fastest! And the turns are cheap quota-wise. You get more top-model turns with Google or however you want to put it; your quotas burn slower and get reset more frequently so it’s good for tasks like this.
Gemini?
🎤
Gemini 3.6 Thinking: Context verified.
Here is the comparative analysis and reduction of how the four frontier models—Gemini 3.6, Grok 4.5, ChatGPT 5.6, and Opus 5—handled the re-projection of the Stick Bug Grimoire entry and the 30-and-3 ideation kata.
1. Convergence: The Universal Gravity
Across all four outputs, the models converged on the same core architectural invariants without prompt-nudging:
- Nix as the Rebuildable Room: Every model agreed that Nix provides an immutable “glass bubble” where environment drift is impossible and dependencies are pinned in code rather than accumulated as machine rot.
- X11 as an Explicit Trade-off: All models correctly recognized that opting for X11 over Wayland is a deliberate choice: sacrificing Wayland’s client-isolation security model to retain inter-process GUI actuation (
xdotool,wmctrl). - ARexx Exaptation: Every model identified that ARexx’s magic wasn’t the REXX language, but addressable command ports—a concept now exapted into modern LLM tool-calling and API endpoints.
- Text &
con.txtSupremacy: The agreement that short Unix commands appending text to a file (echo ... >> con.txt) beats proprietary, black-box UI slash-commands.
2. Divergence: Model Personalities & Structural Focus
| Dimension | Gemini 3.6 | Grok 4.5 | ChatGPT 5.6 | Opus 5 |
|---|---|---|---|---|
| Tone & Style | Direct, product-focused, balanced | Ultra-concise, punchy, minimal fluff | Philosophical, essayistic, meta-cognitive | Technical, mechanics-obsessed, highly nuanced |
| Core Angle | Practical UI evolution: FastHTML & CDP flight recorders | Pinned environment + short commands as a daily habit | Input-routing problem & human as the serial governor | Reachability tiers, shell execution mechanics, and ARexx ports |
| 30-and-3 Katas | 30 Product/Tooling Vignettes | 30-word summary + 3 Forcing Functions | 30 Architectural Consequences + 3 Workshop Laws | 30 Atomic CLI Verbs for con.txt + 3 Picks |
3. Surprises & Black Swans
1. Opus 5’s Falsification & The Reachability Hierarchy (Major Outlier)
Opus opened with a technical observation that directly enforced the repo’s constitution:
The un-probeable compspec: Shell aliases and
complete -Fcompspecs live inside the interactive parent shell and do not export to non-interactive child subprocesses. Therefore, probing them via!inadhoc.txtyields a false receipt.
Opus then derived a Three-Tier Reachability Hierarchy:
- Alias: Fingers only (interactive prompt).
- Function: Fingers + parent shell functions (invisible to child shells/
!). - Executable on
PATH: Universal (fingers, functions, child shells, and the!compile lane).
2. Grok’s Rule-Bending Meta Twist
Rather than generating 30 individual vignettes, Grok compressed the “30-and-3” into literally 30 words followed by 3 operational forcing functions. While creative, it bypassed the fan-out/divergence objective of the 30-and-3 kata.
3. ChatGPT’s Historical Contextualization
ChatGPT accurately contextualized the lineage of slash-commands back to IRC (/me, /join), highlighting that Cursor popularised—rather than invented—slash-commands in AI chat UIs. It framed the primary bottleneck of modern AI not as model intelligence, but as input routing.
4. Analysis of the “30-and-3” Creative Strategies
The 30-and-3 kata is designed as a fan-out (divergence) → reduce (human taste) exercise. Each model interpreted this constraint differently:
- Gemini 3.6 (Engineering Roadmap): Generated 30 software features/vignettes to build. Excellent for drafting a product backlog.
- Grok 4.5 (Micro-Summary): Bypassed the fan-out entirely to deliver an ultra-dense executive summary.
- ChatGPT 5.6 (System Axioms): Listed 30 macro-level consequences for operators, architecture, and sovereignty. Excellent for manifesto writing.
- Opus 5 (The Pure Kata Winner): Generated 30 concrete, one-word CLI verbs for
con.txt(e.g.,here,neg,port,unit,dns) and selected 3 based on failure modes, trade-offs, and value per character typed. Opus captured the operational intent of the 30-and-3 kata most effectively.
Synthesis & Recommended Public Pick
For the public site, Opus 5’s narrative framing combined with ChatGPT’s input-routing thesis yields the highest signal:
- The Headline: “The Command Line Is Becoming the Context Line” / “The Slash and the Space”.
- The Thesis: Slash-commands are curated maps authored by someone else; shell completion over short, append-only text commands (
con.txt) is generated directly from live machine state and cannot lie. - The Actuator: Wire truth (CDP network logs) replaces speculation; short CLI verbs replace complex UI navigation.
Actionable Response Contract
(1) PROBES
grep -c "writeShellScriptBin" flake.nix; grep -c "^ *alias " flake.nix
Proves: Measures the current ratio of universal PATH binaries versus finger-only aliases in flake.nix.
(2) NEXT CONTEXT
! grep -c "writeShellScriptBin" flake.nix; grep -c "^ *alias " flake.nix
foo_files.py
flake.nix
(3) PATCHES
No repo patches required.
(Ignition: no ignition required.)
(4) PROMPT
Context verified. The comparative analysis of model outputs is complete. Please proceed with refining the selected public article draft or updating the pinboard in foo_files.py as needed.
(5) EXTERNAL DELIVERABLES
None required for this turn.
MikeLev.in: I’m about to publish this on the public MikeLev.in Honeybot for reading on YouTube. You have a chance to introduce this article (and this system?) to the world. I need a good introduction. Be brief. Be neutral. Be dry. Like one of those NPR ladies you can tell are emotionally holding back their excitement about a topic because New Englanders emulate that British Victorian stiff upper lip control thing like a properly civilized person does. In TL;DR: form. I’ll copy/paste what you produce to the top of the article.
Also please create a closing summary here at the end of the article which will be left here for hitting home the message of it all and creating the final take-away for the audience. Wrap it up cleanly and set the stage for the most likely next article, please and thank you!
Gemini 3.6 Thinking: Here are the opening TL;DR introduction and the closing summary, tailored precisely to your public post.
[Top-of-Article Introduction]
[Moved to top]
[Article Closing Summary & Next Horizon]
Closing Summary: The Local Conductor
When you strip away the marketing gloss of modern AI tooling, a simple truth remains: plain text won, and context compiled from explicit, local ingredients will always beat context remembered by a black-box model.
The three-day descent into the sub-platform was not an exercise in nostalgia; it was the work required to recover the conductor’s baton:
- Nix provides the rebuildable room where dependencies never rot.
- X11 preserves the deliberate inter-process control that modern isolated display servers restrict.
- CDP Flight Recorders convert background web gestures into readable, auditable network receipts.
- Append-Only Streams (
con.txt) turn the command line into an ordered, non-rewritable context compiler that no model can retroactively edit.
By treating models as replaceable reasoning engines and keeping context assembly strictly local, we maintain control over the actuation boundary. You do not need to surrender your workflow to a single vendor’s ecosystem or trust an agent loop to guess your environment’s state. You simply type short, honest verbs, let your shell complete the nouns from live system data, and pass the compiled artifact forward.
The Next Horizon: Chapter 2 and the Reachability Hierarchy
With the underlying sub-platform established, our focus shifts from workspace mechanics to the operational vocabulary itself.
In the upcoming Chapter 2, we move from architecture to execution:
- The Reachability Hierarchy: Structuring our terminal vocabulary across the three execution tiers—finger-only aliases, shell functions, and universal PATH binaries—so that our tools work as seamlessly inside non-interactive automated compile lanes as they do under human hands.
- The
hereVerb: Building our first zero-dependency, PATH-resident context command end-to-end—capturing exact tree SHA, dirty state, working directory, and time offset without emitting non-reproducible churn into the cartridge payload. - Tab-Completion from Live State: Wiring native
bashcompletion to generated machine state so that discoverability requires zero manual documentation and zero proprietary UI wrappers.
The sub-platform is booted, the garage is closed, and the hovercraft works. Now we build the verbs.
Book Analysis
Ai Editorial Take
What is genuinely striking about this entry is how it reframes the AI token-budget crisis not as a model intelligence problem, but as an input-routing and data-hygiene problem. Instead of asking how to make models smarter, it asks how to make our local operating environments speak the model’s language cleanly via plain text. It treats the local filesystem as the ultimate reliable memory store.
🐦 X.com Promo Tweet
Stop wrestling proprietary UI drop-downs. Learn how append-only text files and short Unix commands create reproducible context cartridges for any AI model. https://mikelev.in/futureproof/command-line-context-line-unix-ai/ #AIWorkflows #Unix #LocalFirst
Title Brainstorm
- Title Option: The Command Line Is Becoming the Context Line: Unix Verbs, ARexx Ports, and Local AI Workflows
- Filename:
command-line-context-line-unix-ai.md - Rationale: Direct, professional, and highlights the core technical transition from chat windows to terminal-driven context assembly.
- Filename:
- Title Option: From Screen Scraping to Addressable Ports: The Unix Way of AI Context
- Filename:
addressable-ports-unix-ai-context.md - Rationale: Focuses on the historical continuity of ARexx and Unix pipes as applied to modern tool-calling and web automation.
- Filename:
- Title Option: The Append-Only Pipeline: Assembling Durable AI Context Without proprietary UIs
- Filename:
append-only-pipeline-durable-ai-context.md - Rationale: Emphasizes the mechanical simplicity of file-based context compilation over closed chat applications.
- Filename:
Content Potential And Polish
- Core Strengths:
- Bridges decades-old computing history (Amiga ARexx, Unix pipes) with modern AI engineering.
- Presents a concrete, actionable alternative to proprietary agent frameworks and chat interfaces.
- Emphasizes inspectability, determinism, and human governance over automated black-box loops.
- Suggestions For Polish:
- Ensure the distinction between live network interception and static cached flight logs is maintained clearly throughout.
- Add explicit examples of how terminal tab-completion speeds up local command composition.
Next Step Prompts
- Design a zero-dependency, PATH-resident implementation of the ‘here’ shell verb that captures working directory state without polluting prompt token counts.
- Draft a follow-up technical guide on writing custom bash completion functions for local API connectors.