A word game, made solo
This is to that. A word game about analogies, live at playasto.com.
I’m Max Rowe, and I made ASTO solo: the design, the code direction, the editorial judgement, all of it. One name on the credits means every decision in this deck is attributable, including the bad ones.
As of August 17, 2026.
The idea
Two goals, named up front. Every slide after this one is evidence toward one of them.
Not a demo. A finished, public word game with a specific character: cozy, unhurried, built on recognition. Every puzzle had to clear an emotional bar, not just a validity check, and strangers had to be able to play it at a real address.
Two distinct learnings: building production software through AI tools as a non-programmer, and designing an agentic pipeline that authors content to a taste it does not hold itself.
The idea
The deck reads front to back; the jumps work too.
The game
Connections, but with analogies: a 4×4 board of sixteen words hides four analogy sets. Tap four words to form A : B :: C : D, seed is to tree as spark is to fire, review the frame, press Confirm.
If you arrived from the game, this is the part you couldn’t see. If you haven’t played, one round makes it click.
The feel
The puzzle is not “which words are similar?” It is “what relationship repeats across these pairs?”
Four sets, four difficulty tiers, revealed on solve and never shown on the live board: difficulty is discovered, not warned about.
Cozy is a constraint, not a mood. No timers, no confetti, no particles. Mistake pips are coffee beans and never red. Lose on the fourth mistake and the loss screen reveals every unsolved set with its explanation, so you always find out what you missed.
I declared the taste bar on day one, not once the pipeline made it necessary: it is not enough for a set to be valid, it has to feel like something. That standard has a name later in this deck, and a machine gets graded against it.
This deck is how ASTO was made. The game design document (v0.13, living) is what it was meant to be. They are companion reads.
The method
A puzzle game is hungry: it needs a steady supply of boards that all clear the same bar. AI could generate that scale. Generation alone was nowhere near trustworthy enough to publish.
One model call can’t hold the job. A publishable board has to satisfy sixteen unique words, one set per difficulty tier, four distinct relationship types, no accidental cross-set groupings, fair ordering, and a theme that feels like something. Asked for all of that at once, a model quietly trades constraints away and nobody can say which step failed.
So the job is split into agents with one job each: an author, a grouper, a rater, a builder, a row of evaluators. Each has a declared input and output schema. Each can be tested, measured and improved alone. When a board fails, the failure has an address.
And one judgement is never delegated: whether a board ships. Taste stays human. The machine’s job is to make my judgement cheaper to apply, not to replace it.
The intuition going in was that generating good pairs is the difficult part and assembling them is bookkeeping. That is backwards.
from my first pipeline’s lessons-learned
My first version was a five-agent Python crew, and it worked. I retired it anyway and rebuilt inside the game’s own repo, importing the game’s own validators: one schema, no drift between the thing that writes the puzzles and the thing that plays them.
The method
I’m not a programmer by training. I direct the code rather than write it, and that only works if trust never depends on my ability to eyeball a diff.
The discipline is boring on purpose. Every session opens by re-reading the plan and closes by verifying and recording. Every decision is written down with the trigger that would reverse it. The main branch only ever holds verified states, so any point in its history is a safe rollback. The repo carries its own memory; nothing depends on mine.
The suite turns “it works” from a feeling into a fact I can check. Nothing ships on my confidence.
The method
Every agent is a pure function with a declared input and output schema, and each one has exactly one job. The run is unattended: I’m only involved once a complete candidate board exists. The diagram is the tour; three stops deserve a word.
The revision proposer reads my feedback and drafts the fix brief: it proposes, never authors. Auto-revise is the one bounded repair the machine may make before I see a board, only on findings I explicitly allowlisted, and taste never triggers it.
The method
The pipeline only makes candidates. The other half is a local Review Studio where every board meets its editor: I start runs there, play the candidate exactly as a player would, and read each agent’s report beside the thing it judged. All 726 judgements that tune the agents were recorded in that room, and approving a board publishes it through the same validators the game loads.
It grew with the project: first review and publish, then a player-ratings panel, then a hand editor where I fix a board in place, every save validated and recorded as before-and-after signal. Judgement becomes data here, and nothing publishes without me.
The method
The early failures were not prompt problems; they were lessons in what a model structurally cannot do. Four principles, each paid for by a real dead run.
What I learned
Every board was starting to feel the same, and the corpus said why: ~80% of all 284 pairs ever authored were the same relationship, one thing becoming or producing another. The obvious next move was to write my own taxonomy of relationship types from taste, and steer the pipeline with it.
I can’t be fully relied on to create a foundation for analogies because I am not an expert. I’m merely interested in playing them.
the note where I stopped myself
So I didn’t write one. I went and found one: Bejar, Chaffin & Embretson (1991), developed at ETS to classify GRE verbal analogy items, and compiled it into a controlled vocabulary the pipeline actually runs on and is checked against.
Mapping my existing corpus onto the borrowed taxonomy showed exactly how narrow my own range had been:
A vocabulary you can count against turns a vague feeling, “these all seem similar”, into a number you can steer with.
The literature even validated two of the game’s earliest instincts, and the framework still had to be borrowed.
What I learned
Round 1. A board built with one set from each of four formally different families. I played it blind, and it read as “all the same, an object moving forward in time somehow.” I demoted three of the four tiers. The experiment invalidated its own design: formal diversity produced zero felt diversity, because every set still carried an arrow: a direction, a before and an after.
Round 2. Blind again, board letters flipped, with an equally evocative control so the effect couldn’t be a theme artefact. The mixed arrowed/arrowless board came back as “the best puzzle yet… This is ASTO.” I rejected the all-arrowed control and named the effect without knowing which board I was holding: “another ‘arrow’ puzzle.”
Recorded as decision D-3, marked n=2, hypothesis not law, with a written trigger naming what would have to happen to overturn it. “Let’s make sure we don’t view the revised principle as immutable.”
Same theme, same night, same evocativeness, letters assigned blind. The only variable was whether every set pointed in a direction.
the night creature and the signal it gives off
the one thing it can never have
The green points somewhere: a creature and what it emits. The black points nowhere at all, and it is the set this game exists for. One arrowed, one arrowless. The mix is the finding.
How taste gets measured at all: the feedback form was rebuilt around how I actually judge, its tags compiled from my own prose notes and board verdicts separated from set verdicts. Every number in this deck rests on that instrument.
What I learned
The machine is allowed to fix a board before I ever see it. It earned that authority against a standard I wrote before the feature existed, and the bound on it is the interesting part.
I rejected two boards for two specific defects, then found the adversarial solver had already flagged both, in almost the same words, with nothing routing its findings anywhere. I was re-deriving by hand what the pipeline had written down.
Louvre and Musée d’Orsay are themselves extremely famous museums
near-synonyms… stock spy-gear items
Deterministic checks are automated outright. AI revision runs only on an allowlist chosen by me and revocable by me: cross-set findings at high severity and the order-ambiguity cluster, nothing else, one auto-revision per board. Taste never triggers a revision. A failed repair sends the board to me carrying both the findings and the diagnosis.
Order fairness is the allowlist’s other half. An analogy that reads as truly backwards (seed : bud :: bloom : wilt, where I lost a mistake to a coin flip) is a fairness bug, not a style note, and three detectors now catch that shape. All three report and none can block: a wrong fix gets reviewed by a person, but a wrong veto silently costs a good board. Signals, deliberately not gates.
What I learned
A read-only tool re-runs any evaluator against any board in the archive, so the agent is the only variable. Same board, same model, same effort setting, eleven days of prompt work apart.
unity: strong
evocativeness: strong
The second answer is to a question the first version had no field for. The axis did not exist yet, so the old agent could not have been wrong about it. It could only be silent.
I had called that board an absolute snooze. Today’s agent answered strong, and went on to praise the exact wording my own note had wanted sharpened. The disagreement was reported as it came back, unedited.
That is the useful result, not the improvement. An evaluator that only ever agrees with you is not an instrument, it is a mirror.
The counterweight: one board, one stage, chosen by the person the machine was flattering. It measures that the agent changed. It does not measure that the agent is right.
What went wrong
The full list in the project log runs to thirteen items and grows with the project on purpose: keeping it is a method, not a confession. Three of them, chosen for what they teach.
git add -A. Synthetic judgement is indistinguishable from real judgement once it is in the file the editorial rubric compiles from. Caught at wrap-up; all four removed.The game, live
Live at playasto.com since August 13, 2026. A real domain, free static hosting, roughly 130 real pipeline runs behind it, all of it built solo.
That last number is honestly framed: n=1 is not validation and it is not traction. What changed is a category, not a score. The loop now has a door a stranger can put a judgement through, and the first thing to come through it was “loved the theme of this one.”
An About page states plainly that the boards are AI-generated and human-approved: every published puzzle was played by me before release. It is linked from the end screen as well as the homepage, because a shared link goes straight to a board and never passes the front door.
Go play it. The fastest way to evaluate everything this deck has claimed is one round at playasto.com. Come back for the last slide when you’re done.
Forward
As of August 17, 2026 · playasto.com · the game design document
The open loop, named: the editorial rubric does not exist yet. The plan said thirty judged boards; there are 109. I would rather name the debt than have this deck imply it is done.
Where this goes next: Relics of the Nine, my systems-driven roguelike, is the next project this workflow gets pointed at. What transfers is the machine’s shape: generator, validators, an adversarial check, and a human editor whose taste is the standard.
Not the game. The habit of writing down what was decided and why, of naming the trigger that would change my mind before I need it, of granting a machine authority only against evidence I wrote the standard for in advance, of keeping the failed experiment instead of the tidy summary, and of knowing which judgements are mine to make and which ones to go and borrow from someone who actually knows.
Validity can be delegated and checked. Taste is the product.