Experiments, side projects, and notes from the dev lab.
I locked my laptop in a drawer for thirty days and ran the entire lab from a $300 Android phone. Some workflows were shockingly good, one nearly broke me at a Chicago O'Hare gate, and the verdict on the 'laptop is dead' crowd is more nuanced than either side wants to hear.
For one month, every feature on my side project had to answer a single question: could I explain it to a skeptical interviewer before their attention ran out? Half my codebase failed. Here's what survived, what got axed, and why the product got weirdly better.
My side project now has a Terms of Service, a privacy policy, and a registered LLC — and not a single user to show for it. Here's a week-by-week breakdown of where the hours actually went, plus the short list of legal chores that matter before launch and the long list that can wait.
I wired up a phone number, pointed an LLM at my hobby app's docs, and gave out the number to actual humans. The calls ranged from genuinely useful to deeply weird, and the transcript log turned out to be the best documentation audit I never paid for.
I mailed handwritten postcards to 50 strangers asking them to poke at my side project and mail back exactly one complaint. The response rate embarrassed my analytics dashboard, and the feedback stung in a way no tooltip ever has.
I know my AWS bill to the penny, but I had no idea what my own closet costs me. So I strapped a smart plug to every device in the lab and tracked watts, dollars, and grams of CO2 for a month. The results made me rethink what "always-on" actually means.
I charged 23 strangers five bucks a month to deploy whatever they wanted on my garage servers. Three months later, I've got receipts, a terms-of-service nobody read, and a surprisingly strong opinion about whether a micro-PaaS can pay for its own electricity.
I rebuilt my entire side project toolchain under the constraints of a 1968 mainframe: 1MB of RAM, no cloud, no autocomplete, no mercy. Three weeks later, my dev habits look very different — and honestly, so does my code.
For one week, anyone could push to my side project. Anonymous contributors renamed functions, restructured modules, and left commits like 'fix' and 'trust me.' Here's the full crime scene report, including the changes I'm actually keeping.
I wired an LLM into my homelab's monitoring stack so every service could file its own outage report in plain English. It worked great — until the reports got mouthy and I had to decide how much personality infrastructure is allowed to have.
I wired a Raspberry Pi and a camera module into my old intercom, and somewhere along the way the project stopped being about hardware. Once my neighbors got access to the doorbell feed, the real engineering problem turned out to be people, not solder.
For 48 hours I let strangers hammer, poke, and outright attack my live side project — and kept a running log of everything that broke. Spoiler: my security assumptions died faster than my uptime.
I wired a Raspberry Pi to text me whenever something in my home lab breaks, and then I gave the notifications a personality. A month of passive-aggressive alerts later, I know exactly which failures actually deserve my attention.
Ten years of commits, branches, and abandoned repos turned out to be the most honest productivity journal I never kept. Here's how I ran the analysis, what the 2am commits had in common, and the three habits that came out of it.
Half a year of daily engineering notes, dumped into one file and actually re-read. What I found: ideas that took three tries to stick, dead ends that were just early, and one debugging blind spot that cost me entire weekends. Plus the dead-simple note template that made the audit possible.
I released a tiny CLI tool as open source and committed to treating it like a digital pet — daily feedings, weekly grooming, full emotional investment. Here's the honest ledger of hours, stars, and what it actually cost me.
Perfumers can tell a good fragrance from a cheap knockoff in one whiff. Developers should be able to do the same with frameworks. Here's the five-sniff test I run before anything gets a repo in my lab.
Hosting, domains, API credits, a Raspberry Pi that never sleeps — the real operating cost of a one-person dev lab, itemized. Plus the ROI rule I use to decide which experiments earn compute time and which get a graceful shutdown.
I dragged five half-dead experiments out of my repos folder, gave each one a README, a demo, and a two-page write-up, and stapled them to a single landing page. Three weeks later, two interviewers brought up the parking app unprompted. Here's exactly what I changed and what recruiters actually clicked.
We celebrate launches and quietly ignore the projects we abandon, which is exactly backwards. Killing a side project — deliberately, with a post-mortem — is a judgment skill worth putting on display. Here are six funerals from my own graveyard and what each one taught me.