Like most devs, I keep a mental backlog of useful-to-me project ideas. In my younger (pre-kids) days, I’d easily spend 20 or 30 hours a week playing around with personal projects, interesting programming languages, or new frameworks. As I grew and felt more constraints on my personal time, that changed; it became a few hours here-and-there, spread sparsely. Personal dev projects became difficult to maintain momentum on, and then were abandoned completely. For a couple of years, I’d open one of those projects, get a weekend or two in, then drop it for a month and never come back. The reason wasn’t lack of interest. It was the math.

The Old Math

With two young kids and a day job that deserves real focus, a side project had to clear an implicit bar: “if I get excited and load all of this into my head tonight, am I actually going to be back in this code again soon?” Usually the honest answer was no. GoalChasr, for example, was a small VueJS project selling $5 iFit-related magnets. I had a small community of repeat customers, and several ideas for growth and stickiness. I was eager, but found it hard to make any progress on the bigger changes. The friction wasn’t really “what was I going to do next.” It was rebuilding the mental model, and re-figuring out what state I’d left the code in, every time I opened the project after a several-day gap. Half the session burned before I’d written a line.

So I mostly didn’t start things. Hobbies drifted toward more discrete, self-contained stuff: hiking, playgrounds, Home Assistant automations that fit inside a Saturday.

What Changed

I didn’t notice the change all at once. It crept in. An hour of personal coding after putting the kids to bed used to be thirty minutes of context-loading and thirty minutes of actual flow. At some point it became a solid hour of productivity, because the project’s state wasn’t living in my head anymore. The plan file was sitting right there with “we left off here, the next step is this.” I could skip the reacquaintance entirely. This wasn’t light vibe-coding; it was “real” hands-on-keyboard dev work, with context being spoon-fed to me based on prior agreement & planning.

The shape that does most of the externalizing for me is a long upfront planning conversation that produces a written plan, then small implementation units against it. One workflow inside that shape (not the only one I use, though it’s representative) is Matt Pocock’s grill-me skill, where Claude interrogates me about a feature until the design is concrete, followed by ping-pong TDD (Claude writes a failing test, I make it pass by hand). The grill phase takes a non-trivial part of the total time and requires focus, because that’s where many of the implementation decisions actually get made. After that, the path is laid out and broken into small enough pieces that any one of them fits into an evening.

Regained Momentum

Lately I’ve been working on PushForward. It’s fun, though not particularly novel: a conversational AI fitness coach that pulls my Hevy (weightlifting) and Google Health (step count, etc) data into one ongoing thread so the model actually knows my training history. There are dozens of AI fitness coaches in 2026 and a handful that already do cross-tracker synthesis, so I’m not claiming the idea is unique. I’m building it because I’m the user, and because shipping a real working agent end-to-end beats reading about them.

Recently, I added the new Google Health API integration to the agent. One big upfront planning session covered the architecture, the OAuth flow, the new agent tools (get_step_count, get_weight_history, etc.), and how it slots into the existing orchestration. That got split into discrete units, each its own small plan I could knock out in an evening or two. The big plan kept the direction; the small plans were the spoon-fed next-step I’d find waiting when I came back a week later. A year ago, I wouldn’t have started this. Not because the work was harder, but because the gaps between sessions would have killed it.

Latency Tolerance

Most AI-coding takes I read are about output per hour, lines per day, “10x productivity.” Those are a difference in degree, not kind. The real change for me is something else: latency tolerance. The gap I can leave between a session and the next without the project dying went from “a few days, maybe” to “a few weeks, fine.” That is what makes dev viable as a hobby again at this stage of life, and I suspect it’s undersold relative to the speed framing. Most devs with young kids, demanding day jobs, or scattered attention will recognize this math change as much as they will the speed one.