memorydial

I said I'd build it. Last post I wrote, “That's the next build.” The Eat Watch on my wrist worked, but it was deaf. I logged meals in MyFatnessPal, then tapped the same calories into the watch by hand. I was the middleware. Two systems, no bridge, me in the middle pressing buttons.

Then I built DogWatch.

DogWatch was supposed to be about counting dogs on the walk to daycare. It was. But it taught me plumbing. Data flowing from wrist to phone to server. A Garmin app that talked to Django. By the time the first walk synced, zero dogs and all, I had a pipeline.

If I could sync dog counts, I could sync calories.

The Build

The architecture is simple because the watch is stupid. On purpose.

Every five minutes, the Garmin sends one request to the server: give me today's numbers. The server checks what I've logged in MyFatnessPal, does the maths, and sends back three numbers. Goal. Consumed. Remaining.

The watch stores nothing. Calculates nothing. Decides nothing. It asks one question and displays the answer. Green means eat. Red means stop.

When I log a burrito at lunch, the server knows within five minutes. I don't open anything. I glance at my wrist. The number moved.

Midnight comes, the count starts fresh, and the watch goes green again. The first morning it worked, I just stood there looking at it. A zero I hadn't typed.

Walker called it a fuel gauge. The gauge doesn't know how the engine works. It just reads the tank.

The Skin

Walker never built the Eat Watch. But he drew one. In The Hacker's Diet he mocked up a watch face: square, black, a red-bordered LCD screen with “Marinchip Eat Watch” in italic script across the top. It looked like a Casio from 1985. A “Turbo Digital” badge sat at the bottom like a maker's mark on a thing that never existed.

I wanted mine to look like that. The problem was shape. Walker drew a rectangle. Garmin makes circles. So I redrew it: same bezels, same script, same badge, bent around a round face. The LCD tan, the red border, the italic branding. All of it, just curved.

Now it sits on my wrist. Green text, “EAT,” the remaining calories underneath. A relic from a future that never shipped, finally running on real hardware.

The Arc

A calorie counter. Then a Garmin app. Then a system to connect them. Each build was the logical next step, each question a little harder than the last. Could I build something useful? Could I build for hardware? Could I wire it all together?

The answer kept being yes.

The calorie counter talks to the watch. Loop closed.

I look at my wrist. Green. I can eat.

Walker imagined this in 1991. He never had the watch. I do.

-—

If you want to try this yourself:

FatWatch is a Garmin watch face that connects to MyFatnessPal. If there's enough interest I'll make both available. MyFatnessPal is the calorie counter that started all of this. You can read about it in the first post in this series.

Father and son walking to daycare, counting dogs along the way

Every morning my son and I walk to daycare through quiet streets.

We have one rule, his rule: when we see a dog, we stop and we look.

Some days we see the man with three St. Bernards. A woman with two Bernese Mountain Dogs. Last Friday she only had one. We looked worried.

“Tiberius is sick today. He will be around next week.”

When a big dog appears, my son kicks his legs and looks at me with an expression that says are you seeing this.

We do not care for small dogs.

We started keeping count. Three or more was a good start to the day.

But the question we could not shake: which route has the most dogs?

The Grid

The grid: six streets north-south, four avenues east-west. Street E is the main road. We can only cross it at the lights. Everything else is fair game.

Twelve valid routes from home to daycare, each shaped by where we can cross.

We had no data.

I needed a way to pick a random route, count dogs as I walked, and see the results later. The Garmin on my wrist could do all of it.

The Build

He was napping.

I wanted a Garmin app that would tell me which way to go, count dogs with up and down buttons for false positives or dogs deemed too small, and sync to a dashboard on my laptop.

Garmin apps are written in MonkeyC. MonkeyDo runs them. I chose Python and Django for the backend. The watch would sync through the Garmin Connect app.

The watch needed to pick a random route. We can only cross Street E at the lights on 4th and 2nd. Everything else is fair game. I mapped twenty-four possible routes.

I worked on the spec and tried to catch any edge cases, what happens when there's no connection? How do I know which leg of the route I'm on?

I fed it into Claude Code's planning mode. Reviewed. Then enabled yolo mode and let it run.

The app worked in the simulator on the first try. I adjusted fonts and configured ngrok so data could flow from watch to server.

I synced a test walk. The terminal lit up. The dashboard updated.

One kilometer. Ten dogs. Ten seconds.

Test data. Ten dogs in ten seconds would be a miracle, a stampede, or the best day ever.

The Walk

I deployed it to the Raspberry Pi that weekend and tested the sync one more time. Then we went on with our weekend.

Monday morning. First real test.

My son in the stroller. Watch on my wrist showing Route 1. Left for 200 metres.

We walked. I watched for dogs. He pointed at trees, birds, a crack in the sidewalk.

No dogs.

Not one.

The entire route, start to finish, and not a single dog. No St. Bernards. No Tiberius. No doodles. Not even the small ones we ignore.

I ended the walk. The watch synced. The dashboard updated.

Total walks: one. Total dogs: zero.

The watch tells you to stop eating. No willpower required. Just a signal, like a fuel gauge.

John Walker called it the Eat Watch. The AutoCAD founder wrote The Hacker's Diet in 1991. An engineer's approach to the body: treat it as a system. We are bags of water. Calories go in, calories go out. Weight is the integral of the difference. Why not fat?

Walker proposed a thought experiment. You set a calorie budget for the day. The watch counts down as you eat. When you hit zero, it tells you to stop.

He never built it. This was 1991. He ran the numbers on paper, then spreadsheets.

So I built it. I'd never touched Garmin development or heard of MonkeyC before. I opened Claude, started the spec, and three hours later I had an app on my wrist.

The app: a daily calorie budget, a reset hour. The watch stores both. One word at the top: EAT in green. One number below: calories remaining. When the number hits zero, the text changes to STOP in red. At your reset hour, it starts fresh.

I look at my wrist. Green. I can eat.

It's simple. Tap to add or subtract calories. The watch isn't connected to anything. It only knows what I tell it.

MyFitnessPal has the real numbers. Every meal logged, every snack timestamped. If I can sync that data to my wrist, the Eat Watch becomes what Walker imagined: a closed loop.

That's the next build.

The Eat Watch app on a Garmin watch showing green EAT text and remaining calories

A white onion almost broke me.

I was cooking dinner, logging as I went. I weighed the onion, chopped it, threw it into the pan, then opened MyFitnessPal. The first result had more fat than a stick of butter.

I knew that was wrong. I spent the next five minutes hunting through a database of user-submitted shite, guessing which entry was accurate. For an onion.

Why am I still using this crap?

Right then I decided to build my own.

It came together with Claude Code pretty quick. A Django Web app, SQLite Database and a cheap GPT model deployed onto a raspberry pi and made accessable over the web via Tailscale.

You describe food in plain English. It returns reasonable nutrition data. Just type what you ate.

When I'm cooking, I know what's going in. Last week I made chili. I pasted the ingredients straight from a YouTube description: ground beef, kidney beans, tomatoes, onion, half a packet of American cheese. Told it six portions. It came back: 340 calories, 26g protein per bowl.

When I'm out, I don't know what's in the burrito. I don't need to. I type “chipotle chicken burrito, no sour cream” and it comes back: 650 calories, 42g protein, 80% confidence. Good enough. Logged and done.

Here's what the big apps miss: a rough estimate you record beats a precise measurement you don't. Tracking is a habit. Habits need to be easy.

Last week I wanted to re-log yesterday's breakfast with one click. Took an hour. Now it's there, because it's mine.

And mine doesn't store passwords in plain text.