// a history of making things

One idea led to another.

Games, little apps, a smarter house, and the tools built along the way. 64 stories from 2012 to 2026, anchored to the work behind them.

Historical entries are written in retrospect and dated to documented project milestones. Gaps mean there isn't a selected story for that period.

Hover or focus a marker to preview. Click it to read the story.

2026

17 stories
  1. From Prototypes to Steam: Building Arcward

    Arcward started with a cursor and a reactor. Getting it ready for Steam means thinking about saves, controllers, packaging, and what a successful test actually proves.

  2. Building Games My Family Can Actually Play

    A one-button tower, a moonlit game of hide-and-seek, and a camp full of butterfly nets are changing how I think about controls, assistance, and getting everyone into a game.

  3. Web Town Hero: Beyond Websites

    Building a small-business website is only part of the work. Parent portals, booking integrations, contact forms, and ongoing maintenance have made Web Town Hero a broader engineering project.

  4. My VR and Animation Workshop

    VR tabletops, shared-room creatures, superhero traversal, and phone-based motion capture are different experiments with a common problem: making digital things feel right when people interact with them.

  5. The Infrastructure Behind My Growing Game Collection

    Shared input, networking, saves, and delivery checks help my Bevy projects benefit from each other's fixes without turning every game into the same application.

  6. AI Made More Code—Then I Needed Better Tools

    Faster implementation created a different problem: keeping track of work, preserving the spec, and reviewing what actually changed. Baton, terminal signals, and Review Desk are my attempts to make that manageable.

  7. Small Apps I Keep Building for Everyday Life

    A stroller timer, a sticker board, a reader, a scheduling poll, and a stay-request calendar. Small apps keep reminding me that useful software starts with an ordinary problem and a few decisions made carefully.

  8. Lava, a River Raft, and a Squirt Gun: A Week of VR Party Prototypes

    In one week at the end of July I started three quick WebXR party games for the Quest 3. A headless, emulated headset did a lot of the testing. It still could not tell me whether any of them were fun.

  9. Three Doors and a Fun Scorecard: Letting My Deckbuilder Stop Imitating

    In July I cut my co-op deckbuilder loose from its reference game: a new hero roster, a bot that finally shopped properly, an attempt to measure fun, and a map replaced by three doors.

  10. An AI Narrator for Game Night with My Kids

    I built a D&D session engine that narrates, voices the NPCs, and tracks the party while I run short adventures for my kids. Playing with it taught me more than building it did.

  11. My Tax Appeal Score Was Worse Than a Coin Flip

    I finally checked my property tax appeal scores against three years of real Board of Review decisions. The first result was humbling. What came after changed what the tool is actually for.

  12. Rented GPUs, a Sleepy Desktop, and Paying Per Image

    Between March and June I ran image, video, and 3D models three different ways: on a rented cloud GPU, on my own desktop with ComfyUI, and through paid APIs. Each one earned a place, for different reasons.

  13. One Must Draw: Studying a Game I Love So I Could Build My Own

    Seven weeks, about 3,600 commits, and a spec-driven AI harness later, my latest attempt at a co-op deckbuilder finally had a baseline I trusted, heroes of its own, and a working title.

  14. Hide-and-Seek, Crayons, and Monsters: Small Games for My Kids

    A spotlight that hunts for hiding Pokémon, a coloring app for the Steam Deck, and a phone-based monster drawing party game. Small games for my kids taught me more about controllers and playtesting than I expected.

  15. Two Pokémon Fan Games in Three Weeks: A Tower Defense and a Co-op Deckbuilder

    A two-day Bloons-style tower defense turned into a three-week co-op roguelite deckbuilder, and the biggest lesson was that the combat I actually wanted came from Slay the Spire, not the games I grew up with.

  16. A Second Brain, Then a Board for My Assistant

    In January I built a chat-driven second brain that filed my notes into Obsidian. Three days later I found an assistant with a better front door, turned my work into a skill for it, and then built the assistant a kanban board.

  17. Round Two of the Tax Crusade: Building an Appeal Tool for Attorneys

    Seven years after going door-to-door with property tax appeals, I pulled the old data out of a backup, pointed it at a different customer, and planned and built an MVP for tax attorneys in a single day.

2025

