Build to Think: An Autumn Audit
The year-to-date audit, through the lens of Build to Think — the twentieth edition since March, regenerated with /audit on Fable and Opus 5, this one 2026-11-12. One ink, one accent, short on purpose.
On October 28 the project this audit had filed as the year’s honest failure — a bass practice tool with a thirty-tab library and one practice ever logged — got a commit that deleted 2,172 lines, and five days later a single Monday morning rebuilt it as something else: a seven-day curriculum with a session engine, a metronome, and a fretboard that makes sound. The whole window since the last edition is that one repo, fourteen commits on three mornings. The year stands at 1,283 commits, twenty-one products anyone can open in a browser, no servers to babysit — and one rebuild that arrived with eighty passing tests and nothing that runs them before a deploy.
The leave’s clock held: nothing at 5am since August 26, everything between nine and one. The rebuild also sat unpushed for six days with a machine-written note saying so, until the builder opened the live site, saw April, and typed push. The oldest failure in this file has a fresh exhibit, and so does the newest lesson: the portfolio builds checks and doesn’t wire them.
Lesson 1 — Projects die between sessions, not during them
Nothing here died of a hard problem. Things died of the cold start — sitting back down and not knowing where you left off. Every project that matured left itself a note; every one that stalled, stalled in the gap. The evidence is uncomfortably literal: one version’s final commit reads fix: resolve 27+ TypeScript build errors; another died finished, on branches nobody pushed.
This round adds the opposite case: the note was empty and the project came back anyway. When the rebuild of the bass tool began, its note was four machine-written stubs and its April plan said “Git is the streak tracker… no database, no auth, no client-side persistence.” What brought it back was not the note but a new brief, written from the hobby outward — “The website is not the hobby. Playing bass is the hobby” — and the first act under that brief was deletion, in its own commit, before anything new was written. The memory that survived the gap was the problem statement, rewritten rather than reread. The engine’s case is unchanged: 0.3.0 still sits on a branch with no upstream, the live site two versions behind, the generated status block reporting it every session since September 16.
The counter-exhibit kept its shape and gained a twist. The golf record’s nightly job ran fourteen more times with nobody present — thirteen green, one failure that filed and closed its own issue — and committed nothing, because there was nothing new; the right default for a machine with commit rights. And the rebuilt bass, with the best plan file in the set and no campfire at all, ended its second morning with its commits unpushed and a stub that said so. The builder found out by opening the live site and seeing April. The hook wrote the truth. The truth was read by accident.
The living log · how a project survives the gap
The transfer: give every project one living file — decisions with reasons, what’s next, what changed your mind — and let the machine write the part that’s a fact every time you stop. Then put the fact where a second pair of eyes lands. A status line nobody reads is a diary; a team’s board is only a board if it’s on the wall, and the cheapest wall is the thing that fires on its own.
Lesson 2 — Everything you build wants to become a game
Look at where each exploration ended up: an atlas of San Francisco became a drivable city. A launch-planning idea became a deckbuilder. Golf-course data became a sim you can lose at; a friend’s life became an RPG; even the habit tracker is a rat you keep alive. The AI underneath is indifferent. The pull toward play comes from the person: a general capability has no handles, and giving it rules, feedback and stakes is how a mind gets a grip on it.
This round one refusal was written as product rules. The rebuilt bass is the most gamifiable thing the builder owns — a daily practice with a tempo to climb — and its plan forbids the scoreboard: no streaks, no badges, no inferred mastery; progress is “invisible” except for one optional Tricky / Good / Easy question at the end; “Breaks are fine” — three days away gets “Welcome back. Let’s play for five minutes.” The April version had the game-shaped parts, a heatmap and a streak-by-commit, and one logged practice. The November version deleted them first and kept the part of a game that teaches: a session that is a state machine in four lengths, an exercise that is a fully specified object, and a loop — Tricky repeats the lesson slower with fewer notes, Easy takes one more pass faster and advances. A difficulty curve with the scoreboard removed.
The rest held because nothing happened to it. The course manager still labels nearly every number a Guess; the war-game engine’s combat redesign is still unpushed; the physical-therapy tracker still stores an unknown set count as not specified.
The transfer: when an idea isn’t landing — a pricing model, a roadmap — build a toy version people can lose at. Losing teaches faster than reading. Then label every number a guess until someone has lost to it: a tuning table with its reasons attached is a design review you can hold later, and one without them is a fight about taste.
Lesson 3 — Build the memory first, then chisel the product out of the rest
Building to think works like sculpture: early versions pile up material — code, dead ends, notes — and the product is what’s left after you cut the rest away. The cutting is only safe if the design lives somewhere outside the code. That’s why the memory comes first.
The Dopamine Rat proves it. Built four times; dependencies per version ran 2 → 7 → 10 → 3. The version that shipped is the smallest, and the only one that started from a written record of what the first three got wrong. Doppler applied the rule on day one instead of attempt four: two dependencies, no backend, and 264 CI data invariants. If a number can be derived, derive it; anything hand-set is labeled as opinion.
This round’s subtraction came first, as its own commit, five days before the addition. The first commit of the bass rebuild removed the daily loop, the heatmap, the note-recognition drill and the one logged practice; the next turned ten lessons into eight reference articles; only then, on a Monday morning, did the new thing arrive — in vertical slices, each commit a library, its test and its route, on six runtime dependencies, with the model SDK demoted to a script nobody runs. The thirty-tab library was kept, moved behind a redirect, and the README calls it unchanged. Memory kept, product cut around it. Two cuts still haven’t happened: the engine at forty-four thousand lines has no decision log, ten weeks after its own note said to seed one, and the archetypes tree has been dirty since July because a build step rewrites its own timestamp into a committed file.
One repo, three homes · the July extraction
Maturity as separation of concerns you can survive: give each exploration its own address, and keep — don't destroy — what it grew out of.
The transfer: when a rule appears twice, that’s the design asking to be written down once and referenced. The cheapest refactor in a team’s codebase is usually a document, and the second cheapest is deleting the copy that drifted.
Lesson 4 — AI compressed implementation. It did not compress judgment
The cold start is how projects die; whether the thing deserved to exist is why you never come back. For four editions bass was the exhibit — supply for a demand that never existed, one practice ever logged. The rebuild revises the sentence rather than retiring it: the April failure was the brief, not the tool, and the November brief is built on the opposite judgment — a Known limitations list that says what it won’t do, a first phase whose done-when was a usable first week, and an app designed so the answer to did you practice can be no for three days without penalty. The judgment is better. The demand is still unproven, and this time the project is built to wait for it.
This round’s evidence is about what a check is for. The rebuild shipped with a full test suite, a curriculum validator and a clean typecheck, and a build script that runs none of them — a broken lesson deploys. The engine’s calibration suite prints its targets and asserts only that the run count equals the run count; “twenty distinct winners, was fourteen” is a reading with no interval. The rebuild’s progress store has a migration hook and both callers pass a reset, so the first schema change deletes every logged practice. The tracker’s sync route still answers anyone with the full health log, sixteen days after this audit put it first. And the audit’s own status generator crashed on a commit subject containing the word notes, because its privacy guard checked for words instead of for the thing it was guarding. Across the set, tests exist in eleven repos and run before a deploy in three.
The transfer: a check that can’t refuse is a wish. Wire every test to the one path that matters — the deploy — before writing the next one, and when you write a guard, make it test the property, not the vocabulary. With other people: the line that runs the tests before the deploy is the line that protects them; it is where a second person would have started.
The stack — whatever you don’t have to log into wins
The monthly infrastructure bill is $0 — but the money is the least of it. Sort the portfolio by what each project depends on and a pattern falls out: everything that survived runs on things you can hit without logging in — OpenStreetMap, MapLibre, git, localStorage, a static host’s free tier — and everything that rotted, rotted at an auth boundary: an OAuth flow, an expiring token, a service key. Not because open tools are better, but because they’re still there at 5am, on a phone, from a golf course. The path of least friction wins, and a login screen is friction.
Keyless → still running
- OSM + Overpass — two golf projects' course geometry; cost: an attribution line
- MapLibre — real maps, no API key
- Open-Meteo — live microclimates for the atlas’s weather-chase mode; no key
- git + a CDN — doppler's whole "backend"; scoring is a commit
- localStorage — the rat's database; the cooking coach's whole state; the flagship's job queue
- Jekyll + GitHub Pages — twelve years; its one death is opposite →
- a browser extension riding your own session — the watch's data, captured verbatim, no OAuth; the 2021 death across the aisle, solved by not asking
- hand-placed terrain — 48,000 lines of war game on zero external data; every ridge typed in
- GitHub Actions + git — the golf record’s nightly capture: twelve green runs, one failure that opened and closed its own issue; the first commit in the census with no human author
- Demucs, local — stems: no cloud, no accounts, no uploads; the price: only a demo lives at a URL
Auth-walled → where things rotted
- Garmin OAuth — built before daily use was proven; rat v3 died finished
- a Supabase anon key — five months of public writes on the flagship
- Universal Analytics — the site's one death in twelve years
- cron secrets & DNS aliases — the rat simplified; the failures moved here
- a stale Overpass mirror — the one that answers looks healthy; three courses baked from May data. The guard written after it caught a second mirror lying 50 days deep, in a different repo, on its first run
- five runner secrets — a watch token and a scorecard password, held by a cron; it works because “neither site challenged the runner’s IP”, and stops the day one does
- a model key on a server — the cooking coach’s photo review answers 503 without it; the first server-side key in the set
- a free tier with two slots — the film archive is coded against a database it cannot create; both slots are taken
- a hosting team's URL — the war game's deploys answer a login screen; only an alias nobody wrote down is public, and the obvious address belongs to someone else
Tournament weekend was the field test. Thursday, July 23: git init at 3pm, a live tournament site by 11:31pm. Then every update, all weekend, came from a phone between rounds — 22 commits of scorecards entered hole by hole from the course in Ontario. Nothing on the board was ever set by hand: standings, odds and the champion badge all derive from the committed scorecards. No admin panel, no login. That’s the bar — run it from a golf course, on a phone, between shots — and any OAuth screen in that path kills the live board by Saturday.
This round added nothing to either column, which is its own reading. The rebuilt bass runs on localStorage, Web Audio and a static host — the one key in the repo is in an April script nobody runs — and the most auth-walled thing in the set ran fourteen more nights on its five secrets, thirteen green, the one failure filed and closed by itself. The control arm is unchanged: still no CI on a push, still a tier nobody can check from outside.
And keyless still isn’t the same as findable. Three of this year’s shipped things have no URL in their README; a fourth’s README names one that doesn’t resolve; the obvious address for two of them belongs to strangers. Open beats auth-walled on survival; it buys you neither correctness nor a front door.
The transfer: count the credentials before you count the features — every key is a place the project can die while you’re not looking. When you must hold one, hold it the way the cron does: in a vault, with a run log that files its own failures, and a sentence in the record naming the day it stops working.
What building on top found
Three things fell out this round that no reading would have found.
- The guard that checked for words. The status board’s privacy guard refused any public text containing notes or branch. A commit subject said notes. The board went dark for sixteen days. The fixed guard checks the property — no path, no risk fragment, no manifest note may appear — and a commit may say whatever it likes.
- The migration that is a wipe. The rebuilt bass has a versioned store with a
migratehook, and every caller passes a reset. It will work perfectly until the first schema bump, which deletes the log. Three personal stores in the set hydrate without a parse; one tests its migrations. - Untracked is not ignored. The same commit that removed the bass note from git left it on disk, so the stop hook sees a dirty tree every session and writes a stub every day, forever. One line in
.gitignoreor onegit add— never the middle state.
The transfer: a safeguard is only as good as the thing it checks against. A guard on vocabulary, a migration that resets, a hook that counts the wrong kind of dirty — each passed its own test and failed its purpose. Before trusting a safeguard, feed it the case it was built for and watch it refuse.
What the code is asking to learn next
This edition was asked for a syllabus. It came from reading every repo, not from a reading list: each item names a pattern the portfolio hasn’t used, the evidence, and the file where it lands first. The long version — fourteen items and a four-week plan — is in the master report; these are the five that pay back fastest.
- A gate is a test that can refuse. Tests exist in eleven repos and gate a deploy in three. First: a
prebuildin the bass tool that runs the suite and the curriculum check; then the golf trip’s thirty-line CI copied into the golf sim, the tracker and the flagship. - Parse, don’t validate. Three personal logs hydrate storage as a partial state with no parse; the film archive has fourteen secrets and no boot check. First:
safeParseon hydrate in the tracker, anenv.tsin the archive, a real migration chain in the bass store. - A single user still has a trust boundary. A capability token compared in constant time is complete authentication for one person; a
Sec-Fetch-Siteheader is not. First: the tracker’s sync route, both verbs; then the flagship’s fifteen open write routes. - Property-based tests for engines. The simulators expose seeds and invariants and test three hand-picked cases each;
fast-checkis in no package. First: a combat invariant in the war game over generated seeds, a shot invariant in the golf engine. - An interval before a claim. Seventeen calibration files, four assertions. First: a Wilson interval on one golden-matchup target, then a parameter search where five hand patches are now.
The transfer: none of these is a product. Together they are about three hundred lines, and every line is a check that can say no — the part of building this year hasn’t built.
The year in one line
The shape of the year · commits per week, in three acts
Two quiet months, a detonation, a tail — and a fourth act with its own clock. The spring holds 46% of the year’s commits. The mid-May flatline is Google I/O; the June trough is the move, New York to San Francisco; the autumn is paternity leave, from August 26, and it has now gone eleven weeks without a 5am commit. The year’s busiest hour is 9am, by twelve over 9pm; it was by three in October. The window reads as one Monday on the curve, and the rest is flat.
The portfolio
This round’s deltas — THE POCKET · bass · the site & its harness
Shipped & steady — MACKENZIE · MUNI golf · bittman · Westeros War Games · Prompts · The Doppler XII · archetypes · SF · Flow Slays IO · inference · stems · Level Atlas · Minecraft mods · course renderer · kareemrpg · prompts-mcp
Bench & footnotes — unstuck · SF Rush · the Dopamine Rat · the bench

