The organizing claim of this line of work has been: cheap generation makes verification the scarce discipline. When producing a candidate — code, a patch, a design — is nearly free, the binding constraint is no longer making it; it is knowing which candidates are correct. System reliability is bounded by the verifier, not the generator.

You verify by seeing, not reasoning. Reasoning about whether code is right is itself a form of generation — it produces a plausible story. Verification is observation: running it, and looking at what actually happened. And observation of a running system is exactly Bret Victor's demand that a creator have an immediate connection to what they make — that behavior, flow, and state be made visible rather than simulated in the head (Victor 2012a, 2012b).

Cheap generation makes verification scarce; you verify by seeing; therefore cheap generation makes visibility scarce — the valuable tooling shifts from helping you write (autocomplete, codegen) to helping you see what the written thing does. The generator emits plausible-looking wrongness at scale; only surfacing the actual runtime state catches it. The expensive failures are the silent ones — the run that returns a believable result instead of an error — and the silent failures live precisely in the state you cannot see.

Under cheap generation the shopping list changes. What is worth building, buying, or handing an agent is the set of instruments that make some layer of the system visible enough to verify. They sort by which layer they expose and at what granularity — a point, a flow, or a history.

The rendered artifact is not its telemetry. The most under-served instrument is the one that shows the thing itself — the rendered DOM, the actual image, the real output — rather than logs or execution telemetry about it. Telemetry is a lossy projection chosen in advance; verification often needs the artifact unprojected. For an autonomous agent this is decisive: to verify a UI change it must see the render, not infer it from a log line.

Static and dynamic are both visibility. A code index (LSP, an AST-level search, a call graph) makes structure visible before anything runs; a tracer makes behavior visible after. Both are the same act at different times — turning an invisible relationship into something you can look at.

These came out of a literate rebuild of a Common Lisp textbook under a current toolchain — the pedagogy testbed for this program. Each is a small, reproducible instance of the thesis: invisible state hid a fact, and surfacing it settled the question.

Every ecosystem has grown the same two-move pattern — a pipe that emits hidden state and a renderer that draws it — and the mature libraries expose runtime state as plain data on purpose.

The split is cleanest in Clojure: tap> is a language primitive whose only job is to hand a value to whatever is listening, and Portal, Reveal, and FlowStorm are interchangeable listeners. Decoupling emit from render is the lesson to steal.

Two entries carry disproportionate weight for the argument. Haskell is the hard case: laziness makes state genuinely invisible — a thunk is a promise, not a value — and ghc-vis draws the heap including unforced thunks, so you watch evaluation happen; nothing else here shows the shape of what has not run yet. Elixir/BEAM was built introspectable for live systems: :sys.get_state reaches into any running process and returns its state, and :observer shows ETS contents live — "see the running system" as a platform feature, not a bolt-on.

The cache thread closes the loop. Memoization is the miniature: the cache is the invisible state, and the mature libraries expose it on purpose — Clojure's core.memoize ships snapshot (the cache as a plain map at an instant) and memo-clear!; Elixir memoizes with ETS, whose :ets.tab2list/1 is the cache as a visible table. Expose the state as data, then render it. For a recursive fib the snapshot is the trace, spatially.

Speculative — a conjecture about where the history axis of visibility becomes tractable, not a settled claim.

Debugging shows state at a point; tracing shows a flow; time-travel debugging shows the whole history, scrubbable. FlowStorm for Clojure, rr's record-and-replay (O’Callahan et al. 2017), and Redux DevTools are the mainstream realizations of Victor's "make time visible." The miniature already appears in the findings above: a memoized function's cache filling 0,1,…,n bottom-up is a micro-time-travel — the table is the history of the computation. Where this connects to the repl-driven forking work is the open question: a REPL session's fork tree and a debugger's replay history are the same structure seen from two directions.

Within this program, this note is the visibility companion to threads already laid down:

• Verification & reliability spine — formal transformer verification and goldberry frontend invariants (invariants + property testing as correctness made checkable), alloy specification.
• Verify-by-running — the repl-driven cluster (chat mutation, compliance, flight tracking): the REPL is the visibility instrument; this note names why.
• One-spec, many lenses — type systems: one tool, four ways and reversible pipeline transforms. Types make constraints visible at compile time; the instruments here make state visible at run time — the same move, a different clock.
• Agents need eyes — the agent cluster (agent-telemetry, agent-memory, agent-sandbox) is this thesis under automation: an agent under cheap generation is the extreme case, and "context = the rendered artifact, not its telemetry" is a design constraint for agent harnesses, not a nicety.

The debugger / observability / time-travel axis is nearly absent from the prior corpus; this note annexes it and wires it to the spine above.

This research corpus already practices the thesis on its own prose: headings carry :CUSTOM_ID: so skeptic and claim-validator agents can attach :VERIFIED_AT: / :VERDICT: / :FINDING: drawers, and disputed claims are marked rather than buried. That review apparatus is visibility-is-verification applied to argument — a claim you can see the verdict on is a claim you can trust.

• SPLASH/ISSTA 2026 — Unlocking Safe Agentic Autonomy through Verification, The Checkability Boundary, and the debugger-visualization talks.
• Clojure/Conj 2026 — Patrick de Kruif's source inspector and Juliana Prieto's production traces in the REPL: knowing by seeing.
• Atlassian Team '26 Europe: Closing the context gap — "verified delivery" with verification evidence attached to the Jira work item.
• Atlassian Team '26 Europe: The SDLC, upgraded — the claim that AI gains plateau because tools optimize the share of the day spent writing code.
• Boston AI Week 2026: AI Software Factory with a Human in the Loop — Eli Whitney's staged interchangeable-parts demonstration: a demo taken as proof, the failure this note's instruments are meant to catch.