The Generator Was the Wrong Instinct

Last year I built a small tool I am still a little proud of. Give it a title and some content and it generates a slide deck: one self-contained HTML file, no dependencies, opens in any browser, prints to a clean PDF. It holds a house style, a fixed palette and hard geometry, so that whatever comes out is on-brand whether I look at it or not. It works. It has worked ever since. And the way it works is a generator: intent goes in one end, a finished artifact comes out the other, and the code in between is the only thing that ever writes a file.

That is a good shape, and reaching for it is the correct reflex when you wire a language model to a file format. I want to be clear about that up front, because this is a story about the same instinct being right for years and then, one format later, being specifically and instructively wrong.

The next format was Bento. If you have not seen it: a Bento deck is a single .bento.html file that carries its own editor. You open the file and you are not looking at a rendered slideshow, you are looking at a running application: viewer, editor, and document folded into one artifact, with no server, no account, and no cloud link behind it. Its makers call it the office suite that fits in a file, and they mean it literally: Slides is the first app, with Docs and Sheets to follow, each one shipping as its own self-contained file with the app inside it. The pitch is portability, the pitch is correct, and it quietly undersells what actually happens.

Here is what actually happens. Because the file is the app, the file is editable by a human, in the browser, at any time. Bento leans all the way into this; its makers even ship an agent skill so an assistant can take make me a deck about X from an empty folder to a finished, opened file in a single pass. Wiring my own assistant to it was the obvious move. So I built my slide generator again, the proven shape, pointed at the new format. And the instinct that had been right for a year broke on contact.

A generator is write-only

A generator maps one direction: intent to artifact. That is not a limitation when the artifact is dead on arrival. My old decks are static HTML. You open one, you read it, you export a PDF. Nobody drags a rectangle four pixels to the left. There is exactly one author and it lives upstream, in the code, and the file downstream is a leaf. Read-only by nature. The generator owns it completely because nothing else ever writes to it.

A Bento deck is not a leaf. A colleague opens it, likes it, and moves a box. Now there are two authors, my generator and that person, and one of them is structurally blind to the other. Re-run the generator and it does the only thing it knows: it writes the whole file from the upstream source, silently erasing every edit the human made, with no warning and no recoverable copy. The same code that was a convenience for a year is, against a living file, a shredder.

I noticed the shape of the problem by the shape of the thing I built to contain it. I wrote a guard: fingerprint the document the generator produced, and on the next run, if the file on disk no longer matched, if a human had touched it, refuse to overwrite and drop the freshly generated version in a sidecar file beside the original for the person to reconcile by hand. It worked. It was also a confession. When your safety mechanism exists to protect a document from your own tool, the tool is standing in the wrong place. The sidecar was me negotiating a truce with a medium I was fighting. You do not need a truce with a medium you are working with.

The document is the source of truth

The fix was to stop generating. Not to generate more carefully. To stop.

In the new arrangement the agent does exactly what the human does: it opens the file and edits the document in place. It reads the structured document inside the file, changes the parts it means to change, and leaves everything else untouched, including whatever a person did last Tuesday. There is no upstream source anymore, because the document is the source. The human and the agent are peers now, two editors taking turns on one living file, and neither regenerates it from anything. Nothing is overwritten because there is nothing to overwrite. The entire class of failure I had built a fingerprinting guard to survive simply stopped existing, the way a disease stops mattering when you drain the swamp.

The generator did not die. It shrank to its honest size, a bulk tool for the rare case where you genuinely want to mint fifty fresh decks from a spreadsheet with no human in the loop. For anything a person will touch, the agent edits in place, as a peer. That is the move the portability story misses. Bento does not only collapse the app into the file. It collapses the author into the tool. And that collapse is what breaks the generator: you cannot own a document with a write-only tool once someone else has an equal claim to write it.

Something had to move

But the generator had been carrying something for free, and when I tore it out I felt the weight land.

It had been carrying the guarantee. My old static decks are on-brand by construction: the only code path that produces a file already obeys the house style, so there is no way to be wrong. The palette holds because the generator is mechanically incapable of emitting a color that isn’t in it. The guarantee was free because it was structural, upstream, on the single road to an artifact.

The instant I let a human and an agent write the document directly, that guarantee evaporated. Anyone can now type a rounded corner or pick a red that isn’t in the palette. The rule still exists as an intention, but it has nowhere to live. The one place it had been enforced, the generator, is no longer on the road between intent and artifact. There is no single road anymore.

Readers of the changelog will recognize this move, because it is the oldest one in the verification playbook: a guarantee that used to hold by construction, once the system opens up, has to migrate from construction to checking. So I built the checker. A small standalone validator that runs on any finished .bento.html, no matter who or what produced it, and enforces the house rules against the document itself instead of the generator. By-construction became by-checking.

And this is the part that surprised me. It was not a downgrade. It was strictly more coverage. The generator could only ever vouch for its own output; it was constitutionally unable to say anything about a deck a human had edited. The validator polices both authors, the agent’s writes and the person’s, because it inspects states of the world, not the intentions of a producer. The guarantee got weaker in one sense (it is now a claim you check, not a fact you assume) and much stronger in another (it now covers the collaborator the generator never could). Which is the whole lesson of unsupervised autonomy compressed into one build: how much you can let another writer touch the document without watching them is exactly how good your validator is. Editability did not remove the need for a guarantee. It moved the guarantee to the one gate both authors pass through.

And then the validator didn’t validate

There is a last turn, and it is the failure, not the design, that carries the point.

I had agents review the whole thing adversarially before I trusted it, the sensible reflex when you are about to let a tool run unsupervised. And the review found that my validator, the object whose entire reason for existing was to enforce the palette, was passing colors it should have caught. It checked the obvious places and stopped there. A color written a slightly different but perfectly legal way, or tucked one level down inside a gradient, sailed straight through with a green check.

Sit with the recursion for a second. I had correctly diagnosed that opening the artifact to editing turns a quality problem into a verification problem. I had correctly moved the guarantee from the generator to a validator. And then I failed the verification. Quietly, confidently, with a passing status line, which is precisely the failure mode that makes an unexamined green check more dangerous than no check at all. A validator that doesn’t validate is worse than none, because none doesn’t lie to you.

That is the whole thing, really. The batch era’s instinct is the generator: intent in, artifact out, done, and the guarantee rides along in the machinery for free. It is the right instinct for a dead file, and it was right in my slide tool for a year. The agent era’s artifacts are increasingly alive: documents, spreadsheets, notebooks, design files, the code itself, all opened and changed by people and agents in turns. For those, the generator is nostalgia. Build two things instead. An editor, so the agent works the living document in place like the peer it now is. And a validator, because the guarantee that used to be free is now something you earn on every state, and had better actually run.

Bento’s real disruption is not that the app fits in the file. It is that the file, by being alive, quietly turns editability into a verification problem, and hands the bill to whoever was still reaching for a generator.