Codex Power User Workshop
Build agent workflows you can verify
Fourteen practical moves for packing context, shaping work, reviewing generated options, capturing browser evidence, and keeping human judgment in control.

Portable Files
Download the workshop resource bundle
The bundle is a small Git repository containing the resource map, section files, bundled skills, zsh snippets, and hook examples. Download it first, then clone the local file with Git.
curl -fL -o codex-power-user-workshop-2026-06-27.bundle https://lapis-fossil-vsbc.here.now/downloads/codex-power-user-workshop-2026-06-27.bundle git clone codex-power-user-workshop-2026-06-27.bundle codex-power-user-workshop-2026-06-27Resource Map
Pick the workflow you need now
Use the cards to move between patterns. Read in sequence for the full workflow, or jump directly to the pattern that matches the current project task.
The Browser Bridge: Pack Local Context, Ask A Browser Review Pass
Use the local agent for files, commands, edits, and verification. Use the browser bridge for a separate planning or review pass.
Rewatch this part: 0:04:30–0:30:00 in the recordingIn this section The Role SplitPack DeliberatelyUse A Real Browser SessionVerify Before Trusting

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 that packet into a signed-in browser session, and a local Codex session to turn the result back into edits, checks, and follow-up work.
It's so worth getting set up, like, it's worth sacrificing a day or two to get this locked in. So that you unlock, like, the next level of intelligence, and allow your local models to be more of workers than researchers or thinkers or reasoners.
— From the workshop, around 0:29
The Role Split
- Local Codex is the worker: it inspects files, edits code, runs commands, and saves the outcome.
- PackX prepares the context packet: it selects the project files, references, and setup material that matter for the question.
- Oracle is the bridge: it carries the packed request into a browser session and brings the answer back.
- The browser model is the planner, reviewer, or external critique pass: it handles a separate review lane.
- The local loop owns the result: prompts, answers, verification commands, changed files, and unresolved questions should land back in the repo.
Pack Deliberately
The useful part is not "send everything." The useful part is choosing the files that make the question answerable while leaving out unrelated output, secrets, logs, cookies, generated directories, and private local config.
Use the bundled Oracle PackX skill when the question needs broad project context and a separate browser review pass. Keep exact flags and browser-mode call shapes in the reviewed skill. Use this mental model:
project files + references + skill docs
-> PackX bundle
-> Oracle browser session
-> answer returned to local Codex
-> edits, checks, and saved follow-up
Use A Real Browser Session
The browser bridge depends on a signed-in browser session. That browser can run in the same environment as the repo, or in a separate VM, container, or remote environment so the local development loop stays usable while the browser lane runs.
I know this sounds like a very complicated setup, and it probably will take, take a while for you to figure out exactly how this would work for you and whatever system you have. But the payoff for it is immense.
— From the workshop, around 0:29
Keep this boundary boring and explicit:
- Do not share browser history, account sidebars, profile menus, cookies, tokens, private endpoints, hostnames, ports, or local usernames.
- Do not make a private account setup look like a public requirement.
- Do not promise a specific model name, price, quota, or plan behavior unless it has been checked immediately before sharing setup guidance.
Verify Before Trusting
Check the current package name, install command, browser session, hosted links, and model labels before relying on saved setup notes.
Before sharing exact install guidance, save a dated package-name check:
npm view packx name version bin dist-tags --json
Use the dated check to confirm the package name, binary names, and current version. Do not reuse install commands from old notes without checking them.
What To Save
Save enough context that the decision can be checked later:
- bundle path
- prompt
- browser/model route used
- answer
- verification command
- files changed because of the answer
- unresolved claims or follow-ups
No saved check, no claim.
Make The Repo Agent-Ready, Then Shrink The Agent
Shrink the agent job by giving the repo observable done states, narrow tools, and clear boundaries.
Rewatch this part: 0:30:00–1:00:00 in the recordingIn this section Budget The IntelligenceUse Goals For Long WorkMake Done ObservableKeep The Terminal Thread Small

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.
Budget The Intelligence
The point is not to throw every task at the biggest possible context window. Decide where broad planning belongs, then keep the local work loop focused on files, commands, checks, and saved decisions.
Use Goals For Long Work
Long-running work needs a plan that can survive time away from the keyboard. Ask for the full step list first, then plan each step before implementation. The local agent should execute one step, verify it, and leave enough context for the next step to make sense.
Make Done Observable
An agent-ready repo lets an agent read the code, write the change, and verify the result. If the app lacks browser-style debugging, logs, snapshots, smoke tests, performance hooks, or a reliable local command, build the feedback loop before trusting automation.
The agent needs to be able to read the code, write the code, and verify the code.
— From the workshop, around 0:40
Keep The Terminal Thread Small
Custom terminal workflows matter because the agent needs a reliable surface for invoking repeatable project actions. Keep detailed zsh, shortcut, and orchestration setup in tool-specific docs until the commands are verified.
Use Imps For Narrow Jobs
An imp is a small, tool-shaped agent for a repeated job. It should know the exact tool, examples, files, and conventions it needs. It should not carry every skill, memory, search tool, and integration by default.
You give it as much context as you want, so that it's as smart as you need it, like, out of the gate.
— From the workshop, around 0:56
Strip The Extras
A narrow imp can turn off broad features until the task actually needs them. That keeps the context window pointed at the job instead of at the whole operating system.
Do Not Improvise Secrets
Credential and token isolation is a security design item, not a copy-paste recipe. Keep account state, vault layout, token names, subscription details, local storage, and private setup notes out of public instructions until they have been reviewed deliberately.
Create Hyper-Specific Workspace Agents
Start from a real CLI, API, or project habit, then preload only the context needed for that narrow job.
Rewatch this part: 1:00:00–1:22:24 in the recordingIn this section Start With The ToolPreload The Right ContextKeep The Agent NarrowPrefer Tools With CLIs Or APIs

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.
Start With The Tool
Build the agent around one CLI, API, repo, or repeatable workflow. A narrow helper should have a clear job before it gets a clever personality.
Preload The Right Context
Static prompt context works for stable jobs. Dynamic context works when the helper needs to load files, docs, API data, or a project-specific bundle before answering.
This is about as instant as I've ever seen an AI respond to anything, because it just has that context preloaded in.
— From the workshop, around 1:00
Keep The Agent Narrow
If the task needs web research, product judgment, or multi-system reasoning, send it back to a general agent or a heavier planning workflow. The narrow agent should stay boring, quick, and predictable.
I don't want them to reason or think about things. I want them to know exact file paths, exact examples, and then maybe some basic file editing, but not too much more than that.
— From the workshop, around 1:16
Prefer Tools With CLIs Or APIs
Command-line and API surfaces give the agent something concrete to inspect, execute, and verify. They also make it easier to turn a vague repeat task into a small wrapper with reliable inputs and outputs.
Treat Account Permissions As Setup
OAuth screens, account state, credential storage, scopes, and admin permissions are setup concerns. They should be checked deliberately and kept out of shared examples unless they are sanitized and current.
Make Self-Improvement Reviewable
Store suggested changes, inspect them, and apply them deliberately. A self-improving helper is only useful if its changes are reviewable and reversible.
Prove Generated Helpers
A newly generated imp is draft tooling until the source, link/install behavior, and smoke tests check out. Do not share the generated helper as a setup path until it can answer one harmless query and show the command evidence.
Generate Variations Before You Trust One Answer
Use a candidate matrix and vary one dimension at a time before implementation starts.
Rewatch this part: 1:37:00–2:05:00 in the recordingIn this section Start With A Candidate ListVary One Thing At A TimeUse The Same Base PromptFan Out After The Matrix Is Clear

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 outputs on a surface that makes the decision obvious enough to defend later.
Start With A Candidate List
Ask the agent to generate the dataset first: styles, strategies, prompts, layouts, implementation approaches, or test boundaries. Remove duplicates, rename vague entries, and make sure each candidate is different for a reason.
To do variations, like, you come up with the variations first.
— From the workshop, around 1:59
Vary One Thing At A Time
If every candidate changes layout, data model, tests, and copy, you are no longer comparing candidates. You are just admiring chaos with a folder structure.
Use The Same Base Prompt
Candidate prompts should differ only by the named variable. Keep the base prompt, constraints, review criteria, and verification command identical.
Fan Out After The Matrix Is Clear
Parallelization is useful after you know what each lane is supposed to test. Treat the candidate list like data: each lane gets a candidate id, one variable setting, and the same proof requirement.
I definitely wouldn't rely on setting a long loop… Because then you get into, like, after a while, compaction and other things where you lose that context and things start to look alike.
— From the workshop, around 2:00
Preserve The Review Surface
For UI work, use screenshots or a gallery. For code, use diffs, test logs, and a short comparison table. Save the artifacts before choosing so the decision does not disappear into memory.
Pick, Combine, Refine, Expand, Or Reject
Those are the valid outcomes. Choose one explicitly. If two candidates each have one strong idea, combine the named pieces. If the whole batch is wrong, reject the batch and update the matrix.
Turn The Winner Into A Real Build
A generated mockup is direction, not shipped UI. Use the selected candidate as the reference for a verified implementation pass. The next prompt should say what won, why it won, what to preserve, what to fix, and what proof counts as done.
Copyable Prompt: Candidate Matrix
Create a variation matrix for a software UI concept.
Goal:
Design a mobile app screen for browsing saved listings.
Variable under test:
Visual layout direction.
Generate 8 candidate directions.
For each candidate, include:
- id
- layout direction
- design constraints
- what should stay identical
- what would make this candidate fail review
Do not generate the UI yet.
Return the candidate matrix first.
Copyable Prompt: Refine The Winner
Continue from this saved variation decision.
Outcome:
Refine.
Primary candidate:
v2.
Why:
It best preserves the constraints and passes the review criteria.
Preserve:
- the selected layout structure
- the interaction model
- the accepted visual hierarchy
Fix:
- tighten spacing on mobile
- improve empty-state copy
- keep the same data model
Verification:
Run the same verification command from the matrix and save the result.
Do not reopen the candidate search.
Review Generated UI Before You Build It
Treat generated images as review evidence, not finished UI. Preserve the useful direction and reject the impossible parts.
Rewatch this part: 2:05:00–2:35:00 in the recordingIn this section Start From A Real VisualName The Style Before GeneratingGenerate Against One DirectionReview The Image As Evidence

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 the chosen direction to a build pass with explicit constraints.
Start From A Real Visual
Use an existing screenshot, mockup, or product frame as the anchor. The agent should know what it is changing instead of inventing the whole interface from scratch.
For product work, this could be a checkout screen, a settings panel, a saved listings card, or a dashboard slice. The point is to keep the job of the screen stable while the visual direction changes.
Name The Style Before Generating
Ask for a numbered list of style directions first. Then refer to the style by number in the next prompt. That gives the agent a stable design target instead of asking it to invent the language at the same time it generates the mockup.
As long as you have that list ahead of time. So that, just in time, it doesn't have to come up with new ideas. You'll have much better results.
— From the workshop, around 2:08
Generate Against One Direction
Use the selected style as the variable. Keep the screen purpose, product type, data model, and interaction intent stable.
If the source is a saved listings mobile screen, the generated version should still help someone scan saved listings. The typography, surface treatment, spacing rhythm, or color system can change. The task should not quietly become a different product.
Review The Image As Evidence
Treat the generated image as review material, not finished UI. Check what changed, what survived, what broke, and whether the result is still reasonable to build.
Review against:
- Did the screen keep the same job?
- Did the primary action stay obvious?
- Did the content survive the style change?
- Is the spacing intentional or just empty?
- Would this be reasonable to implement?
- What should the build pass preserve?
- What should the build pass reject?
Hand Off To A Build Pass
The next step is not more wandering. Tell the agent what won, why it won, what to preserve, what to fix, and what proof counts.
Use the selected generated mockup as the visual reference.
Build a real implementation of this direction.
Preserve:
- the accepted layout structure
- the visual hierarchy
- the selected spacing rhythm
- the core interaction model
Fix:
- unreadable text
- impractical spacing
- missing accessibility states
- inconsistent component behavior
Verification:
- run the project checks
- capture desktop and mobile screenshots
- compare the result against the selected mockup
- list any visual mismatches that remain
Do not restart the visual exploration.
Copyable Prompt: Controlled Visual Variation
Use the provided UI screenshot as the source visual.
Goal:
Create a new visual direction for the same mobile screen.
Style direction:
Use style 6 from the saved style list.
Keep unchanged:
- screen purpose
- information hierarchy
- primary user action
- core data shown on the card
- mobile-first layout
Change only:
- visual style
- spacing rhythm
- typography feel
- surface treatment
Return:
- one generated mockup
- a short review of what changed
- what must be preserved in a real implementation
Branch Useful Context
When a design conversation starts working, name it and fork it before trying a risky direction. A fork is a saved branch of useful context. Use it for experiments you may abandon. Do not depend on throwaway side chats for work you might need later.
A side chat in an ephemeral fork. I'm not a fan of those. I don't like ephemeral things with agents. I never want to lose anything.
— From the workshop, around 2:19
Carry Forward: Workspace Layouts
This workflow creates repeated surfaces: source visuals, style lists, generated variants, review notes, implementation passes, and screenshots. Workspace layout matters once the build pass begins: keep the accepted visual direction, implementation files, and verification screenshots easy to compare.
Run Parallel Agents Where You Can Still See Them
Split work by responsibility and file boundary, not by vague vibes. Keep a manager thread in charge.
Rewatch this part: 2:35:00–2:53:03 in the recordingIn this section Start Fresh For The TaskSplit By Boundaries, Not By VibesKeep The Agents VisibleUse A Manager Thread

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.
Start Fresh For The Task
Do not begin by hunting for the perfect saved layout. Begin with the current phase of work: what needs design, what needs implementation, what needs verification, and what can safely happen at the same time.
A dashboard task, a migration, a game level, and a new project do not need the same shape. Ask for the split that fits the task in front of you.
For a dashboard:
- one lane designs the data cards
- one lane checks API shape and sample data
- one lane writes component tests
- one lane reviews empty, loading, and error states
For a migration:
- one lane maps the source schema
- one lane maps the destination schema
- one lane writes verification queries
- one lane drafts rollback notes
Split By Boundaries, Not By Vibes
Each lane needs a job, allowed files, files to avoid, and proof. If two lanes need the same files, they are not parallel yet.
How can we accomplish this task with multiple agents, where they each have their own responsibility, and they each have their own testing, they can work in parallel, usually in the same branch, honestly.
— From the workshop, around 2:41
| Lane | Owns | Avoids | Proof |
|---|---|---|---|
| Lane: UI lane | Owns: src/routes/dashboard/**, component snapshots |
Avoids: API contracts, migration files | Proof: screenshot and component checks |
| Lane: Data lane | Owns: query helpers, fixtures, schema mapping | Avoids: visual components | Proof: query tests |
| Lane: Test lane | Owns: new regression tests | Avoids: production logic except test hooks | Proof: failing-before / passing-after log |
| Lane: Review lane | Owns: risk notes, integration checklist | Avoids: code edits | Proof: written review with blockers |
Keep The Agents Visible
Visible work is easier to correct. You can inspect the history, compare outputs, step into one lane, or stop a bad direction before it spreads.
Hidden background work can be useful, but it removes the trail you need when the next run should be better. If the task is risky, keep the lanes where you can watch them.
When I see agents spawn up in background threads, and I don't know what they're doing, and I can't, like, look at some of the history and tool calls and everything. I don't know how it could improve next time.
— From the workshop, around 2:37
Use A Manager Thread
One thread owns the plan. Other lanes execute bounded work. The manager does not need to do every task. It needs to remember the split, check progress, catch conflicts, and decide when to merge, redirect, or stop.
Manager responsibilities:
- restate the project goal
- divide work into lanes
- assign file boundaries
- name the verification for each lane
- tell each lane which other lanes exist
- check progress before merging ideas
- stop any lane that crosses its boundary
Copyable Prompt: Parallel Work Plan
We need to plan parallel agent work for this software task.
Task:
[describe the feature, fix, migration, or review]
Current phase:
[planning / implementation / debugging / visual review / verification]
Project facts:
- active areas:
- stable areas to avoid:
- commands/tests available:
- risky files:
- expected output:
Create a parallel work plan.
Return:
1. the smallest useful number of lanes
2. the responsibility of each lane
3. exact file or directory boundaries for each lane
4. what each lane must not touch
5. the verification each lane must run
6. the manager check-in schedule
7. the prompt to initialize each lane
Prefer fewer lanes if file conflicts are likely.
Do not start implementation yet.
Copyable Prompt: Lane Setup
You are Lane [name].
Goal:
[one responsibility]
Allowed files:
[list]
Do not touch:
[list]
Other lanes running:
- [lane]: [scope]
- [lane]: [scope]
Before editing:
- inspect only your allowed area
- restate the files you expect to touch
- name the verification you will run
After editing:
- summarize changes
- list files changed
- run verification
- report any boundary conflicts
Make Progress Legible
Use agents to make proof easier to produce: screenshots, before/after numbers, test logs, release notes, and short visual summaries. The goal is not noise. The goal is reviewable impact.
Before/after performance note:
Before:
Dashboard loaded sample account in 4.8s.
After:
Dashboard loaded sample account in 1.9s.
Proof:
Trace attached, test command included.
Change:
Cached account summary query and removed duplicate fetch.
Visual progress note:
What changed:
Replaced manual export flow with a reviewed batch job.
Why it matters:
Removes three support steps.
Proof:
Screenshot, smoke test, rollback note.
Save The Layout Only After It Repeats
A reusable layout is earned. If the same task shape appears three times with the same lane split, checks, and review surface, turn it into a saved workspace, script, or small helper.
Until then, start fresh and ask for the split.
Automate The Agent Loop With Hooks
Use lifecycle automation for predictable setup, routing, and final gates around the agent loop.
Rewatch this part: 3:30:00–4:00:00 in the recordingIn this section Put Setup At Session StartRoute Before The Prompt LeavesUse Stop Hooks As Final GatesKeep Hooks Out Of Jobs That Need Judgment

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.
Use session start for setup and binding, user prompt submit for pre-submit routing, context, and safety, and stop hooks for final gates. Keep skills, imps, CLI helpers, and manual prompts for jobs that need optional invocation, model judgment, or task-specific context.
If you want things to happen automatically, that's not what skills are for. If you want them to happen automatically, that's what hooks are for.
— From the workshop, around 3:57
Put Setup At Session Start
Session start is the setup moment. Use it for identifiers and state that later tooling needs to find without scraping the screen or asking the model to remember.
At session start, a project might record:
- session id
- working directory
- transcript location, when available
- branch name
- visible workspace surface
- a searchable session name or tag
Keep this setup boring and reliable. If later shortcuts, dashboards, or review tools need to find the right conversation, this is where the lookup trail starts.
That's the key piece of information, is that session start, like, a place to set things up.
— From the workshop, around 3:50
Route Before The Prompt Leaves
User prompt submit is the pre-submit moment. Use it when a project-specific prompt pattern should trigger local work before the model spends a turn.
Prompt submit triggers can do things like:
#testloads files tagged for test context#apiloads route and schema context!ticketcreates a tracking issue from the prompt body!summarysends the current thread to a summarizer- sensitive release terms trigger a confirmation check
Choose syntax that fits the project and team. Do not assume custom symbols will remain collision-free forever.
Use Stop Hooks As Final Gates
Stop hooks are for final checks near the end of a turn, so missing proof is surfaced before the work is treated as done.
Good stop-gate candidates:
- run the smallest relevant test
- run a formatter or linter
- check for unresolved uncertainty language
- verify an issue or summary was created
- check whether a forbidden file changed
- surface missing proof and report blocked only when the current hook behavior supports that flow
Do not claim a hook guarantees correctness. A hook can run final checks and surface missing proof; exact blocking, continuation, mutation, and appended-context behavior must be verified against the current docs and installed tool. The verification still has to be well designed.
Keep Hooks Out Of Jobs That Need Judgment
Hooks are best for mechanical behavior. If the action needs fresh reasoning each time, a hook is probably the wrong surface.
Use a hook when:
- the trigger is predictable
- the action should run automatically
- the behavior can be reviewed and trusted
- the result should not depend on the model remembering a rule
Use another surface when:
- the action is optional
- the model needs to decide whether it applies
- the work needs a large body of task-specific context
- a normal prompt, skill, CLI helper, or narrow imp would be clearer
Use Documented Events
Verify the current Codex hook docs before relying on exact event lists or payload behavior. Treat event names as current-tool details, not the durable lesson. A hook workflow should name the lifecycle moment, state what it automates, and keep examples easy to recheck.
Only some events may honor matchers, and handler support can change. Keep implementation examples conceptual until the exact matcher behavior, payload shape, return behavior, and trust flow have been checked against current docs.
That matters for shared examples: start with the workflow shape, then attach exact event names only after checking the installed tool and current docs.
Copyable Artifact: Hook Decision Checklist
Use a SessionStart hook when:
- the session needs setup before the first prompt
- you need to bind session id, cwd, transcript, branch, or visible workspace state
- later tools need to find this session without screen scraping
Use a UserPromptSubmit hook when:
- a prompt pattern should trigger local context loading
- a project shortcut should route work before the model spends a turn
- a safety check should confirm or block a risky prompt
Use a Stop hook when:
- a final check should run before the work is treated as done
- missing proof should be surfaced or reported according to verified hook behavior
- final output needs proof
Do not use a hook when:
- the behavior needs model judgment every time
- the action is optional
- the implementation is not reviewed or trusted
- a normal prompt, skill, CLI helper, or narrow imp is clearer
Implementation Notes To Verify
Before sharing executable hook examples, verify:
- exact payload fields
- whether the example blocks, continues, appends context, or only reports
- timeout behavior
- trust-review behavior
- event matcher behavior
- current docs for the installed Codex version
Concepts are portable. Hook code is version-sensitive.
Compose The First Prompt Before The Agent Starts
Name the work, preview the first prompt, and hand the agent a clean launch packet.
Rewatch this part: 4:00:00–4:19:30 in the recordingIn this section Start With A NameCompose Before LaunchUse Prompt Builder For PreflightUse Hooks For Every-Turn Behavior

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.
Do the deliberate setup before the agent session starts. Use hooks for repeated interception during the session. Use imps or CLI helpers for reusable specialist behavior.
Start With A Name
Unnamed sessions decay quickly. A name gives search, resumption, review, and reporting something stable to grab.
The thing I like about this is that I can just give a conversation a name from the start. And it kind of forces me to think about what the conversation is going to be about.
— From the workshop, around 4:07
Good names sound like software work:
- Checkout saved payment methods
- Billing webhook retry audit
- Auth session rotation review
- Settings empty-state cleanup
The name does not need to be clever. It needs to be short, searchable, and tied to the work.
Compose Before Launch
The core loop is:
intent -> name -> prompt -> references -> preview -> submit
Prompt Builder is useful because it moves composition before the full launch path. You can shape the prompt, add the name, include the references, inspect the launch, and then hand the result to Codex or a wrapper command.
Pre-flight, preload, pre-plan. Sessions before, before anything about the agents kicks in, before the system prompt kicks in, before anything.
— From the workshop, around 4:13
Use Prompt Builder For Preflight
Use a preflight surface when the setup belongs to the first prompt.
Feature kickoff:
Name:
Checkout saved payment methods
Prompt:
Inspect the checkout flow, list the files likely involved, identify the smallest safe implementation plan, and name the first verification command.
Do not edit yet.
Bug-fix preflight:
Name:
Billing webhook retry bug
Prompt:
Use the failing test output and billing webhook files to identify the likely regression.
Return the smallest patch plan and the verification command before editing.
Architecture review:
Name:
Auth session rotation review
Prompt:
Review the auth/session architecture and find risks around token rotation, stale sessions, and logout behavior.
Return findings grouped by risk and proof needed.
Use Hooks For Every-Turn Behavior
Prompt Builder helps before the session starts. Hooks are a better fit when something must happen on every prompt or at a lifecycle checkpoint.
For voice-to-text cleanup:
- Use Prompt Builder when cleanup only needs to happen before the first prompt.
- Use a prompt-submit hook when cleanup must happen on every turn.
- Use an imp or CLI helper when cleanup belongs to a reusable specialist command.
Example boundaries:
- Initial only: clean up a dictated feature kickoff, apply a glossary, attach project references, then launch.
- Every turn: normalize dictated acronyms, product names, ticket IDs, and file names before each prompt reaches the agent.
- Specialist job: take rough dictated text and return a launch-ready prompt without touching the repo.
Use Imps For Repeated Specialized Jobs
If the behavior becomes a reusable tool-shaped job, move it out of the first prompt.
Good candidates:
- prompt cleanup
- bug triage
- screenshot capture
- route inspection
- dependency audit
- ticket drafting
The first prompt should start the work. It should not become the permanent home for every repeated workflow.
Optional Patterns: Fork, Compact, Handoff
Prompt Builder can compose first, then hand the prompt to another command. In that mode, fork and compact options are routing choices.
Keep the model simple:
compose first -> fork selected session -> compact when needed -> resume with named prompt
compose first -> hand off to wrapper -> wrapper owns the routing
Treat this as advanced launch routing. The main lesson is still preflight: name the work, shape the request, preview the launch, and submit deliberately.
Copyable Artifact: First Prompt Preflight Checklist
Before launching the agent, fill in:
Name:
[short, searchable task name]
Goal:
[what should be true when this work is done]
Context:
[files, logs, screenshots, tickets, or docs to inspect first]
Constraints:
[files to avoid, behaviors to preserve, risky areas]
Launch shape:
[fresh thread / named thread / fork / compact fork / wrapper handoff]
First output:
[plan only / edit / diagnosis / test list / comparison]
Proof:
[command, screenshot, trace, diff, or review artifact required]
Stop rule:
[what should block completion]
Example:
Name:
Checkout saved payment methods
Goal:
Fix the saved-card selection regression without changing the payment-provider adapter.
Context:
Checkout route, saved payment method component, failing test output.
Constraints:
Do not touch provider SDK wrappers.
Do not rewrite checkout state management.
Launch shape:
Named thread.
First output:
Diagnosis and smallest safe patch plan.
Proof:
Run the checkout component test and billing smoke test.
Verify Commands Before Use
Prompt Builder command examples are implementation details. Before running them, verify the current binary name, install path, --name, dry-run, print, submit, handoff, fork, compact, and launch-option behavior against the current source and CLI help.
The pattern is stable. Command details can change.
Use A Model Council When One Answer Is Too Narrow
Ask independent providers for critique, wait for terminal artifacts, and reconcile the result with repo evidence.
Rewatch this part: 4:19:30–4:33:00 in the recordingIn this section Use It For Hard DecisionsThe Mental ModelRun The Whole CouncilHandle Missing Voices

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.
Fusion is one way to run that pattern locally: send the same bounded software question to multiple configured providers, wait for the panel to finish, let a finalizer compare the outputs, then make the engineering decision from the result and the repo evidence.
It can take all of those results and then fuse them with the model of your choice. Meaning that… you get multiple opinions, you can have them kind of argue against each other.
— From the workshop, around 4:19
Use It For Hard Decisions
Reach for a council when you need coverage, not speed.
Good fits:
- large PR review
- architecture tradeoffs
- migration risk
- security and performance tension
- uncertain debugging plans
- product or UX direction
- release or rollback strategy
Do not use it as a way to avoid making the call. The council gives you independent critique. You still own the decision.
The Mental Model
bounded software question
-> independent model/provider perspectives
-> terminal provider states
-> finalizer comparison
-> summary.json
-> final.md
-> engineering decision
Fusion is for coverage, not voting. The useful output is not "three models said yes." The useful output is consensus, contradictions, unique warnings, blind spots, and a final recommendation you can test against the codebase.
Run The Whole Council
Partial panel output is not the answer. Wait until every configured provider reaches a terminal state before treating the result as complete.
Before a real run:
- inspect the configured providers
- run the full configured panel by default
- wait for terminal provider states
- read
summary.json - read
final.md - reconcile the result with repo evidence
Panel artifacts are partial until the final artifacts exist.
Handle Missing Voices
A missing provider degrades the council. It does not automatically make the run useless.
If a provider times out, fails, or hits quota after artifacts exist, treat that as a missing voice. The final answer can still be useful if it clearly names the degraded state and enough other panel output exists to synthesize.
Do not hide the missing voice. Make it part of the decision record.
Good Software Uses
Large PR review:
Use Fusion to review this PR before merge.
Context:
- PR summary:
- changed files:
- risky areas:
- test output:
- migration or rollout notes:
Ask the council to find:
- correctness risks
- security risks
- performance risks
- missing tests
- rollout or rollback issues
- documentation gaps
Return:
- consensus
- contradictions
- unique warnings
- blind spots
- recommended merge/block decision
- verification commands
Architecture tradeoff:
Compare three implementation paths for the billing webhook fix:
A. provider event id dedupe
B. invoice-level lock
C. processing ledger
Include:
- failure modes
- migration risk
- rollback path
- test plan
- operational logging
- smallest shippable recommendation
Role/perspective panel:
Review this auth/session plan from four perspectives:
1. security reviewer
2. performance reviewer
3. migration reviewer
4. product/UX reviewer
Each reviewer should name what could go wrong.
The finalizer should preserve minority warnings instead of flattening them.
Optional Pattern: Stop-Hook Review
For risky AFK work, a prompt marker can ask a later stop gate to review changes before reporting done.
Conceptual shape:
When the user prompt includes #review, write a marker for the stop hook.
At Stop:
- check whether files changed
- check whether the marker exists
- run Fusion against the diff
- read summary.json and final.md
- report the council result before claiming done
Treat this as a pattern until the hook payload, marker passing, and current CLI behavior are verified.
Copyable Artifact: Fusion Decision Brief
Decision:
[the software decision under review]
Why a council:
[what one model might miss]
Context:
- repo area:
- changed files:
- relevant tests:
- logs or traces:
- constraints:
Provider instructions:
Ask each provider to review independently.
Preserve disagreements.
Do not treat majority agreement as proof.
Finalizer instructions:
Return:
- consensus
- contradictions
- unique warnings
- blind spots
- recommended decision
- verification commands
- confidence and why
Human decision:
[accept / revise / block / run another pass]
Claim Boundaries
Hosted products may publish their own benchmark or cost claims for panel-style research workflows. Treat those as vendor claims that need dated citations. Local Fusion is a local CLI pattern inspired by the same panel/finalizer idea, not proof of hosted benchmark results.
I can, like, anecdotally vouch for the results, but I can't give you some sort of percentage of… it's this close to Fable or whatever.
— From the workshop, around 4:25
Provider availability, pricing, quotas, auth, and data handling are local/account-dependent. Verify current provider terms before sending private code or prompts.
Model council output is advisory. Tests, code review, product judgment, and repo evidence still decide the work.
Mark The Debug Moment Before Agent Handoff
Capture the exact browser moment, nearby events, and privacy boundary before another agent takes over.
Rewatch this part: 4:33:00–4:49:00 in the recordingIn this section The ProblemBounded Debug PacketsSmallest SetupThe Data Model

Logs show what happened. A marker says which moment mattered.
Use Agent Markers when a bug appears during real app use and the next agent needs more than a sentence and a screenshot. The move is to mark the decisive moment while it is happening, capture nearby runtime evidence, add the human explanation, review the packet, and export only what is safe to share.
mark -> capture -> explain -> review/export
The Problem
You found the bug while using the app. The checkout button stayed disabled, the billing retry fired twice, the auth session rotated at the wrong time, or the date rendered in the wrong format.
We're interacting with an app, we're clicking on buttons, and we're typing in fields, and then something happens, and we want to be able to capture that specific moment. We don't want to have to quit our app, start up debugging mode.
— From the workshop, around 4:39
The old ritual is expensive:
- add temporary logs
- reproduce the bug
- forget which log line mattered
- remove the logs
- hope the next agent understands the state you saw
A debug marker preserves the moment without turning the whole session into a permanent logging project.
Bounded Debug Packets
A bounded debug packet is a small export centered on one marked moment.
It can include:
- the marker label and note
- nearby console, fetch, error, unhandled rejection, and manual events
- route, viewport, and environment metadata
- optional DOM or screenshot evidence
- the privacy review boundary
- the first verification command for the next agent
It is not a replay system, production telemetry, a browser extension, a server product, or an AI product. It is a reviewed packet for debugging work.
Smallest Setup
import { createAgentMarkers } from "<verified-agent-markers-client>";
const markers = createAgentMarkers({
appName: "checkout-demo",
exposeGlobal: true
});
await markers.mark("Checkout button stayed disabled", {
note: "Expected it to enable after selecting shipping.",
tags: ["checkout", "regression"]
});
const session = markers.export();
createAgentMarkers sets up a browser-side collector. It can mark moments, record manual events, export a DebugSession, optionally expose a dev/test global, and clean itself up with stop().
The Data Model
| Concept | Practical Meaning |
|---|---|
Concept: DebugSession |
Practical Meaning: One bounded debugging run: app name, session id, environment, markers, and events. |
Concept: DebugMoment |
Practical Meaning: The human marker: label, note, tags, severity, environment, optional data, optional DOM/screenshot evidence, and nearbyEventIds. |
Concept: CapturedEvent |
Practical Meaning: Runtime evidence near the marker: console, fetch, error, unhandled rejection, or manual event. |
Concept: nearbyEventIds |
Practical Meaning: The bridge between the marked moment and the runtime events captured near it. |
| Concept: export JSON | Practical Meaning: The reviewed packet that can be attached to a test run, issue, or agent prompt. |
The useful part is the link between the human explanation and the runtime trail. Without nearbyEventIds, the agent gets a label and starts guessing. With it, the agent gets a bounded slice of the session.
Privacy Defaults
Field rule: metadata first, values only after review.
Agent Markers is designed around a local review boundary:
- data stays in memory until explicit export
- storage capture records key names and counts by default, not values
- fetch capture records metadata and does not read request or response bodies
- treat raw exported sessions as private until reviewed and redacted
Do not share raw exported sessions. Review and redact private routes, screenshots, stack traces, request URLs, user-entered text, tokens, cookies, account data, local paths, and application-specific identifiers.
Test Runner And Agent Handoff
In dev and test, exposeGlobal: true gives a test runner a browser handle:
window.__AGENT_MARKERS__
A browser test can reproduce the bug, call mark(...), export JSON to a private test artifact, and attach or share only a reviewed and redacted packet. The next agent gets a bounded packet instead of a vague report.
You can take that kind of entire session, you can copy and paste the logs into your agent. And tell it, please review for the markers and help me get this fixed.
— From the workshop, around 4:42
Treat the redaction helper below as project-specific review code, not an Agent Markers API.
const session = await page.evaluate(async () => {
await window.__AGENT_MARKERS__.mark("checkout disabled unexpectedly", {
note: "Expected submit to enable after terms and shipping were selected."
});
return window.__AGENT_MARKERS__.export();
});
const redactedSession = redactAgentMarkerSession(session);
await testInfo.attach("agent-markers.redacted.json", {
body: JSON.stringify(redactedSession, null, 2),
contentType: "application/json"
});
Import from the reviewed Agent Markers client in the current project. Verify the package or workspace path before turning this into executable setup.
The handoff prompt should tell the agent:
- what the human expected
- what happened instead
- which event ids are nearby
- what is intentionally redacted
- where to start verification
- what not to infer from missing data
Clean Up
Call stop() when the collector is done.
The collector installs capture hooks for useful evidence. stop() disposes those hooks. After stop(), treat the collector as finished instead of continuing to mark new moments.
Copyable Artifact: Bounded Debug Packet
Marker:
- label:
- note:
- expected:
- actual:
- next action:
Session:
- schemaVersion:
- sessionId:
- appName:
- markerId:
- nearbyEventIds:
Included evidence:
- console:
- fetch:
- error:
- unhandledrejection:
- manual:
- DOM or screenshot availability:
Privacy review:
- storage values exported? no
- request bodies exported? no
- response bodies exported? no
- private routes removed?
- user-entered text removed?
- stack paths reviewed?
- screenshot reviewed?
Handoff:
- first verification command:
- files or areas to inspect:
- what the agent must not infer:
- stop condition:
Example prompt:
Use this bounded debug packet to investigate the checkout disabled-state bug.
Start from the marker note and nearbyEventIds.
Do not assume redacted fields are absent in the app.
Inspect the checkout form state, shipping selection flow, and submit-button disabled logic.
Return the likely cause, smallest patch plan, and first verification command before editing.
Claim Boundaries
Agent Markers gives the next agent a better packet. It does not guarantee the agent will find the defect automatically.
Use it for local development, browser tests, and reviewed debugging artifacts. Verify any production use, data retention policy, screenshot capture, source-map behavior, and privacy implications before adopting it in a real product.
Turn Generated Choices Into A Mobile Decision Surface
Generate structured options, make selection easy on a phone, save the decision, then resume from persisted JSON.
Rewatch this part: 4:49:00–4:59:00 in the recordingIn this section The ProblemThe MoveThe Smallest Useful VersionThe UI Contract

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.
When an agent generates options, turn them into a small picker. Review it on a phone, tap the choices that should survive, dictate notes, submit, and make the agent continue from the saved JSON.
generated options
-> structured choice job
-> Svelte + mdsvex picker
-> token-gated mobile URL through a reviewed tunnel
-> click/dictate feedback
-> saved submission
-> agent resumes from persisted JSON
The Problem
Generated options are useful until they become a wall of text.
The agent offers five reasonable strategies for a checkout fix, billing webhook retry plan, auth/session tradeoff, QA screenshot triage, or design variation. You are away from the desk. The mobile chat thread now expects you to remember option names, type a careful answer, and trust the agent to turn that paragraph back into structured state.
That is where decisions get mushy.
The Move
Generated choices should become data, not another paragraph.
The agent should produce a choice job with stable option ids, titles, descriptions, risk notes, and proof hints. A small review UI renders those choices as cards. The human selects options, adds per-option feedback, adds overall feedback, and submits. The agent waits for the saved submission before continuing.
Use this when the next step needs a human decision:
- choose among generated UI variations
- pick a billing webhook idempotency strategy
- choose an auth/session migration path
- approve or reject model-council recommendations
- triage screenshot or debug-packet follow-ups
- select the first implementation plan after a broad exploration
The Smallest Useful Version
The picker does not need to be elaborate. It needs stable ids, checkboxes, per-option notes, one overall feedback box, draft saving, and a submit button that writes durable JSON.
Choice job:
- jobId:
- title:
- description:
Options:
- id:
title:
description:
risk:
suggested proof:
expected evidence:
Human response:
- selected option ids:
- per-option feedback:
- overall feedback:
Resume rule:
- continue only after a saved submission exists
- resume from persisted JSON, not memory
The UI Contract
Web Choices uses a Svelte + mdsvex browser UI. The app shell can be branded and pleasant, but the generated choices stay plain JSON.
Keep this boundary:
- mdsvex owns the page/template shell
- Svelte owns cards, selection state, feedback fields, save state, and submit controls
- generated option text remains data
- generated option text is not compiled as Svelte or mdsvex source
That boundary matters. A decision surface should not become a tiny CMS that compiles model output as app code.
Persistence Is The Trust Boundary
No saved submission, no continuation.
Drafts are for humans. Submissions are for agents.
I need you to make these decisions before I continue further, and so I look at it, I click the ones I want, give feedback on it, and then submit, and then it continues. So you create a really asynchronous feedback loop between your local agent and how you're talking to it on your phone.
— From the workshop, around 4:58
The durable state lives under a caller-selected human-in-the-loop output directory, commonly .hitl-choice:
.hitl-choice/
current-job.json
drafts/
submissions.jsonl
submissions/<submissionId>.json
The agent should wait until a final submission exists, then read selected option ids, per-option feedback, and overall feedback from the saved JSON. It should not infer the decision from visible UI state, draft text, or chat memory.
The Phone Workflow
The phone is for decisions, not implementation.
Click, dictate, click, dictate has been the best workflow for me.
— From the workshop, around 4:57
The useful mobile loop is intentionally small:
tap option
dictate note
tap option
dictate note
add overall feedback
submit
This works best when the agent has already done the expansion work. The human does the selection work.
Tunnel Boundary
A reviewed, short-lived tunnel can make the local picker reachable from a phone. Keep the specific tunnel product and hostname setup-specific unless the demo evidence is added and sanitized.
The important lesson is not the exact hostname. The important lesson is:
- keep the local server alive while waiting
- expose a short-lived token-gated URL
- let the human submit structured feedback
- resume from persisted JSON
Do not treat a token-gated URL as full authentication. It is useful friction, not a product security model.
Copyable Artifact: Mobile Decision Surface Brief
Use this when:
- an agent generated several options
- the human needs to choose or annotate them
- the next step should not continue until the choice is saved
- the human may be reviewing from a phone
Choice job:
- jobId:
- title:
- description:
- options:
- id:
title:
description:
risk:
suggested proof:
expected evidence:
UI requirements:
- render options as cards
- allow multiple selection when appropriate
- collect per-option feedback
- collect overall feedback
- save drafts while editing
- write final submission only on submit
Persistence:
- active job: .hitl-choice/current-job.json
- drafts: .hitl-choice/drafts/
- final log: .hitl-choice/submissions.jsonl
- final packet: .hitl-choice/submissions/<submissionId>.json
Agent stop rule:
- wait for a saved submission
- read selected ids and feedback from JSON
- continue only from the persisted submission
- report blocked if no submission exists
Sharing boundary:
- do not expose real tunnel URLs
- do not expose tokens
- do not expose hostnames
- do not expose or share private options or submissions
- do not call the token full authentication
Example prompt:
Turn these billing webhook strategies into a Web Choices job.
Each option needs:
- stable id
- short title
- concrete description
- risk
- suggested proof command
- pass/fail evidence
Serve it as a phone-friendly picker, wait for the saved submission, then continue only from the persisted JSON.
If It Goes Wrong
If the tunnel fails, keep the same job state when possible. Reuse the token only if it was not exposed; otherwise rotate the token, restart the tunnel, and verify the current job is reachable before asking for another decision.
If the server dies, inspect the output directory first. Restart with the same state if drafts or submissions already exist.
If the human says they submitted but the wait command has not returned, check submissions.jsonl, per-submission files, and whatever reviewed server logs or status endpoint the current implementation exposes before regenerating choices.
Claim Boundaries
Web Choices is a local human-in-the-loop pattern with a small web UI and durable files. It is not a production approvals system by default.
Verify timeout behavior, tunnel behavior, mobile rendering, submission persistence, and data handling in the current setup before sharing executable setup instructions.
Turn Long Recordings Into Video Evidence Packets
Chunk recordings by evidence density and ask for visible states, actions, omissions, and uncertainties.
Rewatch this part: 4:59:00–5:09:00 in the recordingIn this section The FailureThe MoveKeep The VideoChunk By Evidence Density

A long recording is not one prompt. It is a pile of evidence with a timeline.
Do not reduce it to a transcript too early. Keep the video as prompt material, cut the recording into chunks, send each chunk through the video-watching lane, extract screen evidence while it is still visible, and carry prior summaries forward.
The artifact you want is not a summary. It is a video evidence packet.
The Failure
A five-hour workshop, app walkthrough, or bug reproduction contains too much visual detail for one tidy answer.
If one model response has to summarize the whole recording, it will usually flatten the exact details software work needs:
- tooltip text
- disabled button states
- cursor actions
- modal transitions
- terminal output
- code snippets
- missing steps
- retries and failed attempts
- loading, error, and empty states
The problem is not only upload size. The problem is answer density. One huge answer cannot carry every useful screen fact.
It's very difficult to get good information out of it that way, because it's limited by the amount of tokens it can provide in one response.
— From the workshop, around 5:04
The Move
Create video evidence packets.
A video evidence packet is a chunked, source-preserving record of what happened in a slice of video:
- clip
- transcript slice
- chat slice
- key frames
- visible text
- UI states
- actions
- code snippets or terminal output
- omissions
- model output
- verification notes
The packet gives the next agent inspectable context without pretending it watched the whole recording.
Keep The Video
Video is not just a transcript with pictures nearby. For UI work, the screen matters.
A tooltip, hover state, selected tab, disabled button, cursor path, dialog, terminal frame, or loading spinner can be the evidence. Keep the clip attached as prompt material until the visual claims have been extracted and checked.
In the demonstrated workflow, the local agent owned the files, prompts, saved outputs, and verification. Oracle handled the browser handoff. Gemini was the video-watching lane for that run. The repo received the output as reviewable files.
Treat exact model behavior, limits, quotas, pricing, and account budget as current-product details that must be rechecked before relying on them in shared guidance.
Chunk By Evidence Density
Use chunks small enough that each answer can stay specific.
What you can do with an agent is split the video into, like, 15-minute chunks, and then in each of those chunks, you can say, what are the key frames, what are the key ideas, what are the key transcript points.
— From the workshop, around 5:02
Fifteen minutes is a reasonable default for workshop or walkthrough material. Five minutes can be useful when the screen is dense, the bug is subtle, or the output needs frame-level detail.
Do not turn those numbers into doctrine. Choose chunk size by evidence density.
Before analysis, remove confirmed dead space when it is safe:
- long silence
- blank screens
- motionless regions
- breaks
- inactive spans
Do not delete chat, links, questions, or setup context that explains the next spoken section. Carry that forward.
Ask For Screen Evidence
Use the same evidence lanes for each chunk.
For this video chunk, extract:
Visual evidence:
- key frames
- visible text
- UI states
- cursor actions
- modal/dialog states
- loading/error/empty states
- code snippets or terminal output
- colors, layout shifts, and visual changes
Transcript evidence:
- key spoken points
- claims made
- instructions given
- unanswered questions
- deferred follow-ups
Action evidence:
- user actions
- app responses
- navigation steps
- failed attempts
- retries
- omissions or confusing transitions
Verification:
- what is directly visible
- what is transcript-supported
- what is inferred
- what needs manual review
This is the difference between "the user clicked around" and "the tooltip text appeared next to the control, then the follow-up prompt asked what it said."
Carry Prior Chunks Forward
Chunking solves the density problem and creates a continuity problem.
Fix that by carrying a compact previous-summary ledger into every later prompt:
You are analyzing chunk 10 of 15 from a long software workshop.
Previous chunk summary:
- Chunk 01 introduced the repo and evidence boundary.
- Chunk 02 covered agent-ready repo setup.
- Chunk 03 covered narrow workspace agents.
- Chunk 04 covered generated variations.
- Chunk 05 covered visual review before implementation.
For this chunk:
- preserve original timestamps
- extract visible UI states, actions, text, code snippets, and omissions
- separate transcript evidence, visual evidence, and inference
- return a chunk summary that can be carried into the next prompt
Every later chunk should know what came before it: active concepts, unresolved questions, decisions already made, and what the current chunk must not re-explain.
Use It For Software Work
Good fits:
- QA records a checkout regression and the packet extracts the disabled button state, selected shipping option, console error, and missing validation message.
- A designer records a settings walkthrough and the packet extracts empty states, modal transitions, keyboard traps, contrast concerns, and confusing copy.
- A product team records its own onboarding flow and the packet turns it into acceptance criteria.
- A developer combines a debug marker packet with the video chunk around the marked moment.
Product research also fits, but keep the ethics boundary clear. Use public walkthroughs for UX critique, accessibility review, flow comparison, and internal design study. Do not present this as a way to copy proprietary UI, assets, copy, CSS, or product behavior.
Copyable Artifact: Video Evidence Packet
Source:
- recording:
- source hash:
- original timestamp range:
- transcript slice:
- chat slice:
- chunk id:
- prior summary included? yes/no
Preprocessing:
- silence reviewed:
- motionless/blank spans reviewed:
- removed spans:
- carried-forward chat/questions:
Ask the video model to extract:
- key frames:
- visible text:
- transcript points:
- user actions:
- UI states:
- code snippets or terminal output:
- colors/layout changes:
- loading/error/empty states:
- omissions:
- uncertainties:
Cumulative context:
- previous chunks summarized:
- unresolved questions:
- concepts already introduced:
- what this chunk must not re-explain:
Verification:
- claims supported by transcript:
- claims supported by visual evidence:
- claims supported by chat:
- claims that are inference only:
- private details removed:
- screenshots/keyframes sanitized:
- model/cost/limit claims removed or verified:
Example prompt:
Analyze this checkout bug recording as chunk 03 of 08.
Previous summary:
[paste compact prior-summary ledger]
Extract:
- visible UI states
- cursor actions
- selected fields
- loading/error/empty states
- visible text
- transcript claims
- omitted steps
- uncertainties
Separate visual evidence, transcript evidence, chat evidence, and inference.
Return a short carry-forward summary for the next chunk.
Claim Boundaries
This workflow does not prove model limits, pricing, quota behavior, speed, or model superiority.
It proves that a recording was processed through a chunked, source-preserving workflow and that shared claims can be checked against transcript, video evidence, key frames, chat, and saved outputs.
Before sharing screenshots or key frames, sanitize them, copy them into the shared asset tree, add alt text, and review for private browser/account state.
Keep Notes Local, Make Goals Verifiable
Let scratch notes stay messy, but turn durable work into bounded goals with proof scenarios.
Rewatch this part: 5:09:00–5:21:30 in the recordingIn this section The MoveNotes Become GoalsLong Agent Work Needs IntervalsUnderstanding Becomes Proof Design

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.
Do not commit that pile. Keep scratch private, ignored, and temporary until it earns its way into a goal.
private scratch note
-> reviewed goal packet
-> bounded agent work
-> proof scenario
-> saved evidence
-> next goal
The Move
Use a project-local scratch space for messy notes and a reviewed goal packet for actual work.
Local conventions such as .notes/ and .goals/ can work well when they are globally ignored and treated as private workspace files. The names are not important. The boundary is.
Notes is just kind of like the junk, or the research, or whatever. Goals are the things I can feed into the model to produce work.
— From the workshop, around 5:09
- Scratch notes are not documentation.
- Goals are not wish lists.
- A note is where messy thinking lands.
- A goal is what survives review and becomes work.
Notes Become Goals
A goal packet is a reviewed project-local work item that turns scratch notes into bounded agent work, names the proof scenario, and records what counts as done.
Example:
Scratch note:
Checkout submit stayed disabled after selecting shipping.
Goal:
Find the smallest cause of the disabled checkout submit state.
Likely areas:
- checkout form state
- shipping selection reducer
- submit button disabled logic
Proof:
- reproduce failing state
- add or run component test
- run checkout smoke test
- capture before/after result
Stop if:
- payment-provider adapter must change
- no reproducible failing state exists
Private notes stay private. Sanitized patterns can become docs later.
Long Agent Work Needs Intervals
Treat long agent runs as interval work.
Set an explicit check-in interval before launch. Leave the agent with a stop rule and proof requirement. Step away. Come back to inspect evidence, not vibes.
Field rule:
If the agent has a bounded goal and a proof command,
step away until the interval ends.
Watching the terminal harder does not make the benchmark finish.
Good launch shape:
Start a migration lane with:
- allowed files
- files to avoid
- verification command
- check-in interval
- stop condition
Return when:
- the timer fires
- the agent reports blocked
- the proof command finishes
- a boundary conflict appears
AFK does not mean unsupervised merge. It means the work unit is bounded enough that the human can leave and return to concrete evidence.
Understanding Becomes Proof Design
You still need judgment. What changes is the unit of understanding.
The best you can hope for is understanding the scenarios that prove the code works the way you expect it to.
— From the workshop, around 5:13
The useful unit is no longer "I have read every line." The useful unit is "I know the scenario, the boundary, and the evidence that prove this behavior."
Examples:
| Task | Proof Scenario | Evidence | Does Not Prove |
|---|---|---|---|
| Task: Checkout disabled state | Proof Scenario: Shipping selected, submit enables | Evidence: Component test, smoke test | Does Not Prove: Every payment-provider state |
| Task: Billing retry | Proof Scenario: Duplicate event processed once | Evidence: Fixture, idempotency test, log | Does Not Prove: All provider outage modes |
| Task: Auth/session rotation | Proof Scenario: Stale session rejected safely | Evidence: Security test, route check | Does Not Prove: Every browser/session store |
| Task: Performance change | Proof Scenario: Same fixture before/after | Evidence: Benchmark output | Does Not Prove: Production latency |
Proof scenarios are how codebase understanding stays grounded when code is moving quickly.
Ask For Lists, Not Comfort
Avoid vague reassurance prompts:
Are you sure?
Is this correct?
Why did this work?
Ask for structured reasons instead:
Do not reassure me.
List 5 reasons this proof actually covers the checkout disabled-state bug.
For each reason, include:
- the behavior it checks
- the evidence source
- what it does not prove
- one way this could still be wrong
More useful prompts:
List 5 ways this benchmark could be misleading.
List 7 security assumptions this auth/session change depends on.
List 4 reasons the smoke test covers the regression, then list 4 gaps it leaves open.
Agents are good at sounding certain. Lists force certainty to expose its assumptions.
Treat Public Skills As Candidates
Public skills are supply-chain inputs. Evaluate before installing.
For a software task, search with multiple terms instead of one narrow phrase.
Example task:
Improve accessibility checks for a Svelte checkout flow.
Search terms:
accessibility audit
a11y test
Svelte accessibility
Playwright axe
WCAG checker
keyboard navigation
screen reader smoke test
ARIA validation
form accessibility
contrast checker
Then ask a model council or Oracle to compare candidates:
Compare candidate skills for this task.
For each candidate:
- what it claims to do
- source/repo/package origin
- maintenance signals
- install or execution risk
- whether it reads project files
- whether it runs code
- what useful prompt or function can be extracted without installing
- recommendation: install / adapt / reject
Reading a skill is not the same as trusting it. Installing it is a separate decision.
Force Known Context
If the relevant files, constraints, stack, or proof command are already known, put them directly in the prompt. Search should fill unknowns, not rediscover known facts.
Weak:
Find the right skill and fix checkout.
Better:
We use SvelteKit.
The failing path is /checkout.
The bug is submit disabled after shipping selection.
Do not touch the payment provider adapter.
The proof is the checkout component test plus billing smoke test.
Search for skills only if they help inspect this exact scenario.
Copyable Artifact: Goal Packet
Scratch source:
- note id or summary:
- why this matters now:
Goal:
- what should be true when this is done:
Known context:
- repo area:
- likely files:
- constraints:
- files/tools to avoid:
Agent work:
- first inspection step:
- allowed edits:
- stop conditions:
Proof scenario:
- user path or system behavior:
- test:
- smoke check:
- benchmark:
- security check:
- debug/log evidence:
Reason list required:
Ask the agent to list:
- 5 reasons this proof covers the goal
- 5 gaps this proof leaves open
- 3 assumptions that could make the result wrong
Pacing:
- check-in interval:
- what to inspect when returning:
Skill evaluation, if needed:
- 10 search terms:
- candidate skills:
- Oracle/Fusion comparison saved?
- source scraped/read before install?
- useful parts extracted?
- install decision: install / adapt / reject
Completion:
- evidence attached:
- remaining uncertainty:
- next goal created:
Claim Boundaries
Do not share private note contents, global ignore files, local config, machine paths, usernames, or private skill contents.
Do not claim a model council can guarantee supply-chain safety. It can compare candidates and surface risk. The install decision still belongs to the human and the repo owner.
Do not claim developers no longer need to understand code. The narrower claim is stronger: understanding should be grounded in proof scenarios.
Interview For Judgment, Build For Agency
Keep human judgment in the loop: critique product flows, decide where agents help, and measure whether automation gave control back.
Rewatch this part: 5:21:30–5:32:58 in the recordingIn this section Judgment Stays HumanInterview With A Product FlowSpeculation Is Not A RoadmapFatigue Is About Control

Agent-heavy work eventually comes back to the human side of software practice.
Not "which model wins?" and not "will developers matter?" The useful question is smaller: when agents can write more code, what do people still need to judge, critique, own, and verify?
Judgment Stays Human
For product software, the durable skill is judgment:
- understand the user
- critique the experience
- communicate clearly
- decide where agents help
- decide where agents hurt
- keep control of the tools
- verify the result
The point is not to replace technical ability with taste. The point is to connect technical work to product reality.
Interview With A Product Flow
A useful interview exercise can be simple:
I would open up a website and just have someone critique it. Have them go through a few websites, have them click around. And not even find bugs, just find what they think could improve from the user experience.
— From the workshop, around 5:21
Open a real website or app. Ask the candidate to click through one flow, describe who the product serves, critique the experience, and connect that critique back to engineering decisions.
Then add the agent layer:
- Where could an agent improve this experience?
- Where could an agent make it worse?
- What should remain human-reviewed?
- What would you ask an agent to do first?
- How would you phrase the prompt so the work stays bounded?
Traits to look for:
| Trait | What To Look For |
|---|---|
| Trait: Product judgment | What To Look For: Can they tell what the product is for? |
| Trait: Communication | What To Look For: Can they explain the critique clearly? |
| Trait: Critique quality | What To Look For: Can they identify tradeoffs without just dunking on the UI? |
| Trait: User understanding | What To Look For: Can they connect features to user needs? |
| Trait: Agent judgment | What To Look For: Can they name where agents improve or damage the workflow? |
| Trait: Prompt framing | What To Look For: Can they turn critique into bounded agent work? |
Speculation Is Not A Roadmap
Near-term AI predictions should read as speculation.
Cheaper access to capable open models may reduce the need for some hand-built skills, video pipelines, and helper scripts. Agents may get better at noticing repeated work and creating small tools from the flow of a project.
Maybe.
That is a direction to watch, not a roadmap commitment.
Memory and tool self-improvement are moving targets. Teams are still figuring out how agents should remember past conversations, project state, repeated tool needs, and decisions that should shape future work.
Do not present current model-roadmap, pricing, capability, or provider behavior claims as fact unless they are freshly verified.
Fatigue Is About Control
AI fatigue grows when AI feels forced, opaque, or outside the user's control.
People generally get frustrated with AI when it's forced upon them, and when it's something that they haven't made themselves. And they don't feel like they have control over it.
— From the workshop, around 5:29
The answer is not "use more AI." The better answer is agency:
- adapt the tool
- own the loop
- inspect the result
- measure whether it helped
- keep review points visible
- make automation opt-in where the decision matters
Software examples:
- A checkout team adds a tiny local wrapper that always loads failing test output before asking an agent to patch.
- A billing team builds a review command that compares webhook strategies and requires proof commands.
- An auth/session team adds a project-local checklist before letting an agent touch token rotation.
- A UI team turns repeated design critique into a decision surface instead of asking the same chat prompt every day.
Local tools can change the feeling of the work because the developer can adapt the loop and see whether the change actually helped.
Ethics Boundary
Ethical concerns around AI are real and should not be waved away.
A practical workflow does not need to settle training data, copyright, compensation, platform power, or labor questions. It does need to avoid pretending those concerns do not exist.
The practical workflow boundary is smaller:
- review what goes into the tool
- keep private material private
- preserve human choice
- make review points visible
- do not make automation mandatory by default
- leave room for people to say no
This does not solve the broader ethical questions. It keeps the local workflow honest.
Copyable Artifact: Product Judgment Interview Packet
Candidate exercise:
- Open a real website or app.
- Click through one user flow.
- Explain who the product appears to serve.
- Name what the flow is trying to help the user accomplish.
Critique:
- What works?
- What is confusing?
- What user need is underserved?
- What engineering choice might be causing the friction?
- What evidence would you inspect before changing it?
Agent fit:
- Where could an agent improve the experience?
- Where could an agent make it worse?
- What should remain human-reviewed?
- What should the agent not infer?
Prompt:
- Ask the candidate to write the first agent prompt.
- Require scope, files or surfaces to inspect, constraints, proof, and stop condition.
Evaluation:
- Product judgment:
- Communication:
- Critique quality:
- User understanding:
- Agent boundary judgment:
- Prompt clarity:
Close The Loop
The useful follow-up is concrete:
- segmented recording
- reference links
- setup notes
- open questions
- verification gaps
- next actions
Do not end with a prediction cloud. End with the materials needed to keep working.
Claim Boundaries
Avoid broad labor-market claims. Avoid exact model labels, provider claims, price claims, memory-system claims, or capability predictions unless freshly verified.
Keep the final message narrower and stronger: judgment, agency, review boundaries, and measurable software work still matter.