{
  "schemaVersion": "1",
  "revision": "22ce5d34dbcb5a78",
  "id": "foundations-multimodal-design-and-model-routing",
  "slug": "multimodal-design-and-model-routing",
  "title": "Use images, video, and task-shaped model routing",
  "summary": "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.",
  "category": "Tools",
  "tags": [
    "images",
    "video",
    "models",
    "CLI"
  ],
  "sources": [
    {
      "label": "Agent foundations: Use images, video, and task-shaped model routing (authorized access required)",
      "url": "https://codex-workshop-followup.pages.dev/lesson-06.html"
    }
  ],
  "sourceUnits": [
    "oracle/lessons.json#06/objectives",
    "oracle/06-references.json#recap",
    "oracle/06-references.json#concepts/0",
    "oracle/06-references.json#concepts/1",
    "oracle/06-references.json#concepts/2",
    "oracle/06-references.json#concepts/3",
    "oracle/06-references.json#concepts/4",
    "oracle/06-references.json#references",
    "oracle/06-references.json#recommendations",
    "oracle/06-interactive.json#intro",
    "oracle/06-interactive.json#checklist",
    "oracle/06-interactive.json#challenges",
    "oracle/06-interactive.json#quiz",
    "oracle/06-interactive.json#reflect",
    "oracle/06-references.json#goDeeper",
    "materials/exercises.md#Chunk-06",
    "materials/qa-index.md#Q025",
    "materials/qa-index.md#Q026",
    "materials/qa-index.md#Q027",
    "materials/qa-index.md#Q028",
    "materials/qa-index.md#Q029",
    "materials/qa-index.md#Q030",
    "materials/qa-index.md#Q031",
    "materials/qa-index.md#Q032",
    "materials/qa-index.md#Q033",
    "materials/qa-index.md#Q034",
    "final/qa-index.md#Chunk-06",
    "materials/keyframes.md#Chunk-06",
    "lesson-06.html#resource-packet",
    "lesson-06.html#clip-map",
    "lesson-06.html#recording"
  ],
  "collection": "foundations",
  "categoryId": "tools",
  "wordCount": 3052,
  "url": "/topics/foundations-multimodal-design-and-model-routing/",
  "markdownUrl": "/markdown/foundations-multimodal-design-and-model-routing.md?raw=1&v=22ce5d34dbcb5a78",
  "jsonUrl": "/api/v1/documents/foundations-multimodal-design-and-model-routing.json",
  "headings": [
    {
      "id": "working-outcomes",
      "text": "Working outcomes",
      "level": 2
    },
    {
      "id": "concepts-and-consequences",
      "text": "Concepts and consequences",
      "level": 2
    },
    {
      "id": "cmux-as-a-primary-orchestrator",
      "text": "CMUX as a primary orchestrator",
      "level": 3
    },
    {
      "id": "model-choice-by-task-shape",
      "text": "Model choice by task shape",
      "level": 3
    },
    {
      "id": "image-generation-as-design-reference",
      "text": "Image generation as design reference",
      "level": 3
    },
    {
      "id": "video-prompting-for-high-context-intent",
      "text": "Video prompting for high-context intent",
      "level": 3
    },
    {
      "id": "mcp-versus-cli-boundaries",
      "text": "MCP versus CLI boundaries",
      "level": 3
    },
    {
      "id": "reference-tools-and-resources",
      "text": "Reference tools and resources",
      "level": 2
    },
    {
      "id": "cmux",
      "text": "CMUX",
      "level": 3
    },
    {
      "id": "codex-cli",
      "text": "Codex CLI",
      "level": 3
    },
    {
      "id": "google-gemini-video-prompting",
      "text": "Google Gemini video prompting",
      "level": 3
    },
    {
      "id": "impeccable",
      "text": "Impeccable",
      "level": 3
    },
    {
      "id": "gogcli",
      "text": "gogcli",
      "level": 3
    },
    {
      "id": "recommendations-and-best-practices",
      "text": "Recommendations and best practices",
      "level": 2
    },
    {
      "id": "practice-and-acceptance-criteria",
      "text": "Practice and acceptance criteria",
      "level": 2
    },
    {
      "id": "checklist",
      "text": "Checklist",
      "level": 3
    },
    {
      "id": "four-pane-orchestrator-drill",
      "text": "Four-Pane Orchestrator Drill",
      "level": 3
    },
    {
      "id": "reference-first-component-direction",
      "text": "Reference-First Component Direction",
      "level": 3
    },
    {
      "id": "video-extraction-brief",
      "text": "Video Extraction Brief",
      "level": 3
    },
    {
      "id": "boundary-audit-and-refactor",
      "text": "Boundary Audit and Refactor",
      "level": 3
    },
    {
      "id": "questions-to-test-understanding",
      "text": "Questions to test understanding",
      "level": 2
    },
    {
      "id": "why-does-the-lesson-recommend-using-cmux-as-a-primary-orchestrator-instead-of-running-one-huge-agent-thread",
      "text": "Why does the lesson recommend using CMUX as a primary orchestrator instead of running one huge agent thread?",
      "level": 3
    },
    {
      "id": "which-task-is-the-best-fit-for-a-fast-flash-style-model-in-this-lesson-s-routing-approach",
      "text": "Which task is the best fit for a fast Flash-style model in this lesson's routing approach?",
      "level": 3
    },
    {
      "id": "what-is-the-main-advantage-of-generating-image-variations-before-asking-an-agent-to-build-a-ui",
      "text": "What is the main advantage of generating image variations before asking an agent to build a UI?",
      "level": 3
    },
    {
      "id": "what-did-john-say-makes-video-prompting-valuable",
      "text": "What did John say makes video prompting valuable?",
      "level": 3
    },
    {
      "id": "what-is-the-lesson-s-practical-rule-of-thumb-for-mcp-versus-cli-boundaries",
      "text": "What is the lesson's practical rule of thumb for MCP versus CLI boundaries?",
      "level": 3
    },
    {
      "id": "reflection-prompts",
      "text": "Reflection prompts",
      "level": 2
    },
    {
      "id": "further-applications",
      "text": "Further applications",
      "level": 2
    },
    {
      "id": "applied-exercises",
      "text": "Applied exercises",
      "level": 2
    },
    {
      "id": "questions-and-answers",
      "text": "Questions and answers",
      "level": 2
    },
    {
      "id": "okay-and-also-this-you-wrote-create-a-primary-terminal-that-coordinates-focused-agents-will-you-go-into-that-or-was-that-already-that-part-where-you-had-the-timestamp-created",
      "text": "Okay, and also this, you wrote, create a primary terminal that coordinates focused agents. Will you go into that, or was that already that part where you had the timestamp created?",
      "level": 3
    },
    {
      "id": "also-what-is-the-when-i-m-already-at-it-what-is-that-cursor-thing-where-you-can-draw-did-you-mention-that",
      "text": "Also, what is the… when I'm already at it, what is that cursor thing where you can draw? Did you mention that?",
      "level": 3
    },
    {
      "id": "any-preference-on-which-agent-to-use-for-which-task",
      "text": "any preference on which agent to use for which task",
      "level": 3
    },
    {
      "id": "if-i-m-automating-a-workflow-in-typescript",
      "text": "if i'm automating a workflow in typescript",
      "level": 3
    },
    {
      "id": "how-do-you-mentally-keep-up-with-heavy-context-switching",
      "text": "How do you mentally keep up with heavy context-switching?",
      "level": 3
    },
    {
      "id": "what-do-you-use-scheduling-for-loops",
      "text": "what do you use scheduling for? loops?",
      "level": 3
    },
    {
      "id": "are-you-a-fan-of-these-fully-hackable-harnesses-like-pi-dev",
      "text": "Are you a fan of these fully hackable harnesses like pi.dev ?",
      "level": 3
    },
    {
      "id": "have-you-used-claude-design-its-pretty-good",
      "text": "have you used claude design? its pretty good",
      "level": 3
    },
    {
      "id": "do-you-limit-your-mcps-have-skills-call-the-mcps-instead-saw-executor-post-as-well",
      "text": "do you limit your mcps? have skills call the mcps instead? saw executor post as well",
      "level": 3
    },
    {
      "id": "do-you-have-any-ideas-on-how-to-create-levers-for-agents-so-they-can-do-big-data-stuff-without-having-all-the-data-in-their-context",
      "text": "Do you have any ideas on how to create levers for agents so they can do big data stuff without having all the data in their context?",
      "level": 3
    },
    {
      "id": "operational-playbooks",
      "text": "Operational playbooks",
      "level": 2
    },
    {
      "id": "recording-references",
      "text": "Recording references",
      "level": 2
    },
    {
      "id": "visual-reference-index",
      "text": "Visual reference index",
      "level": 3
    }
  ],
  "markdown": "# Use images, video, and task-shaped model routing\n\n> Original source pages and recordings require authorized access. The full article text here is public.\n\nThe practice is turning vague intent into useful signals your agents can actually build from: split work into focused CMUX sessions, pick models based on the shape of the task, use generated images as concrete design references, and use video when a sequence of code or UI state matters. John also draws a practical boundary between deterministic scripts or CLIs, fuzzy agent reasoning, MCP wrappers, and operational tools: do not over-abstract when a simple command would be clearer, safer, and easier to reason about.\n\n## Working outcomes\n\n- Run CMUX as a primary orchestrator with token-efficient flash models\n- Use image generation as a design reference and hand off image-to-design\n- Prompt with video and navigate the MCP-vs-CLI boundary\n\n## Concepts and consequences\n\n### CMUX as a primary orchestrator\n\nJohn demonstrates a main CMUX session opening specialized Codex panes for quality control, performance, research, and notes. The main pane becomes the coordinator, while each child pane has a narrow role and can work independently.\n\n**Why it matters:** This keeps context cleaner and makes delegation visible. It gives you a practical way to monitor several agent tracks without dumping every task into one large prompt thread.\n\n### Model choice by task shape\n\nJohn frames Codex as his default coding worker, especially when goal-following and token efficiency matter. Claude can be useful as a conversational manager or design helper, while Flash-style models are best for quick, tightly scoped tasks and weaker for long chains that require self-correction.\n\n**Why it matters:** Good model choice is a cost and reliability decision, not a brand preference. Matching the model to the task reduces wasted tokens and lowers the odds of an agent spiraling while trying to fix its own mistake.\n\n### Image generation as design reference\n\nFor UI work, John recommends generating sheets of visual variations before committing to a direction. For example, he describes taking a screenshot of a component and asking for many variations, then picking the favorite as the design direction.\n\n**Why it matters:** Images collapse ambiguity. They let non-designers express taste through selection, which is often easier than inventing exact CSS, spacing, motion, and layout language from scratch.\n\n### Video prompting for high-context intent\n\nJohn describes uploading video to Gemini by hand and also using scripts that upload to Google's backend to extract code snippets, key parts, timestamps, and screenshots. Video can preserve the flow of a demo or code walkthrough better than a written description because the model sees the sequence of states.\n\n**Why it matters:** When the task depends on timing, UI state, or code changing over time, video can carry intent that text misses. The practical caveat he names is that scripted backend use can involve cost and auth-token setup.\n\n### MCP versus CLI boundaries\n\nJohn warns that it can get weird to build a skill just to call an MCP wrapper when the skill could have called a CLI directly. His broader rule is to define boundaries around what needs tests, what needs flexibility, where memory belongs, and which agents should have access to which tools.\n\n**Why it matters:** Clear boundaries make agent systems easier to reason about. If a workflow is deterministic and testable, a direct CLI or script may be simpler than an unnecessary MCP layer; use agent reasoning where judgment, interpretation, or flexible planning actually adds value.\n\n## Reference tools and resources\n\n### CMUX\n\nThe workspace John uses to automate terminal tabs and panes, launch Codex sessions, name them by role, and coordinate multiple focused agent tracks.\n\n**Use when:** Reach for it when you want a visible multi-agent command center where one main session can create, name, monitor, and delegate to focused panes.\n\n[Reference](https://github.com/manaflow-ai/cmux)\n\n### Codex CLI\n\nThe coding agent John uses as his default programming worker in the workshop, especially for goal-driven implementation tasks and token-efficient coding work.\n\n**Use when:** Reach for it when the task is real code work that needs persistence, goal-following, and stronger follow-through than a tiny one-shot model.\n\nsearch: OpenAI Codex CLI\n\n### Google Gemini video prompting\n\nThe multimodal workflow John describes for processing screencasts into timestamps, screenshots, code snippets, and key moments.\n\n**Use when:** Reach for it when text alone is not enough to explain a demo, code walkthrough, or UI behavior over time.\n\nsearch: Google Gemini API video understanding\n\n### Impeccable\n\nA visual design-to-code workflow John briefly highlights as aligned with his image-to-design approach. He notes its recent npx impeccable CLI, Design.md output, generated-image workflow, and motion/delight features, but does not walk through using it.\n\n**Use when:** Reach for it when you want to explore turning generated design images into frontend implementation, while recognizing this section only gives a high-level overview.\n\nsearch: Impeccable npx impeccable CLI\n\n### gogcli\n\nA Google CLI workflow repository John shared while describing account automation across email and other Google services.\n\n**Use when:** Reach for it when exploring operational automation around Google account data, but be careful because these workflows can read, draft, send, or otherwise act on real account information.\n\n[Reference](https://github.com/openclaw/gogcli)\n\n## Recommendations and best practices\n\n- Create a reusable CMUX setup prompt that opens four panes with explicit roles such as Research, Quality Control, Performance, and Notes, then practice delegating one real subtask to a named pane.\n- Use Codex for coding work that needs goal-following and persistence. Use Claude when conversation or design help matters. Use Flash-style models for quick, tightly scoped tasks where speed matters and failure is cheap.\n- Before asking an agent to build or revise a UI, generate a sheet of visual variations and pick the direction you actually like. A selected reference image beats a vague taste prompt.\n- Use video when the important part is a sequence: a demo, a changing UI, a code walkthrough, or a moment where timestamps and screenshots matter.\n- Expect scripted video processing through Google's backend to involve auth-token setup and cost, even if manual drag-and-drop is still useful.\n- Keep deterministic automation in scripts or CLIs, and reserve agent reasoning for decisions, interpretation, and fuzzy planning. Do not wrap a CLI in MCP just because MCP is available.\n- Be careful with Google CLI-style account automation. John's example was powerful precisely because it could gather information and act on real email/account workflows.\n- Use a physical Pomodoro or off-keyboard reset ritual if you run many agents at once. The point is to force your brain to stop monitoring every pane continuously.\n- For scheduling, monitor actual outputs such as git diffs, PRs, Slack, email, or agent progress rather than only summarizing chat logs.\n\n## Practice and acceptance criteria\n\nPractice turning messy visual intent into concrete agent instructions using CMUX, generated references, video context, and clear tool boundaries.\n\n### Checklist\n\n1. Create a CMUX setup prompt that opens four named Codex sessions: Research, Quality Control, Performance, and Notes.\n2. Seed each pane with a narrow role prompt that states what it should inspect, produce, and avoid doing.\n3. Delegate one real subtask from the main pane to a specific child pane, then verify the main context stays clean.\n4. Pick one UI component or screenshot and generate a sheet of visual variations before asking an agent to code anything.\n5. Choose one favorite reference image and use it as the concrete design direction in the implementation prompt.\n6. Record a short screencast of a code or UI walkthrough, then ask a video-capable model for timestamps, screenshots, code snippets, and key moments.\n7. Audit one automation idea by separating deterministic scripts or CLIs from agent inference and MCP/tool access.\n8. Create one monitoring routine that checks actual git diffs or other real outputs instead of only summarizing agent conversation.\n\n### Four-Pane Orchestrator Drill\n\n**Difficulty:** Easy\n\nIn CMUX, write and run a setup prompt that creates Research, Quality Control, Performance, and Notes panes, then delegate a small codebase investigation to exactly one pane.\n\n**Done when:** The named panes open with distinct roles, the delegated pane produces a useful result, and the main pane can summarize progress without copying every child conversation.\n\n### Reference-First Component Direction\n\n**Difficulty:** Medium\n\nChoose a real component from a local project, generate a sheet of visual alternatives, select one direction, and hand that image plus a focused implementation request to Codex or your preferred coding agent.\n\n**Done when:** The implementation request points to one selected visual direction, and the resulting diff is focused on the intended component or files.\n\n### Video Extraction Brief\n\n**Difficulty:** Medium\n\nRecord a short screencast of a code or UI walkthrough, process it with a video-capable model, and turn the output into a brief with timestamps, screenshots, code snippets, and key moments.\n\n**Done when:** Someone who has not watched the full video can understand the important moments and where to look in the code or UI.\n\n### Boundary Audit and Refactor\n\n**Difficulty:** Hard\n\nTake one workflow that currently uses an agent for everything and redesign it so deterministic steps run through scripts or CLIs, fuzzy decisions stay with agents, and tool access boundaries are explicit.\n\n**Done when:** The final workflow has a clear boundary map, at least one testable CLI or script step, and a written explanation of what needs tests versus what needs flexibility.\n\n## Questions to test understanding\n\n### Why does the lesson recommend using CMUX as a primary orchestrator instead of running one huge agent thread?\n\n- **A.** It keeps each agent role focused and lets the main session coordinate work without mixing every task into one context.\n- **B.** It guarantees every child agent will produce correct code without review.\n- **C.** It replaces the need for Git, tests, or browser inspection.\n- **D.** It is only useful when all agents use the same model.\n\n**Answer: A.** The point is visible delegation: research, quality, performance, and notes can each run in a narrow context while the main pane coordinates. That reduces context mess and makes monitoring easier.\n\n### Which task is the best fit for a fast Flash-style model in this lesson's routing approach?\n\n- **A.** A long, multi-step refactor that will likely require repeated self-correction.\n- **B.** A small, tightly scoped task where speed matters and failure is cheap.\n- **C.** Owning the entire frontend implementation from scratch with no supervision.\n- **D.** Replacing deterministic scripts, CLIs, and tests.\n\n**Answer: B.** Flash-style models are useful when the task is constrained and speed matters. John warns that they can burn tokens or fall off the rails when forced into long sequential repair loops.\n\n### What is the main advantage of generating image variations before asking an agent to build a UI?\n\n- **A.** It removes the need to describe acceptance criteria.\n- **B.** It lets the learner select a concrete visual direction instead of relying on vague taste words.\n- **C.** It guarantees the implementation will match the image pixel-perfectly.\n- **D.** It prevents the agent from needing access to the codebase.\n\n**Answer: B.** A chosen reference image collapses ambiguity. It gives the coding or design agent a clearer target than prompts like 'make it more polished' or 'make the button better.'\n\n### What did John say makes video prompting valuable?\n\n- **A.** The model can see a sequence over time and extract things like timestamps, screenshots, code snippets, and key moments.\n- **B.** It is mainly useful when the model should ignore everything except the final screen.\n- **C.** It replaces the need to explain what happened in a code or UI walkthrough.\n- **D.** It is best for deterministic commands that can be tested with a shell script.\n\n**Answer: A.** John describes video plus code as giving the model a strong understanding of what happened over time. He specifically mentions timestamps, screenshots, code snippets, and key parts.\n\n### What is the lesson's practical rule of thumb for MCP versus CLI boundaries?\n\n- **A.** Wrap every CLI in MCP so the agent has one standard interface.\n- **B.** Avoid CLIs because agents can reason better without deterministic tools.\n- **C.** Use direct scripts or CLIs for deterministic work, and use agents where judgment or interpretation adds value.\n- **D.** Use MCP only for visual design work and never for operational automation.\n\n**Answer: C.** The lesson pushes against over-abstracting simple commands. If a workflow is deterministic and testable, a direct CLI or script may be safer and clearer than an unnecessary MCP wrapper.\n\n## Reflection prompts\n\n- Where in your current workflow are you using a vague prompt when a generated image, screenshot, or video would give the agent a better signal?\n- Which tasks in your stack deserve Codex-level persistence, which can go to a fast small model, and which should be handled by deterministic scripts or CLIs?\n- What is one MCP wrapper or agent tool in your setup that might be simpler, safer, and easier to test as a direct CLI call?\n\n## Further applications\n\n1. Write a one-page agent routing guide for your own stack: which model handles coding, design conversation, quick one-off tasks, video analysis, and deterministic CLI work.\n2. Build a small image-to-design exercise: screenshot one component, generate a sheet of design variations, pick one, then ask an agent to implement only that chosen direction.\n3. Record a short screencast of a code or UI walkthrough and test whether a video-capable model can extract timestamps, screenshots, code snippets, and key moments.\n4. Audit one workflow you currently automate and label each step as deterministic script or CLI, agent inference, MCP/tool access, or monitoring.\n5. Experiment with a CMUX monitoring routine that summarizes git diffs hourly, rather than summarizing chat logs, so you track actual code progress instead of agent chatter.\n\n## Applied exercises\n\nMulti-Agent Layout Experiment: Write a setup prompt for your preferred orchestrator (such as CMUX) that opens four distinct split panes. Assign each a unique system persona (e.g., Security Auditor, Performance Evaluator, Unit Tester, Documentation Writer). Practice routing a single code task out to one dedicated pane and verify that background tracking occurs independently of your central panel history.\n\n## Questions and answers\n\n### Okay, and also this, you wrote, create a primary terminal that coordinates focused agents. Will you go into that, or was that already that part where you had the timestamp created?\n\nExplains that you can tell CMUX to open distinct panels for focused roles (e.g., quality control, performance, research, note-taking) pre-seeded with specialized persona prompts. The primary session then operates as the core orchestrator delegating specific sub-tasks to these target sessions.\n\n### Also, what is the… when I'm already at it, what is that cursor thing where you can draw? Did you mention that?\n\nIt is called Clicklight.\n\n### any preference on which agent to use for which task\n\nCodex is the default programmer selection, outperforming alternatives in token efficiency (especially on Rust code bases). Claude is preferred as a conversational main orchestrator and for design scaffolding when no asset files are provided. Flash 3.5 is suitable strictly for fast, single-step execution but struggles to self-correct during sequential logic tasks. Gemini is unmatched for long-context multi-modal ingestion such as video code extraction.\n\n### if i'm automating a workflow in typescript\n\nIt depends heavily on the specific workflow and how deterministic it needs to be. You must separate the deterministic procedural parts (scripts via Terminal/CLI) from the fuzzy inference parts (intelligence via the Agent SDK).\n\n### How do you mentally keep up with heavy context-switching?\n\nUses a physical, rotating Pomodoro timer sitting directly on the desk set strictly to 25 minutes. When it signals, you must physically touch it, move away from the workstation entirely, and separate from agent monitors to let the brain relax and naturally reset.\n\n### what do you use scheduling for? loops?\n\nScheduling is primarily used for monitoring tasks: configuring agents to compile hourly diff reports to trace code progression vs. conversation chatter, scraping communication updates (Slack, Pull Requests, email metrics), or exporting hourly operational briefs to an e-ink display. For standard execution loops, simply supply a explicit array list combined with standard language definitions like \"for each of these things\" inside a goal-directed prompt loop until a completion condition is reached.\n\n### Are you a fan of these fully hackable harnesses like pi.dev ?\n\nHe likes what the pi.dev team is doing, but due to constrained bandwidth, he remains fully focused on his open-source Rust-based setup featuring Codex and CMUX.\n\n### have you used claude design? its pretty good\n\nHas used it a couple of times with good results, but notes that it tends to hand-hold through a single targeted path rather than generating massive layouts of design alternatives, which is his personal preference.\n\n### do you limit your mcps? have skills call the mcps instead? saw executor post as well\n\nMentions that Executor is preferred for single-agent systems calling multiple tools. He highlights that it gets visually redundant or confusing when an engineer constructs custom agent skills designed specifically to target an isolated MCP server wrapper when the underlying system could have simply called the native engine CLI directly. Acknowledges the community is currently in an unstandardized territory regarding these boundaries.\n\n### Do you have any ideas on how to create levers for agents so they can do big data stuff without having all the data in their context?\n\nExplicitly states he is not an expert on big data engineering integrations and refers the user to follow established, popular open-source data manipulation platforms rather than presenting speculative advice.\n\n## Operational playbooks\n\n- [Image-to-design handoff](/topics/foundations-image-to-design-playbook/)\n\n- [Design, Video, and QA Story Field Guide](/topics/foundations-design-video-qa-field-guide/)\n\n## Recording references\n\n- [Recording](https://codex-workshop-followup.pages.dev/video/lessons/lesson-06.mp4)\n\n[Timestamped source page](https://codex-workshop-followup.pages.dev/lesson-06.html)\n\n### Visual reference index\n\n- [02:02:41](https://codex-workshop-followup.pages.dev/lesson-06.html#clip-06-1): CMUX multi-pane splits displaying Quality Control, Performance, Research, and Notes window splits concurrently.\n- [02:04:04](https://codex-workshop-followup.pages.dev/lesson-06.html#clip-06-2): Active window prompt context where John commands the newly split background Research sub-agent panel.\n- [02:04:49](https://codex-workshop-followup.pages.dev/lesson-06.html#clip-06-3): On-screen annotation or menu moment while discussing the Clicklight drawing cursor tool.\n- [02:12:46](https://codex-workshop-followup.pages.dev/lesson-06.html#clip-06-4): Terminal workspace interface parameters linked with Google CLI scripting files configuration structure.\n- [02:13:37](https://codex-workshop-followup.pages.dev/lesson-06.html): Webcam perspective showcasing John holding the tangible rotating Pomodoro physical unit block.\n- [02:20:46](https://codex-workshop-followup.pages.dev/lesson-06.html): Impeccable system update release page detailing the npx impeccable command terminal instructions.\n- [02:21:49](https://codex-workshop-followup.pages.dev/lesson-06.html): Impeccable site section showing design-oriented examples and image-to-layout material.\n- [02:23:11](https://codex-workshop-followup.pages.dev/lesson-06.html): Visual evaluation of Impeccable browser interface elements containing the slop tab and live canvas module panels."
}
