Build with agents.
Keep your judgment.
Practical reference for building, reviewing and teaching with agents. Find the reasoning, the tradeoffs and the exact text.
Reference library
181 references
-
A trustworthy software factory loop
Bound one recurring task, name the consequential action, and earn autonomy with observable evidence.
-
Preserve contracts and state machines while code changes
Write natural-language contracts and use video as requirements; Treat code as a throwaway artifact behind a state machine + modules; Maintain living guardrails while treating generated code as disposable and ideas as durable.
-
Video as requirements playbook
Web developers already debug behavior in running apps, not just in source files. A narrated screen recording gives an agent the missing layer: what the user clicked, typed, expected, noticed, and wanted changed, then turns that into a concrete QA story and implementation brief.
-
Which principles survive better agents?
Separate enduring human judgment from workarounds for tools that have changed.
-
Which principles survive better agents? — discussion and evidence
Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
-
Which principles survive better agents? — prompts and exercises
Complete reusable prompts, setup recipes, success checks, and caveats for which principles survive better agents?.
-
Which principles survive better agents? — questions and tradeoffs
Detailed questions and tradeoffs with concrete prompts, observable outcomes, and the limits of the example.
-
Which principles survive better agents? — worked example
Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.
-
Agent foundations glossary
Definitions, operational consequences, and related vocabulary for agent-powered software development.
-
Agent-managed memory folders playbook
Web developers already run local dev servers, browser checks, and coding agents against real repos. Agent-managed memory folders give those agents a visible place to plan, track, and resume work without polluting source control or turning scratch notes into stale project documentation.
-
Compose the prompt before choosing the agent
A cross-agent composer, named launch profiles, exact argv previews, and safe handoff patterns.
-
Compose the prompt before choosing the agent — discussion and evidence
Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
Browse 169 more references
-
Compose the prompt before choosing the agent — prompts and exercises
Complete reusable prompts, setup recipes, success checks, and caveats for compose the prompt before choosing the agent.
-
Compose the prompt before choosing the agent — questions and tradeoffs
Detailed questions and tradeoffs with concrete prompts, observable outcomes, and the limits of the example.
-
Compose the prompt before choosing the agent — worked example
Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.
-
Context packing with Oracle and PackX: practical reference
Documents the oracle-packx workflow: setup and verification prompts, bounded context selection, PackX preview and bundling, Oracle CLI/MCP browser execution, optional Tailscale routing, privacy exclusions, compact evidence, session-output review,…
-
Context packing with Oracle and PackX: practice drills
Six exercises cover explicit oracle-packx invocation, evidence mapping, raw-versus-compact evidence decisions, improving vague requests, gating follow-up Oracle calls with a prior-state ledger, and inspecting the published skill's safeguards.
-
Goal, Memory, and Context Hygiene Field Guide
Keep long-running Codex work grounded with local files, compact prompts, and receipt checkpoints.
-
Images as precise task evidence
Use a marked screenshot to identify the target, a sentence to express intent, and a running-app check to prove the change.
-
Images as precise task evidence — discussion and evidence
Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
-
Images as precise task evidence — prompts and exercises
Complete reusable prompts, setup recipes, success checks, and caveats for images as precise task evidence.
-
Images as precise task evidence — questions and tradeoffs
Detailed questions and tradeoffs with concrete prompts, observable outcomes, and the limits of the example.
-
Images as precise task evidence — worked example
Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.
-
Keep agent memory visible and grounded
Create agent-managed notes/goals folders the harness can read and write; Partition context by globally gitignoring those agent-managed folders; Track progress with a live, auto-refreshing Markdown side pane as a visual checklist.
-
Oracle + PackX Handoff Field Guide
Spend Codex on implementation, not on reading 500K tokens of context.
-
Oracle handoff for a huge codebase question playbook
Working web developers routinely hit questions that are too broad for a local coding-agent thread: auth architecture, route ownership, stale data bugs, migration blast radius, or a tangled UI flow. Oracle handoff keeps Codex focused on local implementation while a browser ChatGPT Pro session reads the huge PackX bundle and returns a plan the agent can verify in the running app.
-
Pack local context for a browser review
Your local agent is good at doing work inside the repo. The harder part is deciding what work should happen next when the answer depends on a lot of project context. This pattern uses PackX to turn a project into a focused context packet, Oracle to move…
-
Recover state before continuing
Use history to locate evidence, then rebuild a minimal trustworthy handoff from the current tree and artifacts.
-
Recover state before continuing — discussion and evidence
Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
-
Repeatable video evidence processing
Evidence-preserving video follow-up workflow covering long and short recordings, project setup, segmentation, chat carry-forward, Oracle/Gemini analysis and recovery, prompt templates, verification, keyframes, Git practices, publication review, and planned…
-
Route large codebase questions through Oracle
Route huge, read-heavy codebase questions to a browser ChatGPT session instead of burning Codex quota; Bundle dense repo context with PackX and hand it off via Oracle + an MCP/browser automation bridge; Drive a plan → implement → verify loop with Oracle on a separate high-context session.
-
Turn recordings into video evidence packets
A long recording is not one prompt. It is a pile of evidence with a timeline.
-
Video analysis and evidence workflows: practical reference
Repeatable video-to-prompt workflow covering source preservation, hashing and media receipts, chunking, Oracle/Gemini analysis, timestamped evidence lanes, sentinel checks, keyframes, omissions review, privacy gates, and downstream implementation, QA, and…
-
Video analysis and evidence workflows: practice drills
Exercises for choosing video input, preserving and hashing source media, recording metadata, constructing analysis prompts and Oracle calls, separating evidence lanes, checking outputs, extracting visual evidence, reviewing omissions, and producing…
-
A reusable design.md standard playbook
Web developers already ship UI inside real repos, so a design.md gives their AI agent a concrete visual contract instead of vague taste prompts. It keeps design direction reusable while still forcing implementation decisions to come from the current codebase.
-
Bounded prompts for factory work
Six complete exercises with explicit input, expected output, and success evidence, plus the read-only audit setup.
-
Choose the next agent workflow
Provides a bottleneck-driven agent prompt and an eleven-step workflow connecting context, shell visibility, routing, composition, verified variations, evidence, delegation, council critique, and human selection.
-
Compose the first prompt before launch
The first prompt does more than start a chat. It names the work, chooses the launch path, loads useful references, and decides whether this is a fresh thread, a fork, a compacted branch, or a wrapper handoff.
-
Controlled variation workflows: practical reference
Controlled software-variation workflow covering setup-only agent prompts, single-variable matrices, baseline repository capture, isolation and fan-out, identical verification, diff and UI review, five decision outcomes, convergence, troubleshooting, and…
-
Controlled variation workflows: practice drills
Fourteen exercises covering variation suitability, single-variable matrices, run artifacts, saved prompt seeds, repository checkpoints, candidate isolation and overrides, uniform verification, comparison, selection, convergence, failure recovery, and final…
-
Design, Video, and QA Story Field Guide
Convert taste, screenshots, narrated videos, and weird user behavior into Codex-ready implementation stories.
-
Generate controlled, verified variations
When code and design candidates are cheap, the mistake is not generating too many. The mistake is generating them randomly. Start by defining the candidates, keep the comparison controlled, run each option through the same constraints, and review the…
-
Generate to diverge, code to converge
Keep the subject fixed while exploring structural alternatives, then turn the selected bitmap into verified code.
-
Generate to diverge, code to converge — discussion and evidence
Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
-
Generate to diverge, code to converge — prompts and exercises
Complete reusable prompts, setup recipes, success checks, and caveats for generate to diverge, code to converge.
-
Generate to diverge, code to converge — questions and tradeoffs
Detailed questions and tradeoffs with concrete prompts, observable outcomes, and the limits of the example.
-
Generate to diverge, code to converge — reference patterns
Extended explanations, comparisons, experiments, and practical actions for the same operating pattern.
-
Generate to diverge, code to converge — worked example
Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.
-
Keep notes private and goals verifiable
Agent-heavy work creates a lot of half-formed context: dictated notes, failed prompts, benchmark ideas, security worries, skill candidates, and "try this later" scraps.
-
Prompt Builder composition and handoff: practical reference
Prompt Builder setup and reference covering installation and binary identity, interactive and stdin composition, launch inspection, named Codex threads, safe final-argument handoffs, fork/compact wrappers, composer controls, file and skill lookup, slash…
-
Prompt Builder composition and handoff: practice drills
Sixteen exercises cover Prompt Builder identity and installation, prompt/command/JSON inspection, stdin composition, named threads, argument-safe handoffs, zsh wrappers, file and skill selection, launch toggles, binary overrides, debugging,…
-
Throwaway route variants playbook
Web developers often need to compare UI directions in the real app, against real routing, styling, auth, responsive behavior, and browser state. Throwaway route variants give an AI agent a concrete way to generate options quickly, prove them in localhost, promote one winner, and remove the experimental surface before it becomes maintenance debt.
-
Trust current source and capture design decisions
Tell the difference between basic memory and dangerous stale memory; Treat code as the source of truth with million-token snapshot contexts; Capture a design.md standard and generate multi-route structural variants.
-
Turn preference into reusable decisions
Pairwise comparisons, honest rejection, recorded axes, and durable taste rules instead of vague adjectives.
-
Turn preference into reusable decisions — prompts and exercises
Complete reusable prompts, setup recipes, success checks, and caveats for turn preference into reusable decisions.
-
Turn preference into reusable decisions — questions and tradeoffs
Detailed questions and tradeoffs with concrete prompts, observable outcomes, and the limits of the example.
-
Turn preference into reusable decisions — worked example
Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.
-
Automate lifecycle work with hooks
A hook is not a better prompt. It is a lifecycle checkpoint. Use it when the behavior should happen whether or not the model remembers.
-
Build hyper-specific workspace agents
The fastest useful agent is usually not the biggest one. Wrap the tools you already trust, preload only the context the job needs, and keep broad agents out of small repeated tasks.
-
Build narrow daemons and inspectable agent graphs
Run focused background daemons that update a human-readable HTML dashboard; Use low-reasoning iteration with a deliberately small-context strategy; Coordinate SDK multi-agent graphs with a multimodal verification loop.
-
CMUX Orchestration Field Guide
Use panes, browser tabs, and a manager agent without letting workers step on each other.
-
Codex Daemon Profile Field Guide
Turn repeated web-dev chores into narrow, cheap, low-context Codex workers.
-
Combine intent, implementation, and output for autonomous work
Bundle the context triad — intent, implementation, and live output — for diagnosis; Run specialized Codex daemons as overnight emulated crons; Coordinate agents through natural-language loose coupling.
-
Command a CMUX manager/worker layout playbook
Web developers already juggle dev servers, test runners, browser verification, and agent chats; this pattern turns that chaos into one visible Manager pane coordinating narrow worker panes. It matters most when a local app needs code changes plus runtime proof, because the Manager can inspect panes, send targeted tasks, read worker output, and keep the human focused on decisions instead of pane babysitting.
-
Control agent lifecycle with hooks and context hygiene
Manage context with compaction and conversation forking; Wire user-prompt, tool-use, and stop hooks into your workflow; Choose between skills and plugins and run a Ralph loop.
-
Coordinate agents with a manager and worker panes
Adopt an agent-first mindset and the manager-worker topology; Drive CMUX terminal layouts with natural language; Set up AFK automation loops that keep working while you don't.
-
Install and inspect dash-prefix Imp routing
Installation and trust-boundary guidance for foreground and forked Imp routing, including helper contracts, hook registration, verification prompts, cmux inspection commands, and troubleshooting.
-
Isolated Codex daemon profile playbook
Web developers constantly repeat narrow CLI work around local dev servers, deploy previews, browser QA, GitHub checks, and framework tooling. An isolated Codex daemon profile turns one repetitive tool workflow into a cheap, warm, low-context helper instead of dragging a full general agent through every small task.
-
Keep parallel agent work visible and bounded
A parallel workspace is not useful because it looks busy. It is useful when each lane has a job, a boundary, a check, and a visible trail. Start by planning the split. Then open the workspace that makes that split easy to supervise.
-
Markdown flows as a repeatable control surface
Preload fresh evidence, declare capabilities, isolate ambient context, and improve prompts through explicit proposals.
-
Markdown flows as a repeatable control surface — discussion and evidence
Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
-
Markdown flows as a repeatable control surface — prompts and exercises
Complete reusable prompts, setup recipes, success checks, and caveats for markdown flows as a repeatable control surface.
-
Markdown flows as a repeatable control surface — questions and tradeoffs
Detailed questions and tradeoffs with concrete prompts, observable outcomes, and the limits of the example.
-
Markdown flows as a repeatable control surface — reference patterns
Extended explanations, comparisons, experiments, and practical actions for the same operating pattern.
-
Markdown flows as a repeatable control surface — worked example
Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.
-
Narrow Imp agents and routing: practical reference
Comprehensive Imp reference covering setup and verification, narrow-agent boundaries, command modes, router and compound routing, foreground/forked dash hooks, cmux inspection, fleet and warm-session management, runtime isolation, prompt templates, bounded…
-
Narrow Imp agents and routing: practice drills
Exercises covering Codex-versus-Imp selection, health checks, routing and execution modes, dash-prefix hooks, bounded marker packets, fleet management, evolution review, narrow Imp design, failure recovery, tests, and final handoff receipts.
-
Overnight emulated-cron loop playbook
Web developers often need long-running investigation without a real scheduler: flaky auth, broken localhost flows, intermittent console errors, or UI drift that only appears after repeated checks. This pattern gives an agent a bounded timestamp loop, runtime evidence, and a hard stop so overnight work produces receipts instead of vague claims.
-
Policy at the agent’s execution boundary
Project-specific shells, session-scoped guidance, Codex airlocks, and Claude hooks—with their bypass limits.
-
Policy at the agent’s execution boundary — discussion and evidence
Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
-
Policy at the agent’s execution boundary — prompts and exercises
Complete reusable prompts, setup recipes, success checks, and caveats for policy at the agent’s execution boundary.
-
Policy at the agent’s execution boundary — questions and tradeoffs
Detailed questions and tradeoffs with concrete prompts, observable outcomes, and the limits of the example.
-
Policy at the agent’s execution boundary — reference patterns
Extended explanations, comparisons, experiments, and practical actions for the same operating pattern.
-
Policy at the agent’s execution boundary — worked example
Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.
-
Ralph Loop stop-hook continuation playbook
Web developers already run agents against real repos, dev servers, browser panes, and local QA loops; the Ralph Loop helps those agents keep working toward a bounded goal instead of stopping after one polite assistant turn. It is especially useful for web tasks where success is observable only after code, tests, logs, and browser behavior line up.
-
Reusable flow and skill recipes
Complete small contracts for code review, onboarding, test repair, changelogs, PR descriptions, pane-aware standups, and preference capture.
-
Workspace and session routing: practical reference
Practical cmux/tmux orchestration reference with an agent setup prompt, workspace/pane/surface/session routing model, focused Codex fork and compact workflows, transcript exports, zsh helper integration, multi-agent layouts and gated chains, verification…
-
Workspace and session routing: practice drills
Nine exercises establish workspace-to-session routing and receipts using cmux identity, explicit handles, workspace focus, environment inspection, helper panes, focused Codex fork previews, transcript exports, layered debugging, and gated agent_chain phases.
-
5 Monkeys QA swarm playbook
Web developers already trust tests for known requirements, but fast-moving UI work also needs cheap exploratory passes that click through real app state. This technique gives local agents a practical browser-facing QA job: find weird UX and state bugs before users do.
-
A trustworthy software factory loop — discussion and evidence
Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
-
Advanced consult, image, and video contracts
Transferable contracts from the published Oracle resource family: premise coverage, bounded escalation, attachment proof, multimodal continuity, and honest completion.
-
Agent Markers debugging workflows: practical reference
Browser-debugging reference covering the agent-markers setup prompt, perspective-based exploratory QA, bounded event capture and marker schemas, browser/global APIs, privacy and cleanup, JSON and test-artifact exports, replay capsules, app-specific…
-
Agent Markers debugging workflows: practice drills
Exercises for marking browser failures, initializing Agent Markers, exporting bounded evidence, reviewing privacy, attaching exports to tests, verifying projects, writing debug prompts, designing replay capsules and app-specific shortcuts, recovering from…
-
Artifact evidence is not the same as success
Separate observed creation, command execution, visible output, and verified completion; preserve failures and the exact next check.
-
Browser Proof Field Guide
Make Codex prove rendered web behavior with routes, actions, logs, screenshots, and receipts.
-
Explore software through perspectives and runtime QA
Use perspective-based prompting and discardable QA files for non-obvious user paths; Apply the 5 Monkeys technique and use CMUX state for context-aware shortcuts; Extract implementation intent from narrated screen recordings into Gemini.
-
Fusion council decisions and evidence: practical reference
Local multi-model council reference covering skill and CLI setup, provider diversity and preflight, durable prompts, dry runs, terminal-state and artifact checks, degraded-provider recovery, privacy, and reconciliation with repo evidence before…
-
Fusion council decisions and evidence: practice drills
Exercises for deciding when a model council helps, framing bounded decisions, invoking Fusion, validating providers and completion artifacts, reconciling disagreement, handling failures, and defining a verified first implementation slice.
-
Human testimony joined to runtime evidence
Capture the moment of surprise with a bounded redacted trail and discriminate between hypotheses before changing code.
-
Human testimony joined to runtime evidence — prompts and exercises
Complete reusable prompts, setup recipes, success checks, and caveats for human testimony joined to runtime evidence.
-
Human testimony joined to runtime evidence — questions and tradeoffs
Detailed questions and tradeoffs with concrete prompts, observable outcomes, and the limits of the example.
-
Human testimony joined to runtime evidence — worked example
Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.
-
Independent reasoning and video evidence
Escalate consequential decisions with filtered context and use probes, sentinels, and bounded video analysis.
-
Independent reasoning and video evidence — discussion and evidence
Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
-
Independent reasoning and video evidence — prompts and exercises
Complete reusable prompts, setup recipes, success checks, and caveats for independent reasoning and video evidence.
-
Independent reasoning and video evidence — questions and tradeoffs
Detailed questions and tradeoffs with concrete prompts, observable outcomes, and the limits of the example.
-
Independent reasoning and video evidence — reference patterns
Extended explanations, comparisons, experiments, and practical actions for the same operating pattern.
-
Independent reasoning and video evidence — worked example
Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.
-
Make the repository agent-ready
A background workflow is only useful when the agent can prove what it changed. Start by giving the repo a verification loop. Then move repeated, narrow jobs into tiny tool-shaped agents that carry only the context they need.
-
Mark the debug moment before handoff
Logs show what happened. A marker says which moment mattered.
-
Review generated UI before building
A generated mockup is useful when it gives you something concrete to inspect. Do not jump from one polished image to implementation. Keep the source visual, choose a controlled style direction, generate against that direction, review the result, then hand…
-
Self-improving log-gated fix loop playbook
Web developers already run local dev servers, browser checks, test scripts, and agent panes; this technique turns those runtime artifacts into proof instead of vibes. It matters because UI bugs, auth regressions, and hook failures are often only obvious in logs, browser state, or terminal output, not in the agent's final message.
-
Use a model council for hard decisions
A single model can give a clean answer and still miss the important edge. Use a model council when the cost of a missed perspective is higher than the cost of waiting.
-
Verify fixes with deterministic evidence and narrow boundaries
Extract terminal pane text in CMUX as machine-readable context; Build self-improvement error loops behind log-based deterministic gates; Define natural-language contract boundaries and prune context.
-
Video analysis recipes, prompts, and evidence gates
Complete media-normalization commands, long/short analysis branches, omission and reconciliation prompts, keyframe procedures, and publication evidence gates.
-
Agent conversation search (cs)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Agent foundations resource index
Public tools, command references, design resources, and contextual links grouped for practical use.
-
Agent skills: authoring & distribution (skills CLI)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Agent-safe shell startup file examples
Complete example startup files, PATH assembly, safe local overrides, environment-marker configuration, and startup checks, with explicit gaps and installation boundaries.
-
AI context bundlers (repo → prompt)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Browser automation for agents (Oracle, agent-browser)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Choose tools by the job, not the presenter’s stack
Compare the capability you need, preserve uncertain product claims, and substitute tools without changing the operating pattern.
-
Codex Primitive Field Guide
AGENTS.md, skills, plugins, hooks, MCP, and Goal mode without mixing the layers.
-
Fusion panel execution runbook
Published Fusion skill defining direct CLI usage, provider preflight, full-panel blocking execution, terminal-state monitoring, degraded/quota-limited provider handling, artifact review, and repo-grounded final decisions. Includes preset/custom-config…
-
Image generation for design variations
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Image-to-design handoff playbook
Web developers already live in running apps, local dev servers, screenshots, and browser proof. This pack turns the taught image-to-design handoff into concrete flows where a selected reference image guides the code diff and the browser proves the result.
-
Imp routing hook and cmux helper examples
Complete dash-prefix routing template, hook registration, cmux pane dispatch helper, and session-registry lookup example, with trust, logging, timeout, and incomplete-implementation boundaries.
-
Instant web publishing for agents (here.now)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Just-in-time state capture (markers)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Keyboard customization (Karabiner-Elements)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Markdown agent flows (mdflow)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Navigate the agent-safe shell file set
Explains the zsh environment and helper files, non-interactive-shell safety practices, and commands for checking tool paths and helper availability.
-
Oracle and PackX execution runbook
Published browser-only Packx→Oracle skill covering model settings, bundle preparation and validation, compact evidence and attachments, progress-gated follow-ups, blocking session recovery, full-response reading, implementation summaries, optional…
-
Oracle video analysis runbook
Published Gemini-through-Oracle video-analysis skill covering video discovery and filtering, short- and long-recording workflows, media receipts, reproducible prompts, browser upload commands, readiness probes, blocking execution and recovery, artifact…
-
Packx command and filtering reference
Full context-bundling reference: discovery rules, glob traps, token budgets, output formats, filters, and operational caveats.
-
PackX commands, filters, and bundle recipes
Packx context-bundling reference covering discovery and filtering, default exclusions and file types, glob and external-directory pitfalls, token notation, positional arguments, complete flag tables, filter selection, size-management progression,…
-
Packx discovery, processing, and output semantics
Full context-bundling reference: discovery rules, glob traps, token budgets, output formats, filters, and operational caveats.
-
PackX discovery, processing, and token mechanics
Packx technical reference covering discovery and filtering, glob behavior, token budgets and counting, import and related-file expansion, comment stripping, context windows, Git modes, output formats, caching, bundles, interactive controls, watch mode,…
-
Preference capture / personal RLHF (this-or-that)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Prompt composing (prompt-builder)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Reliable non-interactive shell environments: practical reference
Step-by-step agent setup prompt and troubleshooting reference for non-interactive zsh startup, ZDOTDIR, deterministic PATH, safe environment bootstrapping, opt-in helper loading, Codex launch wrappers and configuration, executable fallbacks, targeted…
-
Reliable non-interactive shell environments: practice drills
Six exercises diagnose missing tools through non-interactive zsh startup, environment markers, PATH ordering, a bootstrap recheck, configuration placement, and function-versus-executable classification.
-
Resource access and tool directory
Catalogs public tools and documentation, bundled skills, shell helpers, command contracts, hook examples, evidence workflows, and unresolved setup topics.
-
Resources shared in the software-factory discussion
Direct public links with their intended role, including source repositories, visual tools, context search, and research artifacts.
-
Screenshot capture & annotation (CleanShot X)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Secrets for unsupervised agents (1Password op)
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Shell functions, aliases, and executable boundaries: practical reference
Zsh helper diagnosis and agent integration reference covering a ten-step setup prompt, command classification, alias/function/executable design, interactive versus login-shell loading, argument-safe handoffs, executable wrappers, source guards, helper…
-
Shell functions, aliases, and executable boundaries: practice drills
Eight exercises classify commands, inspect helper definitions and sources, practice discoverability tools, choose aliases/functions/executables, preserve arguments across zsh handoffs, build a webhook replay wrapper, and map orchestration responsibilities.
-
Shell helper implementations and dependency boundaries
Complete zsh helper examples for Codex launch, Prompt Builder handoff, function discovery, Fusion-first fixes, visible orchestration, and process cleanup; unavailable helper implementations are identified.
-
Terminal coding agents
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Terminal emulators
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Terminal workspace / agent multiplexers
Tool roles, alternatives, selection tradeoffs, and compatibility caveats.
-
Thin zsh launchers and composable command families
Wrap repeated flags, isolate account credentials, compose session helpers, and make launch behavior inspectable.
-
Thin zsh launchers and composable command families — prompts and exercises
Complete reusable prompts, setup recipes, success checks, and caveats for thin zsh launchers and composable command families.
-
Thin zsh launchers and composable command families — questions and tradeoffs
Detailed questions and tradeoffs with concrete prompts, observable outcomes, and the limits of the example.
-
Thin zsh launchers and composable command families — reference patterns
Extended explanations, comparisons, experiments, and practical actions for the same operating pattern.
-
Thin zsh launchers and composable command families — worked example
Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.
-
Use images, video, and task-shaped model routing
Run CMUX as a primary orchestrator with token-efficient flash models; Use image generation as a design reference and hand off image-to-design; Prompt with video and navigate the MCP-vs-CLI boundary.
-
Web Choices server and submission runbook
Oracle-generated strict JSON choices served through a skill-local Svelte/mdsvex app, with Tailscale Funnel, persistent drafts/submissions, blocking wait-and-resume, verification, and recovery safeguards.
-
Agent Markers debugging workflows: team walkthrough
Marker-centered debugging using createAgentMarkers, browser-global marking and export, nearby-event association, privacy boundaries, cleanup, and project verification. Preserves the bounded debug-packet model, downstream work-unit bridge, failure recovery,…
-
Context packing with Oracle and PackX: team walkthrough
Skill-backed context packing and Oracle review: scope and evidence selection, preview and bundling, compact evidence, follow-up state tracking, CLAUDE.md exclusion, saved-log inspection, and locally authored project artifacts.
-
Controlled variation workflows: team walkthrough
Controlled software variations using one variable, a shared prompt seed, isolated candidates, common verification, comparison records, and explicit Pick/Combine/Refine/Expand/Reject decisions, including billing-webhook examples and convergence failure…
-
Fusion council decisions and evidence: team walkthrough
Decision-focused multi-model council workflow: frame a billing-webhook tradeoff, write a prompt file, inspect providers, dry-run, execute the configured panel, and review final artifacts, disagreement, and verification before acting. Distinguishes local…
-
Interview for judgment and build for agency
Agent-heavy work eventually comes back to the human side of software practice.
-
Narrow Imp agents and routing: team walkthrough
Bounded one-tool agent workflow covering routing, direct execution, foreground versus forked dash-prefix prompts, fleet health, warm-mode recovery, isolation, command evidence, and marker-packet handoff. Includes cmux inspection commands, fallback receipt…
-
Product vision and earned automation
Keep product direction durable without freezing implementation, and promote recurring reviews only when their signal earns it.
-
Product vision and earned automation — discussion and evidence
Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
-
Prompt Builder composition and handoff: team walkthrough
Prompt composition and launch inspection through prompt text, shell commands, and JSON; named app-server threads; final-argv handoff; interactive composer controls; zsh helper bridges; and installation, binary-selection, and quoting diagnostics.
-
Questions, answers, and unresolved decisions
The complete anonymized question reference, preserving answered, partial, deferred, unlinked, and unanswered status.
-
Reliable non-interactive shell environments: team walkthrough
Diagnosing agent tool visibility through non-interactive login-shell startup, agent-safe PATH configuration, executable precedence, clean-shell checks, and separation of interactive helpers from executable setup.
-
Shell functions, aliases, and executable boundaries: team walkthrough
Shell command classification, alias/function/executable tradeoffs, helper discovery and source lookup, interactive inspection versus login-shell handoff, workflow helper families, and executable fallbacks for scripts and CI.
-
Turn generated choices into saved human decisions
A chat thread is fine for discussion. It is a bad place to approve a shortlist, reject two options, add per-option notes, and hand the result back to an agent as durable state.
-
Video analysis and evidence workflows: team walkthrough
Evidence-preserving video analysis workflow: preserve and hash media, inspect with ffprobe, prompt Gemini through Oracle browser mode, check session output, separate evidence lanes, and produce downstream prompts, requirements, bugs, QA, or variation…
-
Visible workspaces for agents and swarms
Expose pane state, separate execution from verification, and supervise bounded independent work.
-
Visible workspaces for agents and swarms — discussion and evidence
Detailed companion accounts of concepts, questions, demonstrations, exercises, and unresolved observations.
-
Visible workspaces for agents and swarms — prompts and exercises
Complete reusable prompts, setup recipes, success checks, and caveats for visible workspaces for agents and swarms.
-
Visible workspaces for agents and swarms — questions and tradeoffs
Detailed questions and tradeoffs with concrete prompts, observable outcomes, and the limits of the example.
-
Visible workspaces for agents and swarms — reference patterns
Extended explanations, comparisons, experiments, and practical actions for the same operating pattern.
-
Visible workspaces for agents and swarms — worked example
Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.
-
Web Choices review and persistence: practical reference
Human-in-the-loop choice workflow using the skill-local web app, optional Oracle-generated JSON, a tmux-hosted server, local and Funnel API checks, phone review, and saved submissions as durable decision state. Includes setup commands, prompts, job…
-
Workspace and session routing: team walkthrough
Focused workspace/pane/surface/session routing, registry-based Codex forks, routing preflight, durable transcript exports, helper visibility, and diagnostic paths for invalid workspace handles, wrong sessions, and missing exports.
No references match yet.
Try fewer words or choose another subject.