THE POCKET · bass
Four editions as the year’s honest failure; then a commit that deleted the practice scaffold and, five days later, one Monday morning that rebuilt it as a seven-day curriculum — a session engine that is a pure reducer, a two-clock metronome, a fretboard that sounds, a schema that refuses a backwards tempo range. Its plan’s first rule: “The website is not the hobby. Playing bass is the hobby.” No streaks, no badges, “Breaks are fine.” It shipped with a full test suite and no gate, sat unpushed for six days, and still has no hand-written note.
MACKENZIE
Two editions ago it forgot to push; now it pushes without him. A nightly job logs into the watch and the scorecard app, captures as the extensions would, refreshes, passes the gates, commits and deploys — “the five hand steps between a round and a push” are gone, and the one commit it has made so far is the first in the census by a machine. Around it: a hundred public courses checked row by row (193 values corrected, two left open by name), nine weekends with a story, and a plan page that prices the record against sourced benchmarks instead of its own simulator.

MICKEY’S MUNIS · golf
A 16-bit sim on real course geometry — 360 holes, from Augusta to a Toronto par 3 — and now, through a side door on its title screen, a Golf Course Manager: one par 4, twenty golfers with patience that drains at the tee gate, a ledger, and a done-when — “a Hacker rinses three balls in the pond, quits, and the refund lands in the ledger.” Phase 0 was built by a cloud agent in twenty-one minutes of commits on a Saturday morning; nearly every number in its design notes is labelled Guess.

