This weekend I said five words to my server — "make me a page of my open tasks" — and it answered with a URL. The page at that URL didn't exist when I started the sentence. It exists now: a live count, a live list, scoped to my permissions, updating in real time, sitting in my navigation menu. Nobody wrote it. There is no code for it anywhere.
Here's the transcript, in full:
```
> Make me a page of my open tasks
tools: create_record(201)
Your page is at /views/26b247ed-...
```
One tool call. `create_record`. That's the whole trick, and it's worth explaining, because the trick is that there is no trick.
## The page is a record
The obvious way to build "AI makes you a page" is to have the AI generate frontend code — components, markup, a little app. Everyone demos this. It's fragile, it's unreviewable, and it produces a thousand snowflake pages nobody can maintain.
We did the opposite. In this system, a page is a **record** — a row of data in a collection called `views`. The record says: here's a title, here's a list of blocks — *a count of tasks matching this filter, a list sorted newest-first, a paragraph of text*. One universal renderer reads any such record and materializes the page from generated components. The AI never writes markup. It writes **data describing a page**, and the machine it lives in does the rendering.
Once a page is a record, everything hard about "dynamic UI" turns out to be already solved, because the system already treats records seriously:
- **Permissions are inherited.** Every block fetches through the viewer's own session against the same permission engine as everything else. A page can't leak what the engine wouldn't serve. Nobody wrote a security layer for AI-generated pages — there's nothing to write.
- **It's live.** The page subscribes to its own record over the same websocket everything else uses. Edit the record — by hand, or by asking — and the page reshapes in front of you.
- **It's accountable.** The AI creating your page is just a principal writing a record, so the change is attributed, versioned, and revertible like any other. "The AI changed my software" is a signed ledger entry, not a mystery.
- **It's editable by conversation or by form.** A view record is ordinary data. You can open it in a generated form and tweak a filter, or just say "add the approved ones too."
The entire feature was one schema, one renderer object, and a paragraph of instructions telling the assistant the collection exists. That's not a small implementation of a big idea. That's the actual size of the idea, once the substrate is right.
## Pages can't vibe
The first page it built me taught me something I didn't expect.
Earlier, in chat, I'd asked "what tasks are open?" and gotten a friendly prose answer: *here are your five open tasks*, with a nice list. Then the generated page came back showing **zero**. The page was right. None of those tasks actually had status `open` — they were approved, or waiting, or blank. The chatbot had listed everything and cheerfully called it open.
Prose answers are the model narrating. Pages are the system *computing*. A count block can't round up, can't hallucinate, can't be agreeable. If we're going to let AI answer questions about our data, the answers should be made of queries, not vibes — and the easiest way to get that is to have the AI build the page instead of telling you what it thinks the page would say.
## And it's fast — which is the strangest part
Every page on this system renders in about 40–50 milliseconds over HTTPS, TLS included. The AI-materialized ones land under 200ms. Speech synthesis for the voice mode: 78ms, on-box, with a free synthesizer. Live updates arrive over one websocket connection carrying tiny signals. The background worker that does scheduled work idles at 16MB of RAM. All of it runs on a single $7/month virtual machine — the storage engine, the permission engine, the realtime hub, the AI gateway, the speech, and every app.
Meanwhile the industry's ordinary experience is the opposite: multi-second page loads from stacks that ship megabytes of JavaScript, most SaaS still making you refresh to see whether anything changed, "real-time" sold as a premium feature. Slower, while doing less.
The reason isn't heroics. It's subtraction. There's no build step, no bundler, no ORM translating between two worlds, no framework tax, no fleet of services holding each other up. Data is plain files fast enough that caching them in-process makes reads take microseconds. The UI is generated from schema, so there's barely any frontend to ship. It's fast because it does less *machinery* — which is what lets it do more *work*.
## Why this was so hard for AI to see
Here's the part I find genuinely strange: this feature — the one that most empowers an AI — is the one AI had the most trouble conceiving. We worked with frontier models on this design, and watched one of the strongest of them struggle with it repeatedly. The reasons say something about where software is right now.
**The answer looks like nothing.** In every stack a model learns from, "dynamic UI" would be an enormous build — a component framework, a protocol, a rendering pipeline. The frontend-framework industry is, by sheer mass, the largest workaround layer in software: thirty years of machinery that exists *because UI isn't data*. A mind trained on that corpus, asked for dynamic UI, goes looking for the machinery. When the real answer is "a record and a sentence," it doesn't register as an answer. It registers as not having started yet.
**It's a compound belief.** Views-as-records only works if you believe six things simultaneously and completely: UI is a projection of schema, records are live, the AI is a principal, permissions are inherited, changes are attributed, structure is data. The design sits at the intersection of all of them at once. Believe each at sixty percent and the product is five percent — the idea stays invisible even while every ingredient is in front of you.
**There was nothing to pattern-match.** Generated forms have precedent going back to the 1980s. Append-only storage is as old as logs. But "the conversation writes the interface, as data" has almost no examples anywhere, because the substrate for it never existed to be learned from. Models amplify their training substrate the same way they amplify their runtime substrate — and the training substrate is the old world. The new thing had to be built before it could be believed.
Which is, if you squint, the most hopeful sentence in this post. Every system like this that gets built and documented becomes corpus. We are writing the priors that will make the next generation of models find all of this obvious.
## The stack, for the curious
Single VM. Python standard library only — no framework, no database server. Records are tab-separated files you can open in a text editor; an append-only mode and a few tiny derived indexes make them fast at millions of rows. One permission engine for humans and AI agents alike. Every write attributed. UI generated from schema; pages as records; one websocket for liveness; browser speech recognition in, espeak out. The whole thing is open source (MIT): [dbbasic-object-server](https://github.com/askrobots/dbbasic-object-server).
Say something to it. It'll show you.