How the work gets done
People keep asking how one person keeps up with a hospital job, a temple, a household, a couple of small businesses, and still has time to build things. This is the honest answer. It isn't hustle. It's a system — and a collaborator.
From writing programs to conducting a system
If you've written software for a living, you know the old rhythm: you have an idea, you sit down, and you type every line that makes it real. The computer does exactly what you tell it and nothing more. That model has been true for fifty years, and it's a good one. This is a story about a second model that now sits on top of it — and about the odd, quiet leverage it creates.
Instead of writing a program every time I need something done, I've built a home for an AI collaborator to work in — with a memory, a rulebook, and a toolbox — so that most of the time I describe the outcome in plain English and the system carries it out, checks its own work, and remembers what it learned.
The name of that home is homelab2. It's not an app you can point at. It's more like a workshop: a single folder on my computer that holds my whole life as plain text and small programs, and an AI (Anthropic's Claude, running as a command-line agent) that lives and works inside it. The two of us have been building it together for months.
The instinct of a lifelong engineer — mine too — is to automate by writing a script. Something annoying happens twice, so you write forty lines of code to make it stop. That's still here, and still good. But it has a ceiling: every script is a thing you have to write, test, name, and maintain. The world has a million small frictions and you only have so many evenings.
The new move is different. When something annoying happens, I tell my collaborator the outcome I want, in a sentence, and it writes the script, runs it, verifies it worked, files the result where it belongs, and writes down the lesson so neither of us re-derives it next month. My job shifts from typing every line to describing intent, setting the guard rails, and reviewing the result.
The unlock isn't that the AI is smart. It's that I gave it a place to stand — a memory, a rulebook, and a toolbox — so its work compounds instead of evaporating.
That last word matters: compounds. A normal chatbot conversation is disposable — you explain your situation, get an answer, close the tab, and tomorrow it remembers none of it. The whole design of homelab2 is a fight against that evaporation. Turn the page and I'll show you the five ideas doing the actual work.
Five ideas doing the heavy lifting
None of these is exotic. If you've ever set up a build system or written a good README, you already have the instincts. They're just pointed at a new target.
One repository for a whole life
Everything lives in a single, version-controlled folder: temple operations, emergency-room shift scheduling, home and HOA paperwork, the family businesses, finances, personal projects — all as plain text, notes, and small programs. Because it's all in one place and under version control, nothing is ever truly lost, every change is reversible, and the AI can reason across my whole life at once instead of through a dozen disconnected apps. It's git for a life, and the AI has read access to all of it.
A collaborator with a memory — and a constitution
At the root of the folder sits a document the AI reads at the start of every single session. Think of it as a constitution: how I like things done, what to never do, which tool to reach for, how to write in my voice. Alongside it is a growing library of memory files. When I correct the AI ("no, deletions on a Mac should go to the Trash, not be erased"), it doesn't just fix that one thing — it writes the lesson down as a rule, so it never makes that mistake again. The collaborator that shows up tomorrow is smarter than the one from yesterday.
Plain English, but with real discipline
This is the part people miss. "Just ask the AI" is not enough — that's how you get confident nonsense. What makes the output trustworthy is the same discipline you'd apply to a junior engineer: written standards, hard "never do this" rules, and a bias toward checking the source instead of guessing. I've encoded dozens — never invent a web link, always compute the day-of-week rather than recall it, confirm before anything irreversible. Guard rails aren't a cage; they're what let me delegate without babysitting.
Build a tool once, reuse it forever
Over time, the useful moves get crystallized into reusable commands, and into connectors that let the AI reach real services directly: my email, my calendars, my files, my bank data, my task list, the home automation. So "review my transactions," "book the tire rotation that respects my shift schedule," or "translate this notice into natural Chinese" aren't me clicking through five apps — they're single commands the AI runs end to end. Each was built once, in a spare hour, and now costs nothing to reuse.
It keeps working while I sleep
A Mac Studio sits in my house running around the clock as a quiet "agent server." Behind it are automations that watch for things and act on their own — a bill arrives and gets forwarded to the right person, a report gets filed, a monitor pings me only when something is actually wrong. And I don't work one conversation at a time: I'll often have many AI sessions running at once, coordinating through the shared folder like a small crew working different rooms of the same house. One human, many hands.
Three things that actually happened
Abstractions are easy to wave at. Here's what the day-to-day really looks like — small, unglamorous, and exactly where the time goes.
My parents like to see the home water-usage report each month. I used to forward it by hand. One afternoon I said, "set it up so emails like this one automatically forward to Mom and Dad." The system found the exact report I'd forwarded before, confirmed who and where, built the automation, and flagged one edge case for me to approve. It's forwarded itself every month since. I'll never think about it again.
I asked for a read on my parents' savings. The system pulled seven brokerage statements from my files, read the holdings out of each PDF, wrote a plain-language assessment, produced a clean bilingual one-page dashboard in English and Chinese, emailed it to my parents with me copied, and filed everything back into the right folder — all in a single session. The same task, done the old way, is an afternoon of spreadsheets. (That report is one of the pages on this very site — behind a lock, because it's family financial data.)
Temple work needs natural Traditional Chinese, not stiff machine translation. So one of my specialist helpers is an AI sub-agent whose entire instruction set is written in Chinese — a deliberate trick, because a Chinese-primed model writes in a far more native register. I hand it English; it hands back Chinese a native reader wouldn't flinch at. That's the texture of the whole system: not one big AI, but a bench of specialists, each shaped for its job.
If you already build software
You may be pattern-matching this to things you already know — and you're right to. Almost every idea here is a familiar engineering concept, aimed somewhere new. The mental map:
The one genuinely new element is the executor. For fifty years the executor was deterministic: it did precisely what the code said. The executor here reasons in language, which makes it flexible enough to handle messy, one-off, human tasks that were never worth automating before — and fallible enough that the guard rails, the reviews, and the undo paths aren't optional niceties. They're the engineering.
Why this is careful, not reckless
It would be easy to hear all this as "he lets an AI run his life." That's not it, and the difference is the whole point. The human stays in the loop exactly where it counts:
- I'm the pilot. Anything that leaves the house — an email that actually sends, money that actually moves, a file that actually deletes — pauses for my sign-off. The AI drafts and proposes; I approve.
- Everything has an undo path. Version control, tags before big changes, deletions routed to the Trash instead of erased. If a call is wrong, reversing it takes a minute, not an afternoon.
- It's biased toward checking, not guessing. The rules push it to read the actual source — the real file, the real statement, the live calendar — rather than answer from a confident hunch. Guessing is the failure mode; the system is built against it.
- It fails loudly, not silently. The automations stay quiet when all is well and speak up the moment something breaks. No news is genuinely good news.
That's what turns a fast tool into a trustworthy one. The months of unglamorous work — the rules, the conventions, the review gates — are what let me actually hand things off and sleep at night.
Why it keeps getting better
Here's the real reason one person can keep up with all of it. The system has a ratchet. Every session tends to leave three kinds of residue: a bit of work done, maybe a new tool built, and — almost always — a lesson written down. The work is the obvious payoff. The tool and the lesson are the interest.
So the honest answer to "how do you do so much in so little time" isn't that any single day is superhuman. It's that very little effort is ever spent twice. A frustration handled once becomes a rule that prevents it forever. A useful script becomes a permanent command. The curve bends because the floor keeps rising — I begin each week a little further along than I ended the last.
A rough snapshot, not a scoreboard. The point isn't the numbers — it's that none of it has to be rebuilt tomorrow.
I'm not working harder than I used to. I'm just no longer starting from zero.
That's the whole trick, if it is one. Not a genius machine, not a robot running my life — a workshop I share with a fast, literal, tireless collaborator, where we've spent months making sure that everything we figure out, we only have to figure out once. The leverage isn't in any single day. It's in the fact that the workshop remembers.