Appendix: Nodes & Webs

An appendix to Build to Think. The essay was written about one project. Sixteen more happened. This is the map of what traveled between them — drawn, like the audit, with one ink, one accent, no chartjunk.

The essay’s claim was that a product reveals itself through building — that no design doc could have described the bookmarks tool, because the tool didn’t exist until the building started. Seven months later there’s a stronger version of the claim, and it only becomes visible from above: no single project knows the pattern it’s part of. Each build felt like its own idea. Mapped together, they turn out to be one idea — thinking — with seventeen addresses.

The web

Every project is a node, sized by its 2026 commits. Three kinds of edges. Solid: code physically moved — the driving game extracted out of sf into rush (−19,963 lines in one commit), course geometry from sf into golf, the 1,381-prompt dataset from bookmarks republished as an MCP server. Dotted: a lesson moved without any code — doperat v4’s “ship the skeleton in demo mode” trick reappearing in stems two weeks later; the same make-the-hallucination-a-failing-build gate showing up independently as check-facts.ts in bookmarks and genmedia-prices.json in inference. Faint: the audit reads it — every node, alive or dead, feeds the site.

The edges are the finding. A portfolio review would rank the nodes; the web says the transfers are where the thinking lives. The most valuable thing sf produced wasn’t the atlas — it was the discovery that its driving game deserved its own address, and the copy-first extraction technique (new home committed 10:32, deletion 10:38) that made an irreversible migration into two reversible ones.

The patterns

Read enough edges and they braid into threads. Six run through the whole web:

The campfire. Every project that matured left itself a note — NEXT.md, DECISIONS.md, a resume prompt in a research pipeline — and every project that died, died in the gap between two sessions. Continuity, not energy, is the real constraint. The audit itself is this pattern at portfolio scale.

The gate. The best projects turn their worst incident into a failing build, not a doc. Bookmarks’ check-facts.ts fails prebuild on any string the project has ever been burned by. Inference’s price ledger carries source_url and confidence on every number. Golf’s test:engine bot-plays all nine holes and asserts completability. LabsCraft’s NPC can only emit five typed actions — freeform output never touches game state. Same idea, four costumes: if the fix isn’t a gate, it’s a wish.

Subtraction. The spring accreted; the summer cuts. The Dopamine Rat’s four rebuilds trace a dependency curve of 2 → 7 → 10 → 3, and v4 wins by replacing 18,644 lines with 1,025. The sf extraction was −19,963 lines. Archetypes v2 rebuilt 272 asserted entries into 87 defended ones. You don’t really understand a thing until you can say what to cut.

The same city. One digital-elevation model of San Francisco quietly underlies three nodes — the sf atlas renders it, rush drives on it, golf putts across it. Real terrain became the workshop’s recurring canvas: the city being moved to is also the substrate being built on.

The day job, refracted. Flow appears in the web four times wearing four costumes: a card game where PM disciplines literally cannot deal damage, an economics explainer of gen-media inference, a prompt observatory built from viral posts, and a Minecraft intern quest run by a live agent. Building sideways at what you think about all day turns out to be the highest-yield research method in the set.

Audience of one. A birthday RPG for a friend, a bass tool with one logged practice, a supplements tracker whose load-bearing feature is deliberately kept out of every score. The web’s most affecting nodes were never meant to scale — and one of them (kareemrpg) shipped to more genuine effect than several products.

The meter — tokens and models

Two very different kinds of tokens flow through the web. Build-time tokens — the conversation between builder and model that is the thinking. And runtime tokens — the shipped products doing their own thinking in production.

Somewhere north of half a billion tokens of thinking, then, for 813 commits — roughly ~700k tokens per commit, and for the Dopamine Rat, on the order of ~40k tokens per line that survived the four rebuilds. That last ratio sounds damning until you invert it: the expensive part was never the code, it was finding out which 1,025 lines deserved to exist. Ninety-six percent of the tokens were spent thinking; four percent shipped and kept thinking on their own. That’s not waste. That’s the ratio the essay predicted — the cost of running an experiment fell below the cost of writing about one, so the experiments became the writing.

The model eras track the year’s shape: the spring detonation (Mar–Apr, 73% of all commits) was built mostly on ~Sonnet 4.5 and ~Opus-class sessions; the summer’s turn from finishing to cutting runs on Fable — this appendix included. The one constant is the pattern from LabsCraft, worth more than any single estimate: gate before generate. A cheap deterministic check decides whether the expensive stochastic call happens at all. The workshop’s whole economy runs on that trick.

Complexity, upside down

The strangest curve in the web: over seven months, the ideas got bigger while the artifacts got smaller.

The same inversion runs everywhere. Bookmarks, the most sophisticated system in the web — a two-tier model pipeline, 139 tests, a scored 199-post research corpus — runs on seven runtime dependencies. The MCP server that teaches an entire protocol: two. The site that survived twelve years: zero, and the only thing on it that ever rotted was its one service dependency, a dead analytics tag. Meanwhile the conceptual complexity climbed: from “save my bookmarks” in February to “an 11-mission adversarial research pipeline that publishes its own surviving objections” by July. Complexity didn’t disappear from the practice. It migrated — out of the artifacts and into the thinking, which is the only place it pays rent.

And the web’s most reliable leading indicator stays almost embarrassingly simple — planning-doc weight predicts survival: golf’s 16KB of decisions bought three months of life; bass’s 22KB produced a finished artifact; film’s zero-byte plan died in a day, still wearing its starter README.

The symbiosis

None of this works without the strangest edge in the graph: the one between ~/CodeProj and ummerr.com — the workshop and its logbook.

The relationship is genuinely symbiotic, in the biological sense — neither organism survives alone. CodeProj without the site forgets. The audit lineage exists because the portfolio kept dying of cold starts, one unpushed branch at a time; the essay is the campfire for the workshop as a whole. The site without CodeProj has nothing to say. It sat dormant for four years — 384 commits over twelve years, then silence — until the workshop gave it a subject, and it woke up as the publishing surface for the practice that was already happening.

And the loop is recursive in a way neither side planned. The site is itself a node inside the workshop — repo #17, 58 commits, subject to the same audit as everything else. The audit is an essay about the workshop, generated by the workshop, published on the workshop’s own output surface, which then becomes the homepage’s featured link, which is the first thing the builder sees at the next 5am session — the note left for the self who walks back in cold. The homepage’s project list is the web’s public API: nine nodes, each with a P-number and an address. The essays are its changelog. The audit is its memory.

The original essay ended: build to think, then write what you found. The appendix can now add the missing clause. Write it where the next build will trip over it — because the web isn’t a record of the thinking. Mapped edge by edge, it turns out the web is the thing that thinks.

Estimates marked ~ are reconstructions, not measurements — the one section of this lineage drawn deliberately in pencil. Everything else is from the git history, read on Fable. Back to Build to Think · the full year-to-date audit.