bittman
A cooking coach for one cook — a new dad — built in 28 hours in August and grown since: The Fridge (“the teach-only answer: no fridge inventory, no new state”), menus pinned to the time you want to eat, a nav cut to five tabs in sixteen minutes, six savory breakfasts one morning in October, and a photo review — two model reviewers look at the plate, then a button copies the report for the next session. The validator still runs by hand; the README still says no backend under the portfolio’s first server-side key.

Westeros War Games · catalina
A deterministic war-game engine that grew a genre a day in August, then a combat redesign in September: every exchange a stance — press, measure, guard, feint, close, finish, hold, yield, break — and a 200-game batch that went from 14 distinct winners to twenty. Two versions sit on one laptop: the hotspot fix on main, the redesign on a branch with no upstream, both unpushed for eight weeks while the note beneath them said so every session. No decision log yet at fifty thousand lines.
unstuck
A physical-therapy tracker for one body, kept off the board on purpose. The program is “transcribed verbatim from the handouts … nothing clinical is invented”: unknown set counts are stored as not specified, left/right tracking is “labelled as your own choice,” and quick logs don’t count toward milestones. Five mornings: a PWA, a one-way export to a vendor that “only models sets and reps,” eight hand-drawn pictograms, and the best per-session notes in the portfolio — including one that records a parallel session’s change as “someone else … kept as-is.”

