All work

Personal

Moreno Home

A family wall display, built by agents from a shared vault.

The story
Moreno Home wall interface with Today, Music and Outside cards on dark glass, shown with example data
The real Svelte interface, rendered with example data.

A touch-first wall display for a family home, and the operating model that let AI agents build it inside a lived-in house: one versioned vault, adversarial review and written rules for touching live hardware. The wall app itself makes no model calls.

The problem

A family display and a home control panel are usually two products. Each does half the job, and both put a subscription or a vendor cloud in the path. I wanted one self-built, local-first surface where every control is safe for anyone in the family to press.

The harder problem was the work around it. A house is not a sandbox. The speakers play in rooms people are living in, and I run several AI sessions against the same working tree at once. Agents could write the software. They needed an operating model that let them do it without losing work, re-arguing settled questions or touching the house carelessly.

What I built

Two things. Casa Moreno is a SvelteKit wall app with idle, awake, night and off states: a quiet frame most of the day, music, weather and the day’s plans on touch, a dark clock at night. Music browses through the Spotify Web API and plays through the speakers’ local queue, so control never leaves the home network. Weather leads with today and tomorrow, with radar recoloured into the interface’s own palette.

The second is the system that built it. A versioned vault is the source of truth: one task file per open loop, a change log that keeps failed attempts, and a decisions file that records the options each decision rejected. /close-out ends a session by the book. It logs the work, folds durable facts into the vault, scans the staged diff for literal secrets, commits by explicit path and confirms the remote repository is still private.

How I built it with AI

Claude Code sessions wrote the code and the vault; 15 of 16 commits carry a Claude co-author trailer. Codex joined later through a thin adapter that reads the same close-out command file, so the process has one copy.

The pattern that held up was architect, executor, skeptic. For the third interface round, an architect session had three research agents check radar, tide and performance sources against live APIs, not model memory. It then wrote a self-contained spec with one instruction: if reality contradicts this, stop and flag it. A separate executor built from it and flagged five contradictions, including a tide API path that returned 403 on every request. Finder agents then read the diff through seven lenses, and an independent skeptic attacked every candidate before it counted: 23 candidates, 14 confirmed, all 14 fixed. The worst was the executor’s own new slider, which could change a real speaker’s volume when a vertical scroll drifted sideways.

The same method caught the expensive bugs early. A 32-agent review of code that briefly borrowed an idle speaker’s queue found 25 defects, six of them data-loss paths. The headline case: a song a family member queued from the Sonos app during that borrow would have been silently deleted. The fix became a standing rule: remove only the exact range the speaker reported adding, under a lock shared with playback.

Design ran through a critique loop. I re-rolled the first concepts twice and steered to “think macOS glass.” A fresh reviewer subagent returned “fix” with five findings; the next pass caught a regression the fixes introduced, then returned “ship.” A documenter wrote the design system from the built UI, so later agents work from what exists. Later, agents built three launcher studies side by side. I chose one and set the order: music first, lights and calendar second.

Measurement stayed honest. The executor found that preview URLs froze every animation, so earlier performance traces had measured a still frame. It fixed that before optimising anything. Tablet frame times are still marked unverified.

Where AI stayed out

The running app. The wall makes no model calls. I tested Sonos’s hosted MCP server through a self-hosted household agent, and it played music without touching the queue. But it can’t choose whose account streams, has no queue tools, and its terms forbid hardcoded tool calls behind buttons. It stays a conversational extra. A button on the wall does the same thing every time, on the local network.

Family photos. Background scenery was generated, and each image ships with its prompt and a note that it is not a photograph of the home. Family photos come only from the family.

False precision. The fishing view shows tides, moon and pressure, not a composite 0–100 “bite score”: the best measured lunar effect is about 5%, and commercial scores publish no methodology. Golden-light times say they are approximate.

The house itself. Agents survey read-only first. Audible tests run on a muted or idle speaker, with queue and volume restored and the restore verified. Once, an agent’s request guard turned out to be theatre: its browser tool runs JavaScript in an isolated world, so a real speaker’s volume changed. Nothing was playing; it was restored and verified within about two minutes, and the agent wrote the rule: you cannot sandbox the page from the browser tool. Interaction tests now run against a demo server with simulated speakers.

The decisions. Agents bring evidence; I decide. The repository stays private because the vault is a map of an occupied house. When a close-out nearly committed twelve files another session was still editing, an mtime check caught it, and I made the rule permanent: “I work in multiple sessions all the time. very important things don’t get overwritten.”

Where it is now

The wall app runs locally, passes type checks and builds, and has five focused test suites. It isn’t on the wall yet: that needs a Node adapter and a small always-on local server, and touch, distance and performance acceptance wait for the screen. The household agent with speaker control is live. A TV art workflow is paired read-only and parked before its first upload.

What carries over is the operating model: a shared record any agent can start cold from, specs checked against reality, agent output reviewed by agents built to disagree, and decisions that keep their rejected options.

  • 15 of 16commits co-authored by Claude
  • 14 of 23review findings that survived a skeptic, all fixed
  • 6queue data-loss paths caught by review before use

A project, over time.

The milestones that shaped it, in order.

  1. A vault, then a first screen

    The project became a versioned vault with task files, a change log and a decisions file. The first home screen was shaped with a design skill and reviewed by a fresh subagent until it returned "ship".

  2. Playback proven on live APIs

    Live probes ruled out Spotify Connect, so playback moved to the speakers' local queue. A 33-agent research pass reached the same architecture on its own, and a 32-agent review found six data-loss paths in the queue code.

  3. Close-out and concurrent-session rules

    A /close-out command now ends sessions by the book. A near-miss with another session's uncommitted work became a standing rule: stage by explicit path, never stash or reset what you didn't create.

  4. Architect, executor, skeptic

    An architect session wrote a spec from research checked against live APIs. An executor built it and flagged five places reality contradicted the spec; review confirmed 14 of 23 candidate findings, and all 14 were fixed.

  5. One map for any harness

    A root AGENTS.md gave any agent the project map, commands, design rules and privacy limits. The wall gained a scheduled light-by-day, dark-by-night appearance.

  6. Three studies, one choice

    Agents built three launcher studies side by side. I chose Quiet Frame and set the priorities, and it was adopted into the app with a simulated demo server for testing.

  7. Codex shares the process

    A thin adapter lets Codex run the same close-out command file as Claude Code, so the workflow has one copy. A Codex session paired with the TV's art API and read it without changing anything.

  8. Sonos MCP: useful, not the engine

    Sonos's hosted MCP server was connected to a self-hosted household agent and tested live. It works as a conversational remote but can't route by person or touch the queue, so the wall keeps its local path.