Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
These are the companion’s accounts of the recorded discussion. Model capabilities, subscription rules, prices, version-specific flags, and predictions are contextual claims, not current guidance. An observed action is not proof that the attempted result succeeded. Distinct answers and uncertainties remain separate.
Concepts and distinctions
Custom zsh functions for Agent CLIs
Creating two-letter wrappers or alias-style functions to manage flags across various agent tools (e.g., Codex, Claude Code, Pi) seamlessly without having to remember distinct syntax like --resume vs resume.
funcwhere
A custom shell function created by John Lindquist that locates the precise file and line number where a specified zsh function is defined.
Isolated Assistant Home Directories (CODEX_HOME)
By isolating home directory pathways for AI client packages, engineers can prevent state corruption, parallelize multiple enterprise subscriptions, and prevent agent environment inheritance.
Skill Symlinking
Creating symbolic links between a primary AI config folder and a custom secondary agent folder allows tools to utilize the same skills list while keeping runtime databases separated.
CLI Proxy API Middleware
A local middleware bridge used to run Codex account tokens within the engine architecture of Claude Code clients.
Terminal Pane Management
Using fast keyboard shortcuts within a terminal emulator (like Ghostty) to split screens, organize tasks, and navigate fluidly.
Modular Shell Configuration
Structuring ZSH or Bash profile setups using a conf.d model where settings are broken down into small, numbered files for easier maintenance and composition.
Shell Startup Benchmarking
Using large language models to analyze shell profile files and eliminate blockers (like synchronous NVM evaluation) that introduce startup lag.
Herder
A high-performance command-line workspace and multi-agent dashboard designed to efficiently manage interactive panes.
CMUX
A complex terminal layout driver wrapped as a Swift utility that manages multi-session shell instructions but exhibits performance friction.
IDE
Integrated Development Environment; an all-in-one software ecosystem featuring built-in code analysis trees, direct file graph navigation, and deep refactoring architectures.
Natural Language Development / Agentic Engineering
Developing software primarily via conversational prompts to AI agents rather than through manual coding and file navigation within standard IDEs.
Agentic Code Review
Utilizing AI agents to generate summaries and reports of changes while relying on automated validation tools (linters, tests, hooks) to confirm quality.
Stricter Compiled Typings for Agents
The approach of using strictly typed languages (like Rust or Kotlin) because strict compilation acts as an ultimate quality gate for agent-generated code.
Agent-Optimized Web Languages
Languages designed from scratch to prioritize fast agent code compilation and checks rather than human ergonomics.
Bespoke Rust TUIs
High performance terminal overlays built to execute instantly for handling prompt configurations and tool workflows.
Macro-Driven Workspace Focus
The method of pairing keyboard layout layers (Karabiner) with window arrangement managers (Herder) to immediately target individual split terminals and project pathways using single-chorded hotkeys.
Automated Repository Sharding Skills
Wrapping specialized prompts into reusable console directives (such as /skill:here-now) that dispatch independent, parallelized sub-agents to independently parse git statistics, files, and branch states.
Sandboxed Agent Evaluation
Testing the operational efficiency and accuracy of multi-turn autonomous coding tools within ephemeral, isolated test runners to observe total execution loops, API permission handling, and successful build handoffs.
Budget-Conscious Agent Architecture
Designing multi-agent workflows with cost-gates and low-tier model integration to prevent prohibitive API usage on personal developer accounts.
Programmatic Post-Generation Evals
Applying automated validation scripts following LLM code generation to ensure structural and behavioral alignment with specific traits.
Swarm Code Review
An orchestration methodology where multiple independent, specialized sub-agents review source code simultaneously from disparate viewpoints (e.g., security, compliance, accessibility).
Iterative Fixer Loops
A software repair pattern where specialized sub-agents discover findings and an autonomous fixer agent corrects them repeatedly until zero issues remain.
Smoke and Integration Tests
Verification buckets intended to confirm that updated deployment code functions safely without breaking visual layouts or core operational features.
Agent Session Scripting
An automation pattern where a primary AI agent conducts user actions on a deployment, and a secondary agent reviews the execution timeline to export it as a programmatic test script.
Chaos Monkey Testing Agent
A testing setup where an AI agent is instructed to execute erratic and rapid keystrokes or interface inputs to purposefully try and break software components.
Image Diffing Iteration Loop
An agentic loop approach where the model takes automated snapshots of a rendered webpage layout, runs a visual diff against the original mockup image, and continuously updates the code until pixel-perfect alignment is reached.
File Age Policy Guardrail
A runtime file safety constraint injected into an agent workspace context that establishes a timeline cutoff based on file modification times, preventing the agent from modifying, renaming, or deleting older legacy codebase files.
Project Workspace Directory Trust
A security framework boundary that prompts the user to explicitly trust local file systems before allowing agent extensions or custom shell execution hooks to activate within that context.
Shell Tool Decoration
The technique of overriding default terminal applications or functions within a shell session to overlay custom analytical or defensive actions transparently.
File Age Protection Guardrails
Automated system restrictions that analyze file metadata to block or hesitate before letting autonomous agents modify code older than a configured age threshold.
Questions and answer status
Have you played around with completely dropping local setups like Ghostly's IDE, integrated terminal, and cli ui, and a visible Git tracking to develop entirely inside these high-profile external harnesses?
Status: answered. John states he keeps external apps open only to keep remote tracking hooks running but builds and develops entirely inside his local terminal because it grants maximum power to rapidly search, spawn, and program custom behaviors.
Do you have your dotfiles published anywhere? I'd love to take a look at them if they are publicly available.
Status: unanswered. The question is shown in chat but is not directly explicitly answered or addressed by John during the duration of this specific video segment.
Do you have your dotfiles published anywhere? I'd love to take a look at them if they are publicly available.
Status: partial. John shows that his public GitHub dotfiles repository is obsolete, shows his local structured setup instead, and mentions he wants to review it before publishing it properly.
Cmux / herdr is like Hyper IDE?
Status: answered. John outlines that traditional IDE definitions apply to graphical suites (Zed, VS Code, IntelliJ) embedded with file-system inspectors and refactoring engines, which diverges from terminal-focused script orchestration shells.
How do you review the code in the terminal UIs?
Status: answered. John delegates the task of code analysis to AI agents, asking them to summarize changes and write reports. He checks automated tests, smoke tests, and scenario suites rather than conducting deep manual line-by-line inspections.
Is there a simple Git or something that is the best Git terminal UI in the world?
Status: answered. The optimal approach is delegating to an agent to formulate and construct a highly individualized Rust terminal utility matching your direct workflow constraints.
do you use evals when creating a skill or agent?
Status: partial. John notes he is progressively incorporating automated scripted evaluations into his personal tooling stack. He highlights his experience at Vercel engineering integration infrastructure for terminal agents, where he orchestrated comprehensive evaluation sandboxes measuring prompt turn-efficiency and deployment success metrics across complex boilerplate projects.
a participant provides a summary of Cloudflare's swarm architecture for code review (security, a11y, testing sub-agents).
Status: answered. John opens the blog post directly, validates the concepts, and expands on how low model prices now enable developers to throw multiple capable models into code review swarms affordably.
How close do you think Fable got to that screenshot?
Status: answered. John answers that it performed very well for just a few minutes of generation work, noting the hand-drawn elements, tabs, and layout structures look excellent despite slight physical alignment quirks on the decorative notebook hole punches.
Exercises
-
Try: Isolate an active AI workspace environment locally by configuring independent variables for multiple assistant accounts, verifying separated session databases. Basis: 01:25:46.350
-
Try: Use an LLM model to analyze, optimize, and benchmark your personal bash/zsh startup setup to eliminate high latency hooks like NVM script initialization. Basis: John mentions this at 01:30:45 as an effective workflow optimization strategy.
-
Try: Configure an automated code repository auditing command or skill locally that runs parallel evaluations using git logs and diff metrics. Basis: Demonstrated by John Lindquist when initializing the /skill:here-now prompt at 01:45:00.
-
Try: Students are directed to build a Chaos Monkey prompt variant for their agents to stress-test custom site deployments with erratic behavior over the weekend. Basis: John mentions: 'try that this weekend sometime. Click on everything way too fast, type in way too much... trying to make it break and find where it breaks. That's a really fun prompt.'
-
Try: Configure a repository safety script that checks individual file mtime dates, calculates a 7-day cutoff boundary, and warns an autonomous agent workflow whenever a targeted workspace resource violates modification safety thresholds. Basis: Demonstrated at 01:57:00.000 where the shell agent intercepts the ls query to append a structured FILE AGE POLICY block.
Observed actions and statements
These timestamped observations retain troubleshooting detail and the limits of what was visible. Commands mentioned here are observations, not vetted installation instructions; use the topic’s prepared recipes for runnable examples.
-
01:21:23 — John Lindquist notes that Linear is highly agentic ready with its CLI.
-
01:21:57 — a participant describes Linear as Jira for AI-Native Teams.
-
01:22:18 — The presenter types and executes the directory initialisation macro 'take ~/dev/custom-zsh-functions'.
-
01:22:32 — The presenter executes the 'x' function shortcut, initiating OpenAI Codex CLI.
-
01:22:39 — The presenter exits Codex and tests the 'xr' command wrapper to open the session resumer tool.
-
01:22:51 — The presenter calls the 'clx' function to invoke the Claude Code runtime agent interface.
-
01:23:09 — The presenter tests mock inputs for various resume styles into the shell line buffer.
-
01:23:34 — The presenter triggers 'which x' to inspect the structure of the active shell configuration function wrapper.
-
01:23:52 — The presenter triggers 'which clx' to check flag formatting logic for Claude Code.
-
01:24:16 — The presenter tests 'funcwhere x' to trace the target path locations of local Zsh tools.
-
01:24:27 — The presenter inspects the internal text layout of 'funcwhere' using the standard shell built-in command.
-
01:24:43 — The presenter writes the combined terminal macro string 'zed "(funcwhere x)"' into the input row.
-
01:25:02 — John points out different definitions for resume, resume with a specific conversation, and resume the last conversation.
-
01:25:34 — John types a custom zsh command into Ghostly window to inspect function configurations for x2.
-
01:25:46 — John explains that having two parallel Codex subscriptions involves running them with custom home directories.
-
01:27:13 — John Lindquist drops the URL https://github.com/johnlindquist/claudex into the workshop chat room.
-
01:27:24 — John explains that Claudex lets you run Codex inside Claude Code via a CLI proxy API.
-
01:28:43 — John Lindquist mentions having a shortcut to spawn another tab or pane open to the side.
-
01:29:39 — John addresses a question about whether his dotfiles are published anywhere.
-
01:29:58 — John switches to Google Chrome and enters the URL github.com/johnlindquist/dotfiles.
-
01:30:08 — The browser shows an old repository named dotfiles containing Karabiner config files from 4 years ago.
-
01:30:45 — John suggests prompting AI models to benchmark and optimize ZSH profile configurations for maximum startup speed.
-
01:31:00 — John displays a list of numbered configuration files ranging from 00-path.zsh to 65-ai-agent-shortcuts.zsh.
-
01:32:10 — John states he wants to review his configuration files before publishing them publicly.
-
01:32:20 — John inputs herdr --help into the active command prompt terminal.
-
01:32:39 — John types the cmux command, generating an extensive terminal layout control output list.
-
01:33:28 — The terminal window displays an automated Claude agent update diff for index.html.
-
01:35:24 — a participant comments that John is utilizing Zed instead of ghostly features directly.
-
01:35:59 — Terminal workspace shows the file 40-alias.zsh with active terminal configuration aliases list and workspace file sidebar.
-
01:35:59 — John Lindquist discusses how integrated environments are being overtaken by natural language development, vibe coding, and agentic engineering.
-
01:36:28 — The workspace editor switches files to show the content of pi-lens.md containing file age policies and verification rules.
-
01:36:38 — a participant sends a chat message: 'How do you review the code in the terminal UIs?'
-
01:36:42 — John points out that tools like TMUX have been around forever, but agentic tools make hacking custom plugins on Herder much faster.
-
01:37:10 — John compares agentic pane generation with traditional extension testing workflows inside IDEs like VS Code.
-
01:37:34 — a participant sends a chat message: 'There’s simple-git or something that is “the best git terminal ui in the world”'
-
01:37:47 — John reads a participant's question and describes asking agents to summarize changed files and write report summaries.
-
01:38:16 — John states his high trust in the AI agent Fable and notes that he uses tests, hooks, linters, and gates to verify functionality instead of manual code reviews.
-
01:39:07 — John talks about the benefit of strictly typed compiled languages like Rust that enforce correctness under agentic workflows.
-
01:39:18 — John expects developers to transition away from TypeScript/JavaScript to options that compile to JavaScript with stricter typing like Kotlin.
-
01:39:28 — a participant sends a chat message: 'So you're essentially using AI to provide executive summaries of the code changes?'
-
01:39:33 — John talks about the future emergence of a web language optimized for agents rather than humans.
-
01:40:08 — John poses the question regarding finding or building the best Git terminal UI.
-
01:43:15 — John discusses the development history of digital artifacts, attributing the initial framework conception to the Anthropic Claude Code team.
-
01:43:39 — John explains his local keyboard configuration environment using Karabiner software keys combined with custom panel focusing parameters handled via Herder setup definitions.
-
01:43:54 — Student a participant describes an automated review-loop macro that initiates paired Opus and Codex subagents to iteratively find and resolve repository bugs.
-
01:44:50 — John initializes an interactive agent task loop inside the script-kit-gpui project folder workspace by entering the invocation query x pi.
-
01:45:00 — John passes a long-form request to the terminal via the prompt command /skill:here-now to aggregate code change metrics, identify breaking behaviors, and flag potential visual regression risks over the past week.
-
01:45:39 — John notes an automated test inquiry from the session history asking if he writes validation checkpoints or automated evaluation test suites when authoring customized agent skills.
-
01:45:54 — John highlights his past engineering contributions at Vercel developing early infrastructure implementations for the platform's terminal agent automation plugin.
-
01:46:08 — The terminal view displays multiple parallel sub-agents spinning up under the names Agent review committed weekly changes, Agent review dirty worktree changes, and Agent audit weekly visual risks.
-
01:46:52 — John explains that while Vercel could easily absorb the costs of heavy agent evaluations, doing so on a personal budget becomes prohibitively expensive.
-
01:47:24 — John details the programmatic evaluation gates built into his 'mini arcade' repository that validate traits post-game-generation.
-
01:47:52 — John shares that he is building an app for home builders via a small startup, where simple AI features will solve niche problems without requiring heavy agent swarms.
-
01:48:21 — John highlights how low-cost, highly capable models like Kimi or Kimi 3 can significantly enhance agentic workflows by serving as cheap evaluation layers.
-
01:49:05 — John introduces the Cloudflare article regarding large-scale AI code reviews.
-
01:49:34 — John discusses technical code review loops involving sub-agents (like Opus and Codex) finding errors, followed by a fixer agent resolving them iteratively.
-
01:50:02 — John recalls how expensive multi-model code reviews were in previous years using models like Claude Sonnet 3.5 or older Codex variations, comparing it to today's affordable subscription models.
-
01:51:40 — John talks about working at ClickUp and dealing with high blast radius UI changes.
-
01:51:59 — John introduces the concept of using one agent to build paths and another to turn them into scripts.
-
01:54:16 — John inputs the prompt 'serve this in my browser' into the interactive command input text entry field.
-
01:54:27 — A local Python HTTP server is spawned on port 8459, opening the page in Google Chrome at http://localhost:8459.
-
01:55:00 — John explains how image diffing pipelines let agents iterate on layouts until they match mockups with pixel-perfect accuracy.
-
01:56:34 — John opens the pi-env-demo workspace space, displaying a modal dialog overlay prompt requesting project trust confirmation.
-
01:56:42 — John selects the 'Trust (this session only)' option, allowing workspace initialization.
-
01:56:47 — John writes 'List all of our files with ls' inside the workspace agent prompt panel.
-
01:56:56 — The agent executes the terminal command ls -la and prints a FILE AGE POLICY layout configuration table.
-
01:57:15 — John highlights the injected safety rule prohibiting modification of project files older than 7 days.
-
01:57:51 — John Lindquist describes the issue of legacy project code that shouldn't be touched by automated agents without specific flags or restrictions.
-
01:58:35 — The screen shows a terminal running a custom file age policy module displaying the modification metadata of files under the pi-env-demo folder.
-
01:59:14 — John Lindquist explains that the logic for decorating shell functions lives inside the agent-shell configuration file.
-
01:59:45 — John opens file-age-policy.mjs in the editor to detail the Node.js implementation of the policy rules.
-
02:00:52 — The terminal window displays an active background agent publishing a script to a live here.now URL and verifying it with curl.
Unresolved: Exact pipe extensions configured inside the internal implementation of the custom funcwhere method.
The complete execution line wraps past the visible screen borders during standard stdout print visualization.
Discriminating evidence: Inspect the source script contents file directly in subsequent segments or repositories.
Unresolved: The explicit terminal alias used to trigger full color detailed directory listings during home directory checking.
John runs a command that lists the contents of the .codex-work folder with specific date-modified metrics, but the exact typed short-phrase command keying is partially off-screen or obscured.
Discriminating evidence: Cross-reference with full dotfiles repository configuration scripts.
Unresolved: The exact shell command used to invoke the directory viewer for the conf.d files.
The command itself is entered via an abbreviation or custom key combination without explicit standard typing visible.
Discriminating evidence: Can be inferred as a custom ls alias or tool like eza/exa based on columns shown.
Unresolved: The exact application driving the embedded terminal text editing engine interface layout.
No discrete window decoration labels are cleanly drawn on screen, despite matching text features commonly associated with Zed terminal integrations or text editors.
Discriminating evidence: Cross-reference workshop asset profiles for terminal dashboard editor plugins.
Unresolved: Herder
The tool name is pronounced as 'Herder' but could alternatively be written as 'Herdr' or similar.
Discriminating evidence: Left as 'Herder' matching the verbatim transcript interpretation.
Unresolved: Exact underlying terminal binary backing the prompt builder overlay.
The precise tool executable name isn't entered or explicitly read out during the fast execution toggle.
Discriminating evidence: Verify tool definitions in subsequent workshop shards.
Unresolved: Specific architecture specifications and installation links for the speaker's Herder tool project.
The terminal management tool is highlighted textually and verbally as a component of John's window navigation setup, but its codebase repository home is not opened or inspected.
Discriminating evidence: Examine related project files or configuration folders under the user profile summary data for additional .herder definitions.
Unresolved: The exact version designator configuration layout details at the lower margin of the active terminal window.
Text reading (opencode-codex) gpt-5.6-sol-w1 is relatively small and can be interpreted with alternative typographic spacing assumptions.
Discriminating evidence: Verify with terminal logs or source configurations for the underlying pi-lens status bar layout.
Unresolved: The accurate tool branding classification of the left sidebar agent orchestration app client.
The software frame displays workspace trees, tool durations, and agent states clearly but does not highlight an explicit application title or client banner text.
Discriminating evidence: Cross-reference with the master project architectural diagrams to determine if this dashboard interface runs as a specialized client extension of Script Kit.
Unresolved: Exact target length evaluations inside the shell loop script.
The lower sections of the function window are compact and text scaling reduces readability.
Discriminating evidence: Cross-reference with full repository source files for agent-shell.zsh.
Demonstration detail: 01:22:16
- Executed take command to open custom project environments.
- Ran custom wrappers x, xr, and clx to prove abstraction functions across various AI platforms.
- Demonstrated debugging commands via which and a unique custom utility named funcwhere.
Tools observed: Ghostty, OpenAI Codex CLI, Claude Code CLI, Zed.
Command or prompt observations (not a verified recipe):
take ~/dev/custom-zsh-functions
x
xr
clx
which x
which clx
funcwhere x
which funcwhere
zed "(funcwhere x)"
Demonstration detail: 01:25:00
- Reviewing specific shell script configuration declarations for Codex wrappers
Tools observed: Zed/Editor.
Demonstration detail: 01:25:29
- Querying terminal function composition definitions and scanning runtime isolated directories
Tools observed: Ghostly Terminal.
Command or prompt observations (not a verified recipe):
custom-zsh-functions which x2
Demonstration detail: 01:27:03
- Opening the claudex open source repository page to analyze implementation rules
Tools observed: Google Chrome Browser.
Demonstration detail: 01:28:43
- Spawning horizontal and vertical terminal panes
- Closing terminal sessions quickly using hotkeys
Tools observed: Ghostty.
Demonstration detail: 01:29:58
- Navigating to GitHub repository URL in web browser
Tools observed: Google Chrome.
Demonstration detail: 01:30:19
- Listing files in a shell configuration directory
Tools observed: Ghostty.
Demonstration detail: 01:32:20
- Executed herdr help parameters
- Executed cmux parameters to display pane automation controls
Tools observed: herdr, cmux, Ghostty.
Command or prompt observations (not a verified recipe):
herdr --help
cmux
Demonstration detail: 01:35:59
- Switched tab from 40-alias.zsh config file to view the pi-lens.md documentation file.
Tools observed: Terminal workspace code viewer.
Demonstration detail: 01:41:11
- Toggled custom TUI client framework panel.
- Typed command strings into the terminal interactive input field.
Tools observed: Ghostty.
Command or prompt observations (not a verified recipe):
/model
/permissions
Demonstration detail: 01:43:24
- Swapping active project configurations instantly inside Ghostty panels via key combinations.
Tools observed: Ghostty, Karabiner, Herder.
Demonstration detail: 01:44:50
- Initializing the agent workflow engine and launching a parallel branch documentation query.
Tools observed: pi, Git.
Command or prompt observations (not a verified recipe):
x pi
/skill:here-now Please look through all the code changes over the past week and write out a guide explaining all the changes, why they were made, the things I should definitely look into, and the things that might cause either breaking changes or visual chain deciding to investigate.
Demonstration detail: 01:46:51
- Monitoring ongoing multi-agent execution processes in the pi-lens terminal dashboard environment.
Tools observed: Script Kit.
Demonstration detail: 01:49:12
- Opening Google Chrome and scrolling down through the Cloudflare blog architecture layout.
Tools observed: Google Chrome.
Demonstration detail: 01:50:31
- Displaying an architectural blog section detailing context isolation mechanics and opencode configurations.
Tools observed: Chrome.
Demonstration detail: 01:53:34
- Switching active view to terminal windows to inspect active script tasks and agent execution metrics.
Tools observed: Ghostty, Script Kit, pi-lens.
Demonstration detail: 01:54:16
- Submitted natural language serving command via command line entry input box.
- Verified internal system shell activation.
Tools observed: Ghostty, Python.
Command or prompt observations (not a verified recipe):
python3 -m http.server 8459
Demonstration detail: 01:54:30
- Opened artifact inside Google Chrome preview window.
- Clicked through side navigation component tabs to verify active rendering logic.
Tools observed: Google Chrome.
Demonstration detail: 01:56:34
- Approved security modal folder permissions setup prompt.
- Dispatched file query via interactive text command interface prompt.
- Inspected the calculated age criteria logs in the terminal.
Tools observed: Ghostty.
Command or prompt observations (not a verified recipe):
ls -la
Demonstration detail: 01:57:51
- Executing ls -la and displaying the custom file age reporting summary in the shell pane.
Tools observed: zsh, node.
Command or prompt observations (not a verified recipe):
ls -la
Demonstration detail: 01:59:13
- Navigating and reviewing agent-shell.zsh and file-age-policy.mjs inside the IDE tool.
Tools observed: Cursor.
Demonstration detail: 02:00:50
- Monitoring automated execution logs of a Git change publication script during an announcement loop.
Tools observed: git, curl, publish.sh.
Command or prompt observations (not a verified recipe):
git status --short
publish.sh