Prompts · the flagship
X bookmarks → a curated gen-media prompt dataset, and now a public market map: 74 companies, a Momentum 25, and a 352-finding validation trail written in two hours before work. Its strongest refutation is published in its own audit; contested numbers stay contested; the entry about the author’s own product was corrected toward accuracy, not flattery. The April essay it replaced kept its URL and lost its authority.

The Doppler XII
Built in one evening, operated from the tournament, sealed by Sunday. Live scoring was literally git: commit a scorecard, the field’s phones update. Two runtime dependencies, no backend, 264 data invariants in CI. After the seal came “The 36th”: the playoff hole resurveyed from OpenStreetMap, shot by shot, with witness corrections amending the record.

SF Rush
Don’t read the commit count — the game was built across sf’s spring sprints, then copied out whole on Jul 12: 18k lines, six vehicles, real LiDAR terrain. The chart shows the full lineage; its default level is the Harbor Links golf course.

Flow Slays IO
A Slay-the-Spire deckbuilder about shipping a GenMedia model. The truest mechanic: the PM classes cannot deal damage — the whole kit is leverage on other people’s cards. July’s retheme added pixel-art combat and an honest balance simulator.

Archetypes
v1 was built entirely on a phone. v2 rebuilt the problem statement: 87 archetypes, 170 graded mappings, every objection attacked on schedule and the survivors published.

