The second run was not faster. It was better instructed.
The game is a telephone game for a group. Someone writes a sentence, it gets machine translated through a chain of languages, the next player types it back from memory, and after a few rounds everyone sees what the original became.
seed: "the cat sat on the mat"
| translate to Japanese
v
player 2 retypes from memory
| translate to Arabic
v
player 3 retypes from memory
|
v
reveal: every version side by side
I built it once, then built it again from an empty repository with the same brief, to find out how much of the first run had actually been learned.
Not by me. By the agent. A lesson only counts if it survives into a fresh context with no memory of the project. The agent has no memory of it, which is the whole point and also the whole problem.
What transferred was not code. The second version started with a spec that outranks everything else, plus the rule that when a task card and the spec disagree, the spec wins and you say so in the commit. Each card owned an explicit list of files, so two cards could not quietly edit the same thing. Tests were split by tier: pure rules ran in node, components in a DOM, wiring against a real server. The round timer takes the clock as an argument instead of reading the system time, which is what makes a forty five second round testable in fake time instead of waiting forty five seconds.
v1 v2
one process serverless
rooms in memory rooms in a store
no spec spec outranks cards
one test tier unit, ui, wiring
owned by me owned by the cards
A spec that outranks the code is a strange thing to write for a party game, and I would write it again.
What did not transfer was judgement about scope. The first version shipped with a bug where only the last player could submit a sentence and the others sat on the same screen forever. That is not a hard bug. It is the kind you get when nobody plays the game to the end before calling it finished, and the second run needed an explicit instruction to stop and do exactly that.
I do not have a clean number for which run was faster, and I am not going to invent one for the sake of a tidier post. The second run wrote more tests and spent more of its budget on specification, so if anything it moved the work earlier rather than reducing it. What I can point at is where the failures moved: from a person finding them after deploy, to a test finding them before it.
Which is the honest summary. An agent does not carry anything between your projects. Your instructions do. If a lesson is not written down in the repository where the next run will read it, it did not happen, and you will pay for it twice.
Both versions are still running, and the second one is the one I would hand to someone else.
Screenshots
The first version. A translation-style header, three numbered rules, and two cards.

The rebuild. One panel instead of two cards, and no rules on the page.

A room, before anyone else joins.
