Skip to content
yalt8826.com
← projects/
projects/vivarium/in developmentaideveloper tool

Vivarium

An AI app builder that keeps asking until your idea is fully specified, then builds it in phases, with tests written by a different agent than the code.

Built solo · Sept 2026 – ongoing

01 / overview

Where ideas come alive.

One day the thought just hit me: why not build an app builder that actually works, with every feature I'd want from one? You describe an application; Vivarium questions you until the idea is specified well enough to build, shows you a preview to approve, then generates a working full-stack app phase by phase, on your own machine.

Most AI builders fail in the same two places: they stop asking questions too early, and the model that writes the code also writes the tests that check it. Vivarium is designed around avoiding both.

170design decisions written down
8Python subsystems
107conformance tests
2 / 8build phases complete
02 / how it will work

From a paragraph to a running app.

grillchecklist engine
questions until the spec is completespec.json
previewyou approve
clickable frontend with fake dataevery service in plain wordsthe data model
planplanner agent
tests written firstAPI contractswhat's critical
buildbuilder agents
phase by phaserun, verify, repaircan't touch tests/
editin the running app
right-click any elementdiff + commit
03 / the key ideas

The three rules it's built around.

01 · the grillThe checklist decides when to stop

A classifier picks the kind of app (dashboard, marketplace, chat, workflow…), which selects a checklist. The interview ends when the checklist is satisfied, not when the model feels done. A model that asks five questions and declares itself satisfied builds the wrong thing.

02 · separate testersThe code writer can't write the tests

A planner writes the tests first. Builder agents write the app and are blocked from the tests folder by filesystem permissions and pre-commit checks. If one agent writes both, it writes tests that pass.

03 · right-click to editPoint at the thing you want changed

In development builds, every element is stamped with the file and line that made it. Right-click something in the running app and the model gets the real source location, not a guess.

Underneath all three is an append-only project memory. Every decision you make is recorded with where it came from (you, a default, an inference, an agent), and your own choices are binding: no agent may overwrite them. Secret values never enter a model's context.

04 / the foundation

The parts with no AI in them come first.

Four subsystems carry most of the system's correctness guarantees, and none of them use a model: the store (project memory as append-only JSONL in git, with SQLite rebuilt from it), the templates (hand-built reference code every project starts from), the index (how the code fits together), and the server (a read-only view other AI tools can query).

“The server reads. The supervisor executes. The store records. The template constrains.”

05 / roadmap

Phase 2 of 8, underway.

  1. phase 0 · doneRecord store: append-only memory with provenance
  2. phase 1 · doneTemplates and the local dev runtime
  3. phase 2 · in progressIndexer: structural and semantic code maps
  4. phase 3Read-only MCP server
  5. phase 4Three-view preview generator
  6. phase 5Planner agent: contracts and tests
  7. phase 6Builder agents: run, verify, repair
  8. phase 7Build presentation: live event stream