Live hot-reload preview + session replay

From bet to muscle memory: making "say it, see it" reflexive

The previous days proved "conversation can build something runnable" and raised the foundations of rendering, assets and safety. This day's theme is polishing that loop from "runs once" into "comfortable to use" — changes visible instantly, history never lost, the agent never confused about which target it's acting on. These all sound like experiences that "should just work," but behind each is a real engineering gap being filled. Only once they're all filled does the platform go from "can demo" to "can sit down and use for hours."

Live hot-reload preview: edit a file, the picture changes itself

This day connected the center preview to a "hot-reload bridge": when a game's files change, the preview refreshes itself to show the latest, with no manual reload click. It works by the backend continuously watching for file changes in that game's directory and, the moment something changes, notifying the front end over a real-time channel, which reloads the preview. This may look like "saving a click," but it's a vital link in the "say it, see it" loop: the instant the agent finishes editing, you see the result on screen almost immediately, squeezing the latency between conversation and picture to a minimum. For someone sitting down to make a game for hours, this "what you change is what you see" instant feedback is what connects inspiration to implementation.

Session replay: reopen a session and the back-and-forth comes back

Collaborate with AI long enough and the session history becomes a precious asset — the requirements you raised, the decisions it made, the detours taken. This day persisted session history into a durable "ledger" and made reopening a session replay the prior back-and-forth from it. One technical subtlety was handled: the real-time event stream carries only lightweight records of "what happened," not the full text, so replay must reconstruct the real content from the ledger rather than naively replaying events. The significance: close it and come back, and context isn't lost; a stretch of history can be revisited anytime, just as it happened. This makes "working on a project long-term, over many rounds" possible, instead of starting from a blank page each time.

Composable shaders + cross-file hot-reload

The engine gave shaders a "composable" capability this day: shaders can import one another, share fragments, and parameterize with macro definitions, instead of piling all code into one file. Better still, it supports cross-file hot-reload — edit a shared fragment that others reference and every shader using it refreshes instantly. For someone crafting visual effects, this means organizing shader code like building blocks: factor common lighting, noise and color processing into reusable modules referenced everywhere; change one and it takes effect everywhere, seen at once. It turns "writing effects" from "trial-and-error against one big blob" into "composing reusable modules and tuning live" — a real expansion of rendering expressiveness.

A unified engine console: one execution channel, consistent everywhere

The engine unified its "console" debug/inspect channel this day into a single abstraction: the backend converges to one execution channel, while the command-line side offers a lighter read-only inspect entry. The benefit of unifying is consistent behavior and a simpler mental model — wherever you initiate an inspect or execute, it travels the same orderly path, rather than each place having its own slightly-different version. Such convergence in abstraction is usually invisible on the user's side, but it decides whether a system grows messier as features pile up. Converging "how the console works" into one authoritative channel early sets the same rules for every capability that later plugs into the console.

New games ship a runnable starter + the agent always knows which game

This day filled in two details that make "creating a game" smoother. One: a new game ships with a directly-runnable starter (a spinning-cube opening), so the moment you create it you see a picture, instead of staring at a blank and writing from scratch. Two: the context of "which game you're currently working on" is fed explicitly into the agent's system prompt, so it clearly knows which game to write code into. The latter fixes a dangerous pitfall — with multiple games coexisting, an agent unsure of the current target easily edits the wrong place. Making the "active game" an explicit, reliably-passed context is like giving the agent a compass that won't point wrong.

The backend keeps it solid: more tests, path redaction, name validation

The backend kept up its rhythm of "pinning behavior down with tests," adding another large batch of end-to-end probes and unit tests. A few focuses: locking game and project naming rules with many cases (which names are valid, which should be rejected, every boundary guarded by tests), continuing to redact the user's home path in outward responses (no leaking your machine's real paths), and extracting key logic like building the system prompt into a pure, separately-testable function. None of these are flashy features; they're the daily work of "making a file-editing system worthy of trust." Notably, this day also adapted to another coding backend's event format, smoothing the integration of more model-driving options — one more choice, a consistent experience.

What this day means

Seen together, the through-line is clear: make "build while talking" not just possible but frictionless. Changes visible instantly (hot-reload), history fully recoverable (session replay), effects organized like building blocks (composable shaders), the agent never editing the wrong target (active-game context), the backend worthy of trust (tests and redaction) — each removes a small friction that would break flow. Whether a tool is pleasant to use often hinges less on whether it can do one big thing than on how smoothly it does the hundred small everyday ones. What this day filled in were several of the most crucial among those hundred.