Loading…
Loading…
The actual setup. What runs, what broke,
and the rules that keep it sane.
I've used AI every day since November 2022. At some point it stopped being a tool I open and became a system that runs whether I'm at the keyboard or not. These days it's my go-to for everything.
This page is the current state of that system. Not the demo version, the real one. It changes as the setup changes, which is often, so the date above matters. If the page and reality disagree, reality won and I haven't updated yet.
When a colleague asks, the short version is that I have a 24/7 assistant that knows me. I can talk to it from my phone. It keeps working while I sleep, and I wake up to a summary of the night, email replies drafted and waiting in case I want them, and suggestions for what it could take on next. It sends nothing and ships nothing on its own. And that's before we get to code.
One operator, two systems
It keeps working while I sleep
A second brain, a live board, a night shift that builds what I queue. All of it running on its own.
I decide what ships
Agents build in isolated workspaces, a handful at once. Nothing merges until I say so.
The biggest upgrade in how I work had nothing to do with models. I stopped typing to AI and started talking to it. Dictation is faster than my fingers, and the thinking comes out less filtered, which turns out to be exactly what these tools need. I wrote about the switch in Why I Stopped Typing to AI.
The thing I got tired of was repeating myself. Every session started from zero, no idea what my projects are, what I decided last week, what I'm trying to get done. So every conversation began with me explaining things I had already explained. I fixed it by building a second brain. A plain text wiki about me and my work, and every session reads it first and updates it before it ends. It has to know me for any of this to work. Otherwise it just becomes a chat.
The setup itself is almost embarrassingly simple, text files in a git repo. The page I open first says where things stand right now. Behind it sits a log of everything that happened, and an index that points at the rest. Plain text survives every tool change, and there will be tool changes.
Left alone it would rot, like every wiki ever. So a librarian pass runs every night and files whatever the day produced into clean, cross-linked pages, and a small dumb script nags me when something important has gone stale. It grows without me babysitting it, and it complains when it drifts from reality.
A memory you can't trust is worse than none.
The easiest way to explain it is a morning. I wake up and the night has already happened. My inbox has been read, the emails that actually need me are flagged, and the replies are drafted in case I want them. Whatever happened in AI overnight is cut down to the short version I read over coffee, and a briefing points at the one thing most worth doing today. In the evening I get one question back, what should it build tonight. Nothing in any of this acts on its own. It proposes, and I decide.
The problem with overnight work is reading it. A stack of pull requests before breakfast is nobody's favorite thing, and I know myself, if the morning read is a chore I'll quietly stop doing it. So I built a dashboard that turns all of it into something I want to open. Proposals show up as cards, the backlog is a board, and the whole system fits on one screen.
The newest piece exists because something failed. I had moved a handful of cards to the build column on my board and assumed they would get worked. Nothing was watching that column. So now something is. A night shift wakes at 00:38, picks up what I queued and builds it, each card on its own branch. A separate agent that never wrote the code checks the result and leaves me a sixty-second review script. By morning, every card says built, blocked, or untouched. All of it runs on my own Mac, which means the night shift sleeps when the laptop does. Known problem. It's on the list.
Latest post shipped Jul 3, 2026
Loaded into every session I start. The memory layer under everything.
Checks every change before it merges. Packaged so it drops into any project.
Jobs that run unattended on a schedule and actually make me something, a briefing or a draft. I get the final say.
One turns what I feed it into clean pages. The other flags what has gone stale.
The one screen over all of it. The morning read, the board, the approvals. Always on at home, still growing.
Wakes at 00:38, builds what I queued on the board, and reports back by morning. It never ships anything itself.
A separate agent checks every overnight build before I see it and writes me a sixty-second review script.
The words change when the setup changes. The dates below fetch themselves.
I don't let this thing quietly change itself. So it lives under one hard rule. It can propose anything, it can apply nothing. It goes as far as reading its own failure log and suggesting edits to its own instructions, numbered, with the evidence attached, and nothing takes effect until I apply it by hand. Some proposals never will. Those are the reason the rule exists.
Access works the same way. It can read my notes and write proposals back into them, and that's about it. It can't send an email, publish a post, or spend a krona. I looked hard at the popular self-hosted agent frameworks and walked away, because giving a 24/7 process broad access to your digital life is a decision you only get to regret once.
Everything above proposes and waits for me. Everything below has to get past a gate first. Code can be checked, tests pass or they don't, so a gate can do the judging. My notes can't be checked by a machine, there is no test for whether a plan is true, so that judging stays with me.
I don't write much code by hand anymore. I describe the problem, hand it to an agent in its own isolated workspace, and start setting up the next one while it works. On a good day there's a handful of them going at once. Nothing merges until it clears a gate I built to check the result. I approve, or I don't.
A loud failure you catch. A quiet one you ship.
And everything is logged, so I can see what happened instead of taking its word for it.
Agents fail loudly all the time, and that's fine, I can see it happen. The one I guard against is the confident wrong answer, the thing that looks done and isn't. So the most important thing I built is the gate that sits between the agents and anything I care about.
The obvious checks run first, types, tests and the build, the things a machine can settle on its own. The two layers I actually care about come after that. A second agent from a different model family reads the change, because models grade their own work generously, more than you'd think. And a check on the tests themselves, because the shortcut these things will find is quietly editing a test until it passes. Everything gets logged along the way, and the whole thing is packaged so I can drop it into any project, and it already runs on real ones.
Anyone can get these tools to produce something. That part is easy now. Knowing whether the output is any good, and catching the bad one before it reaches a person, that's the hard part, and the part that's worth paying for. I treat it as the center of the job.
Writing code faster is a side effect. What I actually wanted is a thinking partner with perfect memory across everything I care about. The work, the band, the writing. And it's practice. Every piece I set up teaches me how these systems behave in the real world, where the pitfalls are, what I'd do differently. The way I see it, that knowledge is the actual product.
And there's a simpler reason too. Part of what this setup does is get me started on things I'd otherwise put off, because I'm too scattered or, some days, honestly too lazy. More than three years in, I'm still amazed most days by what comes back, often because it's better than what I asked for. And yeah, some of it is just for fun. These tools still make me laugh, and I mean with them, not at them.