9 stories
  1. The AI Acceleration Era: Making Two Games in a Day and Starting a Web Agency

    2,189 commits in Q3 2025 alone. Pokémon Vampire Survivors with my kids. A web agency hitting $1000/month in recurring revenue. When AI meets a tinkerer's mindset, everything accelerates.

  2. Developer Tools & Gaming Utilities: Open Source, Inventory Managers, and Another Payday Sequel

    Building Mezzo (a mocking framework everyone at work loved), OCR inventory sorting for Diablo 4, and trying to recreate Payday 2 magic with Payday 3. Some projects succeed, some flop hard. Here's both.

  3. The Game Dev Deep Dive: Slay the Spire, Among Us, and Learning Kubernetes for Fun

    698 commits in a single quarter. Proximity-based chat, spreading alien viruses, and finally answering a question I'd wondered about since childhood: how do games actually work?

  4. Smart Homes & Tax Crusades: When Side Projects Meet Real-World Impact

    3D-printed sensor cases, Home Assistant automations, and going door-to-door helping strangers win property tax appeals. The story of when my tinkering habit actually started solving real problems.

  5. The Spark Era: How a Payday 2 Skill Calculator Got Millions of Views and Paid for Pizza

    From a side project to an NDA with Overkill Studios. This is the story of how a simple skill calculator website reached a huge community, paid for pizza, and became another place to put my growing mobile-development skills to work.

  6. One Mobile Foundation, Different Product Faces

    A late-November React Native demo explored reusable navigation, shared components, and distinct visual presentations.

  7. The Co-op Deckbuilder Moves into the Browser

    The recurring card-game idea reached a TypeScript browser implementation, with elemental effects and a very practical targeting problem.

  8. Do More, Live More: Getting the Card Interaction Right

    A mobile card app accumulated the small gesture, scrolling, and sharing changes that make a simple interaction feel usable.

  9. Giving the Godot Prototype a Better Workshop

    Early-2025 NodeBuster work focused on modular structure, a Godot upgrade, and documentation for the next round of changes.

2024

3 stories
  1. Turning a Node-Busting Idea toward Four-Player Co-op

    The Godot prototype grew lobbies, modifiers, boss behavior, and increasingly specific rules for upgrades.

  2. Returning to Property Data, One Neighborhood at a Time

    The 2024 tax rewrite revisited parsing, missing records, tests, and neighborhood information.

  3. The First StickerApp: Rewards, Persistence, and Screen Size

    The March 2024 app began with stickers and rewards, then quickly reached the practical details of saving selections and fitting tablets.

2023

5 stories
  1. Trying Godot Together: Sprites, Multiplayer, and One More Run

    A small game jam led into a Godot action-roguelike project, with animation tooling and multiplayer work along the way.

  2. Payday 3: Returning to the Skill-Calculator Idea

    The sequel brought new skill data, point limits, and shareable builds—and another chance to apply an old project pattern.

  3. Reading Loot Tooltips So I Could Read Fewer Loot Tooltips

    The Diablo 4 inventory experiment combined OCR, item rules, and tests to help sort the aftermath of a run.

  4. CardCoalition: Another Run at the Co-op Deckbuilder

    Unity lobbies, relay connections, card effects, and deck selection brought the recurring card-game idea into another prototype.

  5. The Less Photogenic Side of an Open-Source Tool

    Mezzo’s March 2023 work was dependency migration, build configuration, and coverage reporting—the maintenance behind the features.

2022

3 stories
  1. Turning a Huge Filing into Queryable Data

    A small Celsius-data project used extracted spreadsheets as the bridge between a long public filing and database queries.

  2. Which Version of That Component Is the App Actually Using?

    A React Native monorepo experiment explored published packages, local work in progress, and Yarn workspace resolution.

  3. Mezzo: Making Network Responses Something I Could Control

    Request interception, recording, profiles, and a GUI turned mocking into a tool I could work with directly.

2021

