Project Audit
Generated 2026-06-24, viewed through the bent lens of Build to Think.
“No design doc could have described this project, because the project didn’t exist until I started building it.”
Last audit had a headline: a sketch became a finished, deployed game — Flow Slays IO, four playable characters with hand-drawn pixel portraits, a Slay-the-Spire engine that never hardcodes a card, synthesized sound, a boss. The thing that was a curiosity became a thing you can lose. This round is the epilogue nobody plans for, and it is the quietest in the lineage: one commit in seven days.
That’s the whole delta — and it’s a telling one. Having finished the game, the author kept using it, hit the friction of authoring cards one JSON object at a time, and built the tool that fixes it: a CSV bulk-import pipeline with a tiny effects DSL, server-side validation, and a paste-and-preview admin UI. No spec asks for a content importer up front; only living inside your own finished product surfaces the need. Below: the telemetry, the screenshots (the game still looks like this), and the portfolio project by project. The author is a PM on Google Flow who refuses to write design docs and then writes this. The building is the thinking — and this round, the maintaining was the thinking.
flowtcg — pick your PM, survive the road to launch. Four characters (Amar the Builder, Olivia the Assassin, Thomas the Boss, Anika the Agent Wrangler), each a real deck rendered with the in-game card component. Finished last round; this round it grew a CSV importer so new decks paste in instead of being typed by hand.Audit Meta — the audit, audited
Every audit wants to measure itself. This one obliges — and records the smallest round in the lineage: one commit in seven days. No new repos; the entire delta is a single content-pipeline commit in flowtcg, the game that finished shipping last round. The audit is downstream of the building, and this round the building did the quiet thing — maintained what it had already finished.
| Metric | Value |
|---|---|
| Repositories crawled | 20 (across ~/CodeProj, ~/ummerr.github.io, /tmp/archetypes-audit) — no new repos this round |
| Shipped to production | 11 |
| Total tracked commits | ~1,073 (mainline, no-merges; StreakUp excluded) |
| Infrastructure cost | $0 (Vercel Hobby, GitHub Pages, Supabase Free, itch.io, OpenStreetMap, USGS 3DEP) |
| Prior audits in the lineage | 7 — Apr 12, Apr 16, Apr 18, May 29, Jun 7, Jun 17, Jun 24 (this one) |
| Engineers employed on this portfolio | 1 (not by training) |
The year at a glance
Zoom out from the one-commit week to the twelve-month backdrop. Most of it is empty. The live cells cluster in the right-hand third — the “2026 run” — and the rightmost edge is nearly flat now: not a cooling-off so much as a finished project resting, with a single tooling commit as the week’s only mark on the curve.
Cumulative commits — rolling 52 weeks · Jun 2025 → Jun 2026
The same year as a running total. Flat through summer and fall, then the line tilts up hard in late winter and never quite settles — the labelled dots are the two steepest single days. The line draws itself left-to-right as it scrolls into view; the endpoint is today.
Daily commits — rolling 52 weeks · Jun 2025 → Jun 2026
Eleven months of quiet, then the 2026 run — the GitHub-style heatmap renders the shape of the portfolio on a single row. The brightest cell is Apr 12 (the day inference shipped). The second-brightest is May 27 — `sf`'s arcade-mechanics explosion, 43 commits in that repo alone. The cluster on the far-right edge is the move to San Francisco: six weeks of terrain pipelines, biometric crons, and a drivable LiDAR city. Grayscale by default — density is the signal — with a single spot of warmth on the busiest day. Hover any cell for the date, its commit count, and the repos behind it; the week and weekday light up so you can place it.
What changed since June 17
One commit. In seven days the entire portfolio advanced by a single commit, in flowtcg: “Add CSV import tool for bulk-seeding cards.” Having finished the game last round, the author ran into the most mundane post-ship friction there is — adding new cards meant hand-writing one JSON object at a time — and built the cure. lib/cardCsv.ts is a pure CSV parser with a compact effects DSL (damage 7; vulnerable 1, damage 4 x2; blank effects default by role), mapping rows to CardDefs validated by the existing CardDefSchema. A new app/api/admin/cards/import route re-validates server-side, bulk-upserts, and can append a per-row deck to a named character; CardImporter.tsx adds paste/upload, a New/Update/Error preview, a download-template, and a confirm step. 616 lines of content-pipeline for a game that already shipped. Everything else — sf, golf, bookmarks, gravityDopeRat, archetypes, bass, inference, minecraft-mods, kareemrpg — sat exactly where it was. (One new face in the ls: a godot/ workspace, last touched mid-2025 — not new work, but the cradle where kareemrpg was built. Logged in the footnotes.)
Lifetime commits per project
Every repo the author owns, ranked by lifetime commits — regenerated live each audit. ummerr.github.io (11+ years) and bookmarks (the flagship) still lead; sf holds fourth at 118 after last round's surge. The bars barely moved this week — only flowtcg ticked up by one — which is the point: a portfolio that finished its headline and is letting it rest. Strict grayscale; the cloned-reference StreakUp is excluded.
The throughline this round is maintenance. Last round was about finishing — pushing a build through the unglamorous last 20% that a design doc can’t motivate. This round is the part that comes after finishing, and it’s even quieter: you keep using the thing, and the use generates the work. Nobody specs a CSV importer before there are cards to import; you only feel the need once you’re living inside the finished product, seeding decks by hand and getting tired of it. One commit in a week isn’t a slow round — it’s a builder maintaining something real, letting the next task announce itself instead of inventing one.
The day’s hours, plotted as a clock
The pattern is still resolutely bimodal — a late-night building wing and a morning sprint, with a dead zone in the 4–6am window where even this keyboard sleeps. The shape is the whole point. This is work that happens around a full-time job, in the hours the job doesn’t claim. Nobody schedules a game’s boss-entrance animation for 11pm; it schedules itself. (The exact spoke heights are recomputed live below — the radial reflects the repos as they stand today.)
Commits by hour of day — 24-hour radial
The warm spokes — around 8am and the late-night 11pm–midnight band — anchor a resolutely bimodal day: a morning sprint and a building wing after dark, recomputed live from every repo. The 4–6am wedge is still the only stretch the keyboard reliably rests. This is what work that happens *around* a full-time job looks like in aggregate.
The portfolio, project by project
Jump to any deep-dive below. Bold marks what changed since the last audit.
This round’s deltas — Flow Slays IO — a CSV bulk-import tool for the finished game
Shipped & steady — sf · golf · bookmarks · Dopamine Rat (v1 → v3) · Archetypes · inference · bass · minecraft-mods · kareemrpg · the site
Bench & footnotes — VidMetaPrompt · smaller projects (now incl. godot/) · the Build-to-Think scorecard
The Headline’s Quiet Sequel: Flow Slays IO → flowtcg
Status: Playable & deployed • Commits: 16 (1 new since Jun 17) • Born: Jun 2, 2026 • This round: a CSV bulk-import pipeline Stack: Next.js 15 · React 19 · Zustand · Zod · Tailwind v4 · Framer Motion · Web Audio · Vercel Blob · Vitest
“A minimal Slay the Spire–style deckbuilder — a team toy for the Google Flow org, themed around the launch of Gemini Omni Flash at Google I/O. HP = Morale, energy = Focus, enemies = launch hazards.” — the README, describing a finished game.
Last audit, this repo was the whole story: a three-commit sketch that became Flow Slays IO — a named, deployed, drawn, scored, boss-fight-having roguelike about surviving a product launch. This round it did the thing finished software does — it asked for a tool. Exactly one commit, and it’s the least glamorous, most honest kind there is: a content pipeline.
What landed this round — the tooling tail. Adding a card to the game meant hand-authoring a JSON object; do that a few times and you build the importer. A new admin “Import CSV” panel parses a CSV of team members into validated CardDefs and bulk-upserts them. The parser (lib/cardCsv.ts) is pure and tested, with a compact effects DSL — damage 7; vulnerable 1, damage 4 x2 — and sensible role defaults (a blank attack becomes damage 5, a blank skill block 5). The app/api/admin/cards/import route re-validates server-side against the same CardDefSchema the rest of the game uses, upserts in bulk, and can append an optional per-row deck to a named character. CardImporter.tsx gives it a face: paste or upload, a New / Update / Error preview so you see exactly what each row will do before committing, a download-template button, and a confirm step. Cards stay textual-only; art still flows through the existing per-card upload. 616 lines, four files, zero new dependencies.
Effect[].Still engineered like a product, not a toy. Everything card-related is data-driven: the combat engine interprets a generic Effect[] and never branches on a specific card, so adding a person is adding a row (and optionally a PNG) — no engine changes, no restart. The importer just makes that truth faster: it speaks the same CardDefSchema and the same effect vocabulary as the hand-authored path, so a pasted spreadsheet and a typed JSON object are validated identically. A whole run is still deterministic through a seeded RNG, which is what lets npm run balance headlessly simulate 20 runs × 4 characters and report win rate, fight length, and card usage. The deck is still the org; the enemies are still what breaks your build.
Build to Think verdict. Last round’s question was whether a PM finishes what he builds. This round answers a quieter one: what happens after he finishes? The honest answer is the least cinematic commit in the whole portfolio — a CSV importer — and that’s exactly why it matters. You cannot design a content pipeline before you have content to feel annoyed by; the need is invisible until you’re inside the finished thing, seeding cards by hand. A spec would never have asked for this. Using the product did. The building is the thinking, and so, it turns out, is the maintaining.
The Ongoing Headline: sf → sf.ummerr.com
Status: Shipped • Commits: 118 • Sprint: Apr 19 – Jun 17, 2026 • This round: no change (steady since last audit) Stack: Astro 5 · React 19 (islands) · Three.js 0.184 · Rapier (WASM physics) · r3f + drei + postprocessing · MapLibre GL · @turf/turf · Tailwind v4 · TypeScript · pnpm Live: sf.ummerr.com
One of the most active repositories in the portfolio, and it still committed today — 59 days after it began as a one-line README about moving to San Francisco. It is two apps sharing one repo and one obsession with SF’s actual topology.
/ — the atlas. A hand-drawn paper-and-ink map of San Francisco on MapLibre (no Mapbox token; OpenStreetMap data, free tier), DEM topography with hillshade and contours, personal waypoints layered on top: the apartment as a blueberry, family, Equinox gyms, Google offices, and toggleable layers for cafes, bars, burritos, groceries, golf, parks, microclimate, isochrones. A relocation processed as a GIS project — the way to learn a city is to draw it.
/rush — the driving game. A full 3D arcade racer in the lineage of SF Rush 2049, built as a single Astro client:only React island so Rapier’s WASM and Three.js never touch the server, with the basemap’s LiDAR elevation as a heightfield collider you actually drive on. A garage of vehicles (car, motorcycle, bus, a Waymo robotaxi, a pickup, an e-bike), a panel-crumpling damage model, skid ribbons, a boost meter, stunt scoring, post-FX, a topographic minimap with district-warp buttons, and synthesized audio.
Where it stands. Last round it grew two worlds: a living city pass on San Francisco (ambient traffic, near-miss and punt scoring, bay life, +13 streets) and a brand-new “The Office” map — a tiny car loose on a giant startup-office floor, the pluggable MapDef system stretched to its silliest. This round it sat still — last commit Jun 17. The atlas-plus-arcade is, for now, done.
Build to Think verdict. This is the thesis at full volume. There is no spec for “process a cross-country move” — there’s only the act of redrawing the city until it’s yours, then driving through it until it’s fun, then adding traffic so it feels alive. The atlas is the author learning where he now lives; the racer is what it feels like to move through it. Both are the same LiDAR data, read two ways. No design doc gets you from “I moved” to “a Waymo you can drive across a startup-office floor.” Only building does.
The Sibling: golf
Status: In development (local-only) • Commits: 6 • Sprint: May 7 – Jun 17, 2026 • This round: no change Stack: pnpm monorepo · Next.js 16 + React 19 + Tailwind v4 + Supabase (web) · Vite 6 + Three.js + lil-gui (sim) · Python: rasterio, numpy, shapely, geopandas (DEM pipeline)
sf’s quieter sibling, born from the same terrain obsession: a personal golf journal that renders the courses you’ve played as interactive 3D terrain from public LiDAR elevation models — plus an embedded Three.js simulator to eventually play those courses on the same data. The journal and the sim load the same elevation.json for every course. One source of truth.
Three layers: a Python pipeline that pulls DEM tiles from USGS 3DEP (no auth), reprojects with rasterio, masks course polygons from OSM, detects feet-vs-meters, and emits elevation.json + hillshade.png; a Next.js web app (home grid, /courses/[slug] 3D viewer with a 1–6× exaggeration slider, round-logging form, sim iframe wrapper); and a Vite + Three.js sim played inside that iframe. A 244-line DECISIONS.md records the reasoning: why raw Three.js over r3f, why an iframe for the sim, why base: '/sim-app/'.
Where it stands. Last round’s single commit was all feel: clearer hole HUD, a longer driver, more forgiving putts — the tuning notes of someone actually playing the prototype and bumping into its rough edges, not speccing it. No change this round. You can’t write “the putts feel punishing” into a design doc you haven’t played.
Build to Think verdict. The loop is explicit in the product: play a course → log the round → study its real terrain in 3D → play it in the sim. Same learning ladder as sf (it even shares Three.js 0.184), pointed at a hobby instead of a city. Two projects, one pipeline — discovered by building the first and reusing it for the second.
The Flagship: bookmarks → prompts.ummerr.com
Status: Shipped • Commits: 276 (unchanged since Jun 3) • Sprint: 96 days, Feb 28 – Jun 3, 2026 Stack: Next.js 16 · React 19 · TypeScript · Tailwind v4 · Supabase Postgres · Claude Haiku (triage) + Sonnet (depth)
Steady this round — the flagship sat at the high-water mark it reached last audit, when it did something a PM org would normally staff a team to do: measured the reception of its own launch, rigorously, and packaged it to travel. (It’s also the one project I can’t screenshot for you — the whole site is password-gated, which is itself the point.) That earlier work is worth recapping, because it’s the clearest example of the side project and the day job finally touching:
The Flow + Omni exec brief (new). A share-ready reception snapshot at /flow-brief, framed as Launch → Reaction → Landing, opening with a TL;DR positive/negative split and backing every point with an exemplar quote and a source-thread link. It surfaces the uncomfortable findings honestly — a dedicated section on safety filters overfiring (over-restriction complaints), a clustered Verbatims section of two-dozen-plus quotes, and first-hand June Reddit data folded into the table. It ships with a “Copy-as-Markdown” button (“Paste straight into a Google Doc, Slack, or email”) and named-exec references deliberately removed so it circulates without blast radius. The rest of the site is password-gated; this brief was built to be handed up.
The Omni Report, rev. 7. The underlying corpus grew to 132 posts (from 98), scored day-by-day across Reddit + tweets + open web: 66% positive / 8% negative, peaking at 72% positive on launch+4. The research instrument now runs a press desk on the day job’s own launch.
The Omni Report (new, unlisted). A build-time-rendered editorial page at /omni-report analyzing the open-web reception of Google’s Gemini Omni / Omni Flash video model. A curated 98-tweet corpus (rev. 6, grown from 79) across nine source clusters plus a Reddit deep-dive of ~140 threads. The data tells a story of a narrative flip: the launch-day verdict was “worse than Seedance”; within days the framing pivoted to “fundamentally a video editor, not a generator — Nano Banana for video.” Server-rendered SVG sparklines, numbered executive-summary cards, sentiment-by-day tables with inline %-bars (66.3% positive, +57 net), noindex‘d and absent from the nav. It is the first time the site tracks a specific competitor’s launch rather than the field in aggregate — the research instrument grew a press desk.
Dataset slicing (new). Four derived sub-datasets — T2I, R2I, T2V, R2V (text/reference × image/video) — each at /dataset/[slice] with its own stats and independent JSONL/CSV/JSON downloads, backed by SQL predicates over prompt_category and requires_reference. A shared lib/datasetSchema.ts centralizes the 27-field canonical schema so master and slices can’t drift; old ?slice=-less download URLs still resolve to the master set.
Research export (new). A ?variant=research flag strips PII (tweet_text, author handle/name, media_urls) while retaining tweet_id for rehydration — GDPR- and ToS-compliant academic sharing, exposed as a radio toggle in the download modal.
The access-gate detour (added, then removed). Apr 23–25 saw a client-side password gate, then a fake-404 overlay shown on every page load. Both were stripped by May 27 (Remove fake-404 gate overlay from site). The site is fully open again — a small, public, reverted experiment, the flagship’s signature move.
Everything load-bearing still loads. Two-tier classifier (Haiku triage, Sonnet depth), Chrome extension (Manifest V3), Image-to-Prompt reverse tool, quality audit, dataset datacard, methodology page, State of Prompting essay — all live, all free-tier.
Build to Think verdict. A mature project keeps discovering surfaces it couldn’t have specified. “A Chrome extension for bookmarks” became a dataset became an editorial became a competitive-intelligence desk with compliance affordances. The Omni Report is what it looks like when the day job (a PM on Flow, an AI video product) and the side project finally touch: the side project now reports on the competition, in public, for free.
The Long-Running One: ummerr.github.io
Status: Shipped (continuously, since 2014) • Commits: 367 • Lifespan: 11.7 years Stack: Jekyll • GitHub Pages • Bulma + custom CSS + Tailwind v4 • Geist + Instrument Serif
The heartbeat of the portfolio. Every other project ships through or alongside this site. 11 published essays, 10 portfolio case studies (Amex, Tradesy, Breazy, Kollider, Level, TheKind, Battle Bakery), a film photography gallery, a split-pane markdown editor with localStorage auto-save, and a 57MB Godot WebAssembly game embedded because at some point it became easier to embed it than not.
Tuesday is still the giant — 81 commits, 43% of all weekday activity. Noon peak. The daytime counterweight: the site is the writing project, everything else is the building project.
As ever, the site mostly carries other repos’ news: its recent commits are audit posts themselves (Regenerate project audit …). It’s the publication layer for its own telemetry — including this very page, which lands here as the next commit. It also hosts the screenshots in /images/ from last round, when the audit started shipping pictures of the work alongside the count of it.
The Trilogy: The Dopamine Rat (v1 → v2 → v3)
A habit tracker starring an emotional pixel rat. Steady this round, but worth keeping on the board: three versions trace a philosophy pivot from gamification to harm reduction, and v3 (gravityDopeRat) grew a nervous system. Across six deployed phases (Apr 26 – May 8), the tracker that once only knew what you told it learned to read what your body did: a Hevy auto-pull every four hours (strength workouts log themselves as auto-strength), a Garmin cron (10am + 9pm ET, pulling HRV / body battery / resting heart rate), and a vitality-compute engine (Sleep 0–40 + Recovery 0–30 + Training 0–30, with mismatch flags) that rewires the rat’s emotional state to biometrics. Then a cull: manual fitness and sleep-duration scoring removed, the dashboard recomposed, a Zustand persist migration (v3→v4) adding an overrides slice. 35 commits on the mainline.
The trilogy — a philosophy by subtraction
v1 named the problem. v2 tried every tool that sounded relevant. v3 asked what actually helps someone recover? — cut everything that didn't, and then learned to measure what's left: Garmin HRV, body battery, Hevy lifts, a subjective sleep tap, reconciled into one vitality score. The pivot from grind for points to measured recovery could not have been written down in February. It had to be built, used, and re-built.
The v3 mechanics underneath the new sensor layer: a 5-mood × 6-emotional-state × trajectory engine; blended scoring; urge surfing with a 20-minute timer and tiered partial credit; parent mode; harm-reduction physics (edible above spliff; alcohol escalates at drink 3+); offline-first with an async Supabase sync queue. Deployed on Vercel Node functions with three cron schedules (heartbeat, Hevy pull, Garmin pull). You could not have specified “reconcile a Garmin body-battery reading against a subjective sleep tap and a Hevy lift log” in February, because in February the product didn’t yet know it was a recovery instrument. It learned that by being used.
The Experiment, Doubled: Archetypes (v1 + v2)
It began life as a “single-commit experiment,” grew into a “mobile-iconography endgame,” and back in April reached feature-completeness — a full Quiz + Reading assessment flow — and then stopped. Silent since Apr 23, and silent again this round. The project finished; the author’s attention moved on (first to a moving truck, now to a card game). Notable mostly because of how it was built: v1 (archetypes, on GitHub) was written entirely on the Claude Code mobile app, thumb-typed, as an experiment in whether a real app could be built without a laptop. The answer turned out to be yes.
Archetypes — breadth → depth
Left: ten archetypal systems spread laterally, three interfaces beneath them, all drawn with vanilla JS on a phone. Right: six systems chosen, each given vertical depth — KWML as the pedagogical spine, plus an Atlas layer for cross-system mappings, a Mirror for shadow prompts, a Profile for cross-system tensions, and a Today surface for daily archetype. The decision to go deep was only thinkable after the wide version had shipped.
v2’s grammar. A DESIGN.md enforces a shared visual language across all six systems: KWML uses 3D platonic solids with bloom; Jungian organic forms; Enneagram instruments; MBTI animated cognitive glyphs; Tarot halos; Hero’s Journey silhouettes. Four motion primitives (breath, spin, pulse, shimmer) defined once. Five semantic totem scales (xs–hero, 22–200+ px) with animation budgets. Cards layer frame → field → token. This is the part where the project becomes serious.
v2’s editorial scaffolding. Debates taxonomy (confidence/impact/status fields). Exemplars network with source attributions — /atlas/exemplars was just expanded by 25 figures with a tiered index. A weak-hermeneutic methodology page with pipeline infographics. Citations linked from debates back to bibliography entries — a real graph, not a citation theater.
What +44 commits looks like. The assessment flow. /quiz (landing), /quiz/take (stratified item draw, a Likert scale with a gold spine and warm gradient, section progression, resume/undo), and /quiz/r/[code] — an editorial “Reading” spread with a constellation centerpiece and URL-encoded answers. Feature-vector visualizations (radar + resonance network) wired into all six archetype detail pages, rich snippets across every page, the completion screen previewing your cast and routing into the Reading. The pixel-level polish stayed (Likert spine snapped to whole-pixel rows, axis-label clip fixes) right up to the last commit on Apr 23.
Build to Think verdict. v1 asked can I map every system on a phone? v2 asked what if I pick six and treat them as editorial? — and, with the quiz, finally answered the question the editorial implied: how does someone find their own archetype? The assessment was the last thing built and the only thing that turns a beautiful reference into a usable tool. That it shipped and then went quiet is itself a data point: the project reached completeness exactly as a cross-country move arrived. It is still pre-launch — Vercel-ready, no public domain yet.
The Mods: minecraft-mods
One directory, two projects, two entirely different personalities.
MTL Memories (Forge 1.20.1, Java 17). A nostalgia mod for Montreal and McGill 2004–2008. 14 custom items (poutine, Montreal bagel, smoked meat, Gerts token, Arcade Fire vinyl). 5 quest storylines. Status: exploratory. The quest framework runs, but it’s a foundation without the visual layer — which is roughly the state of memory itself.
LabsCraft (Fabric 1.21.4, Java 21 + a Node.js agent server). An LLM-powered mod simulating an APM internship at “Google Labs” on an AI video product called “Flow.” The centerpiece is Josh Woodward, a PM NPC whose dialogue is generated by Claude Sonnet (Gemini fallback). This is exactly as on-the-nose as it sounds, which is the point.
The mod (46 Java files, 5,391 LOC) sends world state every tick via HTTP to an agent server (13 TS files, 1,394 LOC) running Express on port 3001. Six trigger types (chat, interaction, idle-near-objective, quest-complete, danger, periodic proximity). SQLite stores conversation history, top-5 extracted memories per player, and quest state. Memory extraction every five conversations; summarization at threshold. Josh’s character brief: deadpan PM humor, references to syncs/sprints/P0s/OKRs, max three sentences per turn. Status: shipped — built jar at build/libs/labscraft-1.0.0.jar, 148 unit tests, three Claude worktrees active during the build.
Build to Think verdict. Two modes sharing a disk and nothing else. MTL Memories is pure nostalgia-as-enumeration: the act of listing what to include is the project. LabsCraft is the technically serious frontier — an agentic NPC architecture (perceive → decide → reason → execute) with per-player memory and multi-provider LLM fallback, emerging from iteration.
The Gift: kareemrpg
Shipped on itch.io. A birthday gift for a friend named Kareem. Five learning projects in 16 days, each one existing solely so the next one could exist:
- learningproj (May 24) — first GDScript, 25 lines, “what is a node?”
- kareemrpg-beta (May 24) — mobile RPG skeleton
- dialogictut (May 25) — Dialogic addon + NPC basics
- daytworpg (May 25) — 9 scripts, dialogue, audio, NPC/follower systems
- dialogictutotrial (Jun 9) — final game: 66 scripts, 68 dialogic files, 29 scenes
Exported as WebAssembly, published on itch.io, embedded at ummerr.com/kareemrpg. The fastest build-to-learn cycle in the portfolio: from zero Godot experience to a published game in 16 days. The learning ladder is the project history — if you opened the directory cold you could reconstruct the syllabus from the timestamps alone.
The Explainer: inference → inference.ummerr.com
Status: Shipped • Commits: 63 • Last commit: Apr 17, 2026 Stack: React 19 · TypeScript · Vite · Tailwind v4 · Lucide React Live: inference.ummerr.com
“The Fun Inference Calculator.” An interactive web explainer for generative AI compute costs across modalities. Unchanged since the last audit — shipped, stable, and still doing its job. All 12 sections live: Frontier Frictions, Lifecycle, Techniques Ladder, Forward Bets, Failure Modes, Unit Swap, Hidden Costs, Cost Drop Tracker, Video Price Watch, Silicon, Batch vs Realtime, Napkin Math Playground.
Build to Think verdict. The third audit doesn’t change the verdict — it reinforces it. A one-day explainer became a six-day site; the “Cost Drop Tracker” could only be imagined after the calculator existed. Specs don’t generate second-order surfaces. Only running code generates second-order surfaces.
The Ritual: bass
Status: Live structure (unshipped domain) • Commits: 10 (+6) • Last commit: Apr 20, 2026 Stack: Next.js (App Router) · TypeScript · Tailwind v4 · pnpm · flat markdown content · zod
Born the day of the last audit, bass got two more days of attention before the move arrived. A personal site that scaffolds a daily 15 minutes of bass practice — not a content library but a daily loop: warm up → skill of the week → fretboard minute → play something fun → log it. Git is the streak tracker. All content is flat markdown.
What the six new commits added: a real tab system. A tab library with a color-per-key palette tied to the circle of fifths; a zod-validated structured tab schema (Phase A); a three-view reader — beat grid / ASCII / fretboard (Phase B); a guided practice path; and a 30-tab library with “Start here” grouping. Then, on Apr 20, it stopped.
What shipped in v1. / — the daily loop: five numbered steps + streak + 90-day heatmap + explore nav. /lessons — ten beginner lessons with status badges (not-started / learning / practicing / comfortable / retired). /lessons/[slug] — lesson detail. /fretboard — fretboard explorer, beginner-default (neutral dots, note-name labels, four presets: All notes / C major / A minor / E minor pentatonic); “Show advanced” reveals 12 roots, 5 scales, degree/interval labels. /drills/fretboard-notes — silent note-recognition drill, two modes (Name→Fret, Fret→Name), 12 prompts per round, single-string SVG. /log — copy-template flow for today’s practice entry, filename hint, recent-entries list. URL presets supported: /fretboard?preset=c-major.
The pedagogy. A PLAN.md file — 15KB, six build phases, references to BassBuzz / Scott’s Bass Lessons / StudyBass / TalkingBass / Justin Guitar / Berklee / Fogg & Clear habit-formation science — enumerates the thesis before any code:
“The site is not a content library. It is the scaffold around Ummerr’s daily 15 minutes with the bass in hand.”
Six principles are written down explicitly: beginner-first defaults, one next action, silent-first (no audio in v1), git is the database, progress must be visible (heatmap, lesson-status transitions, streaks), pedagogy over features. The site’s home page is the five-step loop. Not a dashboard of features — the loop itself.
The AGENTS.md reveal. A single file in the repo, eight lines:
“This is NOT the Next.js you know. This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in
node_modules/next/dist/docs/before writing any code. Heed deprecation notices.”
That one file — a one-sentence correction to the agent’s priors — is a complete Build to Think artifact: the author noticed the tool’s training data was stale, wrote down the correction in eight lines, and moved on. No meeting. No ticket.
Build to Think verdict. The clearest Build to Think instance in the entire portfolio, because the product is literally the loop that Build to Think advocates: a daily 15 minutes with an instrument, logged in markdown, streak-tracked by git. The site isn’t for visitors. It’s a personal scaffold that happens to be public because it’s easier to ship Next.js on Vercel than to build a bespoke tracker. Five small things, ≈15 minutes, skip any of them. Showing up is the win.
That it paused mid-stride doesn’t undercut the thesis — it’s a personal scaffold, and personal scaffolds wait for you. The tab reader is now there for whenever the bass comes out of its case in the new apartment. bass joins bookmarks, inference, and the Dopamine Rat as a tool whose use is indistinguishable from its design.
The Test Bench: VidMetaPrompt
A framework for transforming high-level creative video ideas into structured 7-component prompts for Veo-3 generation. Modular: Analysis Engine, Knowledge Base, Character Builder, Generation Engine, Quality Validator. 15+ implementation modules; UI scaffolds exist and are empty. Where bookmarks discovered its shape through deployment, this one discovers its shape through tests. Same principle, different probe.
Footnotes: smaller projects
cursorMint — Personal finance tracker. Loads bank CSVs, standardizes transactions, stores in SQLite, plots spending. ~350 lines. No git. Functional utility — it exists because the alternative was a SaaS that would have cost more than the groceries it tracked.
godot — New to the ls this round, but not new work. A 2025-era Godot workspace — kareemrpg-beta, daytworpg, two Dialogic tutorials, learningproj — last touched mid-2025. No git history of its own. It’s the cradle where kareemrpg (the shipped birthday gift on itch.io) was learned and built, surfaced now only because the audit re-scanned the directory. A delta in the listing, not in the work.
film — Astro 6 photography portfolio scaffold. Single commit. Template stage.
StreakUp — Cloned from rezahedi/StreakUp as an architectural reference. This is not my code. A production-quality habit tracker studied for patterns (CRUD flow, streak lifecycle, timezone handling, Prisma schema design).
testExport — Godot web export test. Binary artifact. Not a development project; it’s evidence.
dopRatTest — An empty directory. The most honest project in the portfolio. It knows it doesn’t exist.
The Build-to-Think Scorecard
Every project started without a spec. The interesting column is the right one — what only became visible because building forced it into the open.
Spec → Reality — the gap building made visible
Every project started with code, not a spec. Constraints taught. Writing followed building. The arrows are the gap building made visible — and the two newest, sf and golf, are the clearest of all: you cannot design a move into a repository, you can only build it.
Closing
Seven audits in, the lineage has a rhythm, and this is its quietest beat: one commit in seven days. It would be easy to read that as nothing happening. It’s the opposite — it’s what finished looks like. Last round closed with a game shipped; this round opens with the game still shipped, and the only new work is the small, unasked-for tool that using a finished thing eventually demands. A CSV importer is not a headline. But it’s the most faithful Build-to-Think artifact in the whole round, because nobody could have specified it in advance — the need was invisible until someone sat inside the product and got tired of typing.
That’s the half of the thesis the loud rounds hide. New repos and launches are easy to narrate; the unglamorous after — maintaining, tooling, smoothing the friction you only feel once the thing is real — is where most side projects quietly rot instead. This portfolio didn’t rot this week. It noticed an annoyance and built the fix, then stopped. One commit, scoped exactly to the problem, and not a line of busywork to make the audit look busier.
No design doc asks for a content pipeline. Only a finished product, in use, does. The building was the thinking; this week, the maintaining was too — and the smallest commit in the lineage is the clearest evidence yet that the loop is real and not just productive when it’s exciting.
This audit was generated by Claude Code across 3 filesystem locations and 20 repositories, inspecting ~1,073 commits. Screenshots captured with headless Chrome via Puppeteer. Zero permission prompts, by design. To regenerate, run /audit from ~/CodeProj/.