Course renderer
A golf-course digital twin on MapLibre + OpenStreetMap — refuses to invent geometry the map doesn’t know. The keyless thesis’s control arm: its auth tier has now sat untouched for three months — not broken, just no longer checkable from outside.

Stems
A local-first Demucs stem splitter whose demo renders music videos in your browser — ten styles, four generative sketches drawn from a hand-written FFT — and then, in twenty-three minutes, became a working Winamp. Its own note says the next step is to ship it outward.

Level Atlas
An atlas of level design in which the repo is the database: every entry a JSON file checked at build time, so a dangling reference fails the build instead of the page. Day two it built a space-graph engine instead of per-level artwork.

The SF atlas
An atlas built to answer a real question: where in SF to live. Its weather-chase mode colors 189 neighborhoods by live sun, wind, and warmth. It also grew a driving game, then gave it up: −19,963 lines in six reversible minutes.

LabsCraft v2 · minecraft-mods
An LLM-driven NPC mod deleted and rebuilt in ~100 minutes by 7 parallel agents — safe because the design was extracted into a spec first. A third mod, SportsCraft, golf inside Minecraft, is still in PR, honest that no one has run it.

Inference
Gen-AI unit economics, cited and interactive. Its 34-commit launch day exposed the missing source of truth; the fix made July’s refresh one commit instead of thirty.

The site
The workshop’s logbook — and this audit’s publisher. Its one commit this window was the last edition. The public board it carries is regenerated by a hand step, and nobody ran it: the as of line read October 27 until this morning. The harness underneath — four Python scripts that generate the board, the homepage and this census — has no tests and no git, and its status generator crashed on a commit subject. Fixed by hand, with a backup file as its only history.
The Dopamine Rat
Dependency count per version: 2 → 7 → 10 → 3. v4 wins by deleting the other three. Its July privacy fix has been sitting uncommitted for 111 days — the campfire is lit; nobody has pushed it into git.

kareemrpg
A friend’s life as a walkable RPG. The tutorial folder quietly became the product — bias toward extending what works.
prompts-mcp
Learned MCP by implementing all four primitives and both transports over his own dataset. The bugs were the curriculum.
The bench
film was deleted and rebuilt in twenty-one minutes on Sep 12 — rolls as the unit, a contact sheet, a grease pencil, a search — and stopped at the first account it had to create; its README says Live above a domain that doesn’t resolve. westeros-battle-royale, the rival engine that got its first commit sixteen minutes after the last audit found it bare, has not moved since. Two repos never reached a first commit.
The cadence
The bimodal builder · commits by hour of day (Pacific)
Every day of 2026 · Daily commits, week by week
Hover any day for its count and which repos moved. The dense block is the March–April detonation; the warm cell is the single busiest day (Apr 12, the inference launch).
The verdict
The portfolio isn’t a list of products; it’s a thinking log with a URL for each thought. This round the log reopened an entry it had closed: the tool this file wrote off in April came back as a different product, built from the hobby outward, deleting first. It is the strongest argument in the set for the thesis it used to refute — the failure was never the code — and it arrived with the gap this file has named since March: checks written, checks not wired. A suite that doesn’t run, a calibration that doesn’t assert, a route that doesn’t check, a guard that reads words. The month of work this edition proposes builds nothing new. It is three hundred lines that can say no.
The leave’s clock held, and the window is one Monday morning. Nothing at 5am in eleven weeks; the 9am builder is the only one left, and he works in forty-minute bursts that land thousands of lines at a time, with a machine splitting them into commits.
What none of this has been tested on is still other people, and this edition can say where they would have started. The eight product rules in the bass plan, the guesses in the manager’s notes, the fifty-five rulings in the golf record are all review checklists that have never had a second reviewer — and a second reviewer would not have opened the schema. They would have asked why the tests don’t run before the deploy, because that line protects them. The portfolio has learned to leave itself a note. It has not yet built what a stranger with commit rights would need. Seven weeks of the year are left.
Build to think; then wire the check, because a test nobody runs is a wish with a filename.
Twentieth dated edition since 2026-03-29. Census through 2026-11-12. Regenerated with /audit on Fable and Opus 5 across the run — this one on Fable. The long-form master report — including the full fourteen-item learning section and a four-week plan — lives at ~/CodeProj/PROJECT_AUDIT.md.