4 stories
  1. Back to the Ender 3: Probe Offsets and a Denser Leveling Grid

    The printer firmware history resumed with build-size fixes, probe adjustments, and a revised leveling setup.

  2. A Few Evenings with Trees, Lists, and Sorting

    AlgorithmPrep traded game infrastructure for small TypeScript problems with clear inputs and checkable results.

  3. A Tiny Crawler during the GPU Shortage

    A stock-checking script reduced one repetitive task to a periodic check and an email notification.

  4. Rebuilding the Co-op Card Game around Unity ECS

    Cards, powers, and network events came together in a Unity prototype where even solo play used the client/server path.

2020

3 stories
  1. Pathogenesis Needed a Room Code—and a Server Behind It

    The Go matchmaker turned “join a game” into an allocation problem involving Agones, room codes, containers, and cluster setup.

  2. Pathogenesis: What If the Infected Team Could Grow?

    The September 2020 Unity prototype combined social deduction with conversion, then immediately brought dedicated-server questions along with it.

  3. Coordinating Cameras with Raspberry Pis

    piScanner was a small distributed capture experiment: deploy code, check cameras, trigger work, and collect the images.

2019

4 stories
  1. When the Side Project Was the 3D Printer

    Two Marlin changes record a very physical kind of programming: configuring an Ender 3 and changing its BLTouch probing grid.

  2. The First Co-op Deckbuilder: Kotlin, Cards, and Monster Intent

    The libGDX-era prototype was already wrestling with turn boundaries, visible intent, and the difference between displaying an effect and implementing it.

  3. Codenames Was My Kotlin Game-Development Classroom

    A couch-friendly board-game adaptation became a practical tour of libGDX, ECS, and several approaches to networking.

  4. Putting the Weather and the House on a Watch

    A Fitbit watchface experiment brought time, steps, weather, and smart-home integration onto a much smaller screen.

2018

4 stories
  1. Property Data Becomes a Searchable Application

    Late-2018 tax-tool commits added township filters, linkable searches, and map views—the interface around the property data.

  2. Another Sensor on the Workbench

    A September 2018 laser-sensor sketch captures the hardware experiments growing alongside the home-automation configuration.

  3. Giving Code Review a Dashboard

    Git-review-stats moved from gathering GitHub data to a small website and CSV export, with a revealing pagination problem along the way.

  4. A Small App for Remembering the Right Card

    RewardsPoints paired a simple reminder with the less glamorous task of keeping changing reward information current.

2017

3 stories
  1. A Trivia Game Is Also an Argument about Answers

    A React and Firebase trivia project turned small rules about numbers, short answers, and final scores into real implementation work.

  2. Teaching the House to Notice Motion

    Home Assistant configuration and NodeMCU sketches came together in August 2017 around a wonderfully concrete interface: walking into a room.

  3. Looking Beyond the Commit Count

    A small GitHub reporting script tracked reviews, comments, and approvals—an early attempt to make development work easier to see.

2016

2 stories
  1. From a Party-Game Experiment to a React Native Pilot

    An early-2016 pitch, a summer with one intern, and a team rollout grew out of the tools I learned after playing Jackbox.

  2. Taking the Payday Skill Tree onto a Phone

    The July 2016 app commits capture the practical work behind moving a game companion from a website into React Native.

2015

3 stories
  1. The Halloween Party That Changed My Career

    Jackbox at a 2015 Halloween party led to a homemade party game, React and Redis, an interview, and eventually a very different day job.

  2. Drawing Games and the Trouble with Leaving the Room

    A spring 2015 Unity drawing-game experiment was already teaching me about multiplayer state, reconnects, and starting another round.

  3. Teaching a Card Game to Take Turns

    The January 2015 Spades history records bidding, scoring, AI work, and a shift from frame-by-frame updates to explicit game state.

2014

2 stories
  1. Hot Potato: My Earliest Surviving Multiplayer Experiment

    A tiny Unity LAN game from 2014 reveals that the urge to build something people could play together was already there.

  2. Recipes, Grocery Lists, and Learning the Whole Stack

    A homemade recipe app became a playground for Django REST Framework, AngularJS, food search, and a Firebase grocery list.

2013

1 story
  1. An Online Card Table for Any Game

    Before the later co-op deckbuilders, a 2013 project aimed to let friends bring their own card images to a shared virtual table.

2012

1 story
  1. A Song Catalog Before the Side-Project Archive

    A 2012 Java and MongoDB experiment brings the archive back to song metadata, Spring Roo, and an earlier generation of web tooling.