The Summer I Built Six Things I Never Had Time For
The Summer I Built Six Things
I Never Had Time For
A mini PC the size of a paperback quietly became the most capable machine I own. I’d wanted to build something like this for years. This summer I finally had the time.
built
now
box
this
retired
There is a mini PC sitting on a shelf in my apartment, roughly the size of a paperback, and over the last two months it quietly became the most capable machine I own. It runs my home’s lights. It streams my movies to the TV. It serves the comics I read every week through a reader I built myself. It shows me my sleep, my weight, my blood pressure, and my blood sugar on a single page that updates while I’m asleep. It runs a private search engine that answers to no advertiser. Five services running right now, walled off from each other, each one restarting on its own after a power cut and backing itself up at two in the morning.
Here’s what I want to be clear about, because it’s the whole point: I could have built all of this years ago. So could you. None of it took a computer science degree. It took time, the kind of uninterrupted stretch of evenings I never had a spare one of. I built it with Claude Code, and what that changed wasn’t my ability. It was the price. What used to cost weeks now fits in the cracks of a normal week, so I finally did the thing I’d been meaning to do for years. The wall between “I wish I had that” and “I have that” didn’t come down because I got smarter. It came down because getting over it stopped taking weeks, and I think it’s about to come down for everyone.
It started with a dying Raspberry Pi
For a couple of years my house ran on a Raspberry Pi 3 B+, a $35 computer the size of a credit card, tucked behind a bookshelf and running Home Assistant. It quietly ran the lights, the routines, all of it. That little Pi was doing real work, and it was getting old, and I’d been nervous about it for months. If it died, the house went dumb, and I had no idea how to rebuild it.
So in late June I bought a GEEKOM IT12, an Intel i5 mini PC with sixteen gigs of RAM, about four hundred dollars, with the vague idea of “moving Home Assistant somewhere better.” What I did instead was wipe Windows off it and install Proxmox, which is the kind of software that normally lives in a server rack, not a Forest Hills apartment. Proxmox is a landlord. It doesn’t do any real work itself; it rents space to tenants, and each tenant is a fully isolated little computer. That one idea, one physical box pretending to be many separate machines, is the thing that made everything after it possible.
On June 24, with Claude Code walking me through it over an SSH connection from my Mac, I moved Home Assistant onto the new box as the first tenant. Restored the whole configuration from a backup: every automation, every scene, the Matter server that all the smart bulbs depend on. Toggled a real light to confirm it worked. Then I powered the old Pi off. That was the takeover moment, the instant the house changed hands from the credit-card computer to the paperback one. The Pi is still on a shelf, its memory card intact, as my rollback that I have never once needed.
It runs the entire house
This is the one that started it, and it’s still the one I’d miss most. Home Assistant controls fifteen lights across the apartment (WiZ bulbs, a Govee strip, an Elgato key light, a floor lamp), all over Matter, driven by twelve automations that run the day without me touching anything. The bedroom lamps do a slow sunrise ramp on weekday mornings: sixty percent at a warm 2500 Kelvin, then full brightness five minutes later, then a cool daylight white five minutes after that. But only when a “Work in Session” toggle is on, so a vacation day stays dark. The living room runs its own schedule behind a “School in Session” toggle, because my kid’s mornings and my mornings are different problems. Evenings follow the sunset on their own. And the scene system is hand-written, mine to reshape whenever I want.
If that had been the whole project, it would already have been worth it. But something had shifted in my head. The box had five more tenants’ worth of empty room in it, and now I knew how to fill them.
Then it started compounding
An hour to working. Then the fun part.
Here’s the part that still feels like cheating: getting a service running is the short part. I point Claude Code at a git repo, an installer script or one of my own projects, and about an hour later the thing works. Properly, not a demo. The rest of the night is tinkering, and tinkering turns out to be the easy part, not the hard part. I change what I want, redeploy, look at it, change it again. Every one of these lives in my own GitHub repo, so customizing isn’t some scary edit-the-server operation. It’s edit, push, deploy, with a full history of every change I’ve ever made. That’s how 8,284 lines of auto-generated config became 363 clean lines I finally understood, and how the comic reader kept growing features until it beat the thing it replaced.
I built my own comic reader
I read a lot of comics, and I’d been running an off-the-shelf server called Kavita to organize them. It was fine, but it depended on a finicky tagging step, and when the tags were wrong the library was wrong. So instead of fighting it, I had Claude Code help me write my own: a small, dependency-free Python web app that reads the folders on my NAS directly. It shows sixteen weeks of new releases as a grid of covers. It has an in-browser reader with arrow-key paging, a two-page spread mode, pinch to zoom. It remembers where I left off on every device, so I can start a book on the couch and finish it in bed. It searches the whole archive. I ran it side by side with Kavita for a few weeks, decided mine was better, and then deleted Kavita entirely. Stopped the tenant, destroyed it, gone in ten seconds. That casualness still surprises me. I build things and tear them down now the way you’d install and delete an app.
I fixed my TV, and the fix was a detective story
Watching movies off my NAS on the Apple TV had always stuttered, and I’d assumed the NAS was just too slow. It wasn’t. With Claude Code I stood up Jellyfin, a proper media server, as another tenant, and in the process we diagnosed what was really wrong. Two things, and neither was the NAS. The first was how I’d been watching at all: I’d play the file on my Mac and AirPlay-mirror it to the TV, two wireless hops, and the mirror was the twitchy one. The second was the Apple TV itself, a 2015 model with no hardware ability to decode modern HEVC video, so the sharpest files choked trying to do it in software. The fix was to serve the video straight from the mini PC to the Apple TV over a fully wired path, and let the box’s built-in Intel graphics transcode anything the old Apple TV can’t play. Every setting is written down, so the day I upgrade the Apple TV I know exactly what to loosen. The movies play perfectly now. And I didn’t spend a dollar on new gear to get there. The NAS is a little Synology I’ve had for years; the Apple TV is from 2015. Instead of replacing either one, I cut the wireless hops out of the path and let the new box do the heavy lifting, and both are running like new.
I built myself a health dashboard
This is the one I’m proudest of. I wear an Oura ring, stand on a Withings Body Scan, take my blood pressure with a Withings BPM Vision, and wear an Abbott continuous glucose monitor. Four devices, four separate apps, four walled gardens. I had Claude Code build a single dashboard that pulls all of it into one page: sleep and readiness, weight and body composition, blood pressure, and an hour-by-hour glucose trend with a healthy-range band. It syncs itself every fifteen minutes in the background, which is the entire reason it lives on the always-on mini PC and not my laptop: a laptop sleeps, and a sleeping laptop misses the glucose readings my phone forwards to it. Abbott has no public way to get the glucose data out, so we bridged it through Apple Health and a webhook. And the Body Scan measures muscle in each individual limb, but the app doesn’t cleanly expose which reading is which arm, so we reverse-engineered it, matching the numbers against what the official app displayed until we could label left arm, right arm, each leg, and torso correctly, confirmed to within a few hundredths of a percentage point. For years this sat on my someday list, not because I couldn’t build it but because I never had a free week for it. It took one afternoon.
I stood up a private search engine
The newest tenant is SearXNG, a metasearch engine that queries Bing, Brave, DuckDuckGo, and Google on my behalf from the server, so the search engines see my homelab, not a personal profile trailing cookies and ad-targeting. It’s privacy, not anonymity, and I try to be honest about the difference. The interesting part was how it got built. The normal installer is an interactive menu you click through; I had Claude Code drive it completely non-interactively over a single SSH command, working out the exact environment variables to feed it so it never stopped to ask a question. When I’m away from home, I reach it over a VPN tunnel back into the apartment. It works from a hotel the same as from my couch.
Why Claude Code, specifically
A few things made this possible, and I want to be precise about them, because “I used AI” is too vague to be useful to anyone.
It drove the real machine, not a tutorial.
When I hit problems, and I hit plenty (an error on the very first login, a web interface that mysteriously wouldn’t work in Chrome), the fix wasn’t me reading instructions and translating them into commands and typing them wrong. The commands ran. We worked over SSH from my Mac’s terminal, and I was describing what I wanted while the work happened in front of me.
It explained the why in the moment, not after.
This is the part I didn’t expect to matter so much. I wasn’t blindly pasting commands and hoping; when something worked, I could ask why it worked, right then, against my exact setup, and get a real answer before I moved on. Documentation can’t do that. A good engineer sitting beside you can, the kind you can interrupt with “wait, why did that fix it” and get the actual reason. I came out the other side understanding my own system, not just owning it.
It wrote everything down.
After each build, Claude Code produced the runbook: what we did, what went wrong, the exact commands, the traps to avoid next time. I now have a real operations manual for a system I couldn’t have described in May. The knowledge didn’t evaporate when I closed the terminal. It compounded. Each build started smarter than the last because the last one was documented, and that’s a large part of why six of these happened in two months instead of one happening and exhausting me.
It never made me feel stupid for asking.
Anyone who’s tried to learn this stuff the old way knows the other option: post the question on Stack Overflow and brace yourself. Closed as duplicate. “Why would you even want to do that.” The right answer wrapped in a small lecture about how you should have known better. I like understanding things; I have never enjoyed paying that toll to learn them. This never charged it. I could ask the obvious question, the naive one, the same one twice, and just get a straight answer in a normal voice, aimed at exactly what I was doing.
The only thing between me and this
was a free afternoon.
What changed
Before this summer, “run your own infrastructure” sat permanently on the someday list. Not because I couldn’t do it, but because doing it the old way meant weeks of evenings, and I have a job, a wife, a kid, and a life. So the whole category of thing (self-hosting, home servers, building your own tools instead of renting someone else’s) stayed a someday. I ran what came in a box.
Now it isn’t someday, and here’s the part worth sitting with: nothing about me changed. I didn’t get smarter or finally take the course. What changed is that the expertise stopped being something I had to front-load over months and became something I could summon exactly when I needed it, aimed at exactly my problem, and then keep in writing. The barrier was never the hardware. The hardware was four hundred dollars. And it was never really the knowledge either. It was the hours it used to take, and that’s the part that collapsed.
I don’t think this is really a story about a homelab. I think it’s an early look at the shape of a lot of things. The comic reader I built is nicer than the product I replaced. The health dashboard does something no company sells me. The media server is tuned more precisely to my hardware than any turnkey box would be, because I understood, with help, in the moment, why every setting was set the way it was. The decade-old Apple TV and the aging NAS are doing better work than they did when they were new; nothing got thrown out, it got taught new tricks. None of that required me to already be the person who could do it. It required me to know what I wanted, and to stay curious when it broke.
So here’s what I’d say, if you’ve ever wanted to build something like this but could never spare the weeks it used to take: it doesn’t take weeks anymore.
Think of the thing you’ve always wanted to build. You probably haven’t, because it looked like more time than you could spare. That’s what changed. It fits in the spare moments you actually have now. You were always capable of it. Go build it.
