Have your agent record video demos of its work with shot-scraper video

Simon Willison (Simon Willison's Newsletter) · email · 2026-06-30 source ↗ Reader 🖥️

Agent-Native Design Agent Self-Documentation Agent Skills Agentic Engineering Coding Agents Feedback Loops Human-in-the-Loop Multi-Agent Orchestration

Coding agents should record video demos of their own work, and the tooling that enables it — shot-scraper's new storyboard-driven `video` command — is itself best built by an agent and driven straight from its `--help` output, so the human's remaining job is reviewing the design rather than writing the code.

practical · Weekly weblog roundup newsletter (announcement + build-log), practical/how-to register — This is a Simon Willison newsletter roundup: two feature write-ups (shot-scraper video; sqlite-utils 4.0rc2 written by Claude Fable) plus ~10 links, 6 quotations, 4 notes, 3 releases, 1 research report and 1 tool. The opening sponsor blurb (Sonar / Gartner) is advertising and is ignored. The extraction is centered on the primary substantive piece — the shot-scraper video feature for having a coding agent record video demos of its own work — with a few strong secondary ideas captured from the sqlite-utils piece and the roundup items (cross-family review, review-docs-first, understand-to-participate, cheaper-model delegation).

Structure

Part	Role
Feature announcement + worked demo	Introduces `shot-scraper video` (shot-scraper 1.10): a `storyboard.yml` routine recorded via Playwright, shown with a full Datasette bulk-insert demo storyboard.
'The agent drove it' reveal	Shows the entire storyboard was written by GPT-5.5 xhigh in Codex Desktop from a 3-line prompt, and names the '--help as embedded SKILL.md' pattern.
'How I built this'	Build log: agent wrote the feature code and its documentation; Pydantic used to define/validate the format; reviewing the docs was how Willison steered the design; activation-cost reflection (issue open since Feb 2024).
Secondary piece — sqlite-utils 4.0rc2 (Claude Fable)	A release-hardening story: Fable found 5 release blockers (incl. a delete_where data-loss bug) via code review, a GPT-5.5 cross-family review found 2 more, cost tracked at $149.25, release notes outsourced.
Roundup fragments (links, quotes, notes, releases)	Jon Udell's 'agent in the loop' reframing, Geoffrey Litt's 'understand to participate', a prompt-injection challenge, cheaper-model subagent delegation, 'Better Models: Worse Tools', DSPy prompt evals.

Key terms

shot-scraper video / storyboard.yml
A new shot-scraper command that takes a YAML 'storyboard' (server to launch, URL, viewport, scenes of click/fill/wait steps) and uses Playwright's screencast to record a controlled video of a web app being exercised.
agentic self-documentation (agent-recorded demos) Agent Self-Documentation
The practice of having a coding agent produce reviewable artifacts of its own work — here a video demo — so a human can see what it built.
'--help as embedded SKILL.md'
The pattern where a command's `--help` output carries enough usage detail that a coding agent can drive the tool from it alone — functioning 'like bundling a SKILL.md file directly inside the tool.'
cross-family review Multi-Agent Orchestration
Habitually having one lab's best model review another's output (Anthropic's model reviews OpenAI's work and vice versa) because differing blind spots surface real issues.
review-the-documentation-first
Reviewing an agent's documentation edits before its code as the fastest way to build a mental model of what a large agent-produced change actually did.

Propositions

explicitCoding agents should produce demos — especially video demos — of the work they do, as a routine part of agentic development.conf: high
explicitshot-scraper video records a Playwright video of a web application being exercised through a routine declared in a storyboard.yml file (server, URL, viewport, scenes of click/fill/wait steps).conf: high
explicitA coding agent can drive the entire demo pipeline from a short natural-language prompt — reviewing the branch, reading the command's --help, spinning up a dev server, authoring the storyboard, and producing the video — with no human-written configuration.conf: high
supportsWith Android CLI, Google is Making the Android Toolchain Agent-Friendly · p6 — A coding agent driving a real CLI end-to-end from its --help alone is a concrete instance of the argued need for vendors to design first-class, agent-drivable tool surfaces.
explicitA command's --help output can carry enough detail for a coding agent to use the tool correctly, functioning like a SKILL.md bundled directly inside the tool and removing the need for a separate agent-instruction file.conf: high
extendsWith Android CLI, Google is Making the Android Toolchain Agent-Friendly · p3 — Extends 'SKILL.md files encode workflows better than per-prompt docs' to the tool's own --help output serving as the embedded skill, dropping the separate file entirely.
explicitHaving the agent write the feature's documentation gives the human the most useful frame for reviewing the design, because much of the design iteration comes from spotting redundant, inconsistent or confusing prose in the generated docs.conf: high
explicitDefining the config format with Pydantic (to both declare and validate it) was chosen partly to make the agent-generated design easier for the human to review.conf: medium
explicitCoding-agent support lowers the activation cost of building features enough that ones that would otherwise never get done — here an issue open since February 2024 — actually get shipped.conf: high
implicitestablishedWhen an agent writes the code, the human's residual, non-delegable contribution concentrates in judgment at the design and review layer — reviewing documentation, demos and edge-case behavior — rather than in typing code.conf: high
supports ←Agentic Code Review · p12 — Both hold that when an agent writes the code the human's residual, non-delegable contribution concentrates in judgment at the design/review layer; this doc sharpens it into 'human in the loop becomes human on the loop'.
supports ←Podcast: Formal Methods for Every Engineer in an AI-Powered Future · p17 — Both locate the non-delegable human contribution in judging edge-case behaviour rather than typing code; formal methods are Moreira's precise language for that residual work.
explicitestablishedHaving one model family habitually review another's output ('cross-family review') reliably surfaces real issues and is worth doing as standard practice, despite initially seeming superstitious.conf: high
supportsGitHub Copilot CLI combines model families for a second opinion · p5 — Willison's habitual Anthropic-reviews-OpenAI-and-vice-versa practice is direct practitioner corroboration that cross-family diversity beats same-model self-reflection.
supportsProject Glasswing: what Mythos showed us · p11 — Corroborates that a reviewer with a different model (and prompt) is more effective than asking the original agent to check its own work.
supports ←Agentic Code Review · p10 — Willison's 'cross-family review reliably surfaces real issues and is worth doing as standard practice' gets empirical backing here: four differently-built reviewers over 146 PRs flagged 93.4% of locations by exactly one tool and none by all four, so heterogeneity — not picking a single best tool — is the point.
supports ←How I write software with LLMs · p5 — Both independently describe cross-family/cross-model review as reliably catching real issues that same-model self-review misses, despite initially sounding superstitious.
explicitReviewing an agent's documentation edits first is an effective way to build an initial mental model of what changed in a large agent-produced change.conf: high
explicitSome categories of writing — such as release notes — are safe to outsource to agents precisely because they should be boring, predictable and accurate, and the agent's output can be better than the human's hand-written version.conf: medium
explicitYou must understand agent-produced code to a depth that lets you keep participating creatively in the project; a rich set of concepts in your head is what preserves your ability to move the work forward, and drifting from it is cognitive debt.conf: medium
explicitRouting implementation work to cheaper, lower-power models in subagents while keeping judgment, review and synthesis on the top model is a practical way to cut the real (unsubsidized) cost of agentic work.conf: medium

Arguments

Building tools that a coding agent can drive end-to-end from its --help output, so the agent can record demos of its own work, is a worthwhile and now-practical pattern for agentic engineering. strength: medium

Explicit premises:

shot-scraper video can record a controlled Playwright video of a web app from a declarative storyboard.
GPT-5.5 xhigh authored the entire storyboard and drove the recording from a three-line prompt, using only the command's --help.
The --help output worked like a SKILL.md bundled inside the tool.
The feature itself (code, docs, format) was written by the agent, with the human reviewing the design via its documentation.

Implicit premises:

A human can adequately catch design problems by reviewing an agent's documentation and watching a demo video — this reviewing capacity is the load-bearing assumption of the whole loop.
A scripted demo that runs to completion is taken as evidence the feature works, even though the storyboard exercises a predetermined happy path (and even stubs navigator.clipboard via injected JS) — so it demonstrates 'the flow runs as scripted', not 'the feature is correct'.
The command's --help will stay accurate, complete and token-cheap enough to remain a reliable agent instruction as the tool evolves.
The recorded artifact reflects real application behavior because Playwright drives the actual app, not a mock (mostly true here, with the clipboard exception).

Inferences:

From 'an agent drove a real feature build and demo from --help alone' to 'agent-drivable tooling is a generally good pattern' — an existence proof generalized to a design principle.

Cross-family model review should be a habitual step in agent-assisted software work. strength: medium