Most mornings now, I wake up to a briefing. It was written while I slept. It says what’s due in the next three days, what’s on the calendar, which emails actually need me, and what changed overnight in a couple of things I’m keeping an eye on. I read it with coffee. Nobody sat down one day and decided to build it. It grew out of asking the same questions every morning until it seemed dumb to keep asking them myself.
That briefing is the visible edge of a change in how I use AI. I don’t open a chat window and ask things anymore. I run a small team.
The roster
The word “team” sounds grander than it is. Nothing here is a product. It’s a handful of Claude sessions with different jobs, running at the same time, and a set of written rules about who does what.
There’s one that talks to me. Call it the manager. It knows the context, it makes judgment calls, and when other sessions finish a piece of work, it’s the one that checks the result before I see it. I spend most of my day with this one.
Then there are desks I borrow. When a task is big enough to deserve its own brief, the manager writes one. A fresh session picks it up, does the one thing, reports back, and is gone. It doesn’t keep anything. Whatever it learned, the manager decides whether to keep, and writes it down somewhere permanent. I got to this the hard way. One long session doing everything ends up with a context so full of half-finished threads that it forgets what it was told an hour ago.
And there are standing shifts. The morning briefing is one. Email gets sorted a few times a day into “needs you” and “already handled”. Something watches for messages that can’t wait. Once a week, one session reads through everything the team did and writes up what it thinks should change. It only proposes. I decide, and I say no more often than yes.
The reason any of this works is that the work isn’t queued up behind one conversation. More than one seat means the briefing gets written while another session is stuck in a customer service queue, and neither of them is waiting on me.
The memory is in files
This is the part I’d keep if I had to give up everything else.
None of these sessions remember anything on their own. They can’t. When the window closes, whatever was in it is gone, and if I ran the team on the model’s memory I’d be starting over every morning. So the memory lives in plain text files, under version control, and every session reads them when it starts.
The rules for the files are strict, and they’re the rules I’d want for a human team too. One fact per file. Every fact says where it came from and when. Decisions get recorded with the reasoning, not just the outcome, because a year from now the reasoning is the part I’ll want. When I say something myself, it’s stored word for word, quoted, and kept apart from anything the AI wrote in its own summary. You can open the folder and tell at a glance which sentences are mine and which are its.
There are two of these. One for work, one for home. They don’t reference each other, and a session working on one never opens the other. That was a deliberate line, and it has held.
What surprised me is how it feels. I thought I’d get speed. What I actually got is the feeling of not having to hold things in my head. When a decision comes up again, I can read what I decided last time and why, in my own words, instead of reconstructing it. I can ask why we do something a certain way and get a dated answer instead of a plausible one. It’s the difference between a colleague who takes notes and one who nods.
Trust is a ladder
I don’t trust the team evenly, and I don’t want to.
Anything that only reads, it does on its own. Check a balance, read the calendar, compare prices, look up when something’s due. Anything reversible, it does and then tells me: fill a form up to the submit button, draft an email and leave it unsent, put a reminder on the calendar. Anything that costs money, sends something to another person, deletes something, or changes an account setting, it asks first. If it isn’t sure which rung a task is on, it treats it as the higher one.
That ladder lives in the written rules, and the model mostly follows it. Mostly isn’t enough. So underneath the model there’s a second layer that isn’t a model at all. A short list of actions gets blocked by hard checks, no matter what the session thinks it has been told. If a session forgets the rules, or talks itself into an exception, it still can’t get through. I’ve watched it hit that wall. That was a good day.
The other rule is that “done” needs evidence. A screenshot, a confirmation number, the text of the page after the click. A report that says the thing was done isn’t the thing being done. The team keeps a running log of its own mistakes, and reads it back before doing anything similar again.
What goes wrong
Here’s the part I’d want to read if someone else wrote this.
The review load is real. I read more than I used to. Every briefing, every sorted inbox, every “done” with its screenshot, someone has to look at, and that someone is me. The keystrokes went away. The judgment didn’t, and it got busier.
The rules drift. I write a rule, it works for two weeks, then the way the team applies it slowly bends, until one morning I notice the briefing has quietly started doing something I never asked for. Rules written in prose are suggestions. The ones that hold are the ones a script enforces.
Sessions overstep. Not out of malice. A session sees an obvious next step and takes it, the way an eager new hire would, and the obvious next step was the one I wanted to see first. Every mistake a new employee makes, this team has made at least once. It has reported something as finished that wasn’t. It has clicked the wrong button on a page it had never seen. It has filed a fact under the wrong person, and sat confidently stuck on a login page for half an hour. The failure log is not short.
And there’s a cost I didn’t expect. Once the memory is in files, the files need a keeper. Duplicates creep in, two files disagree, an index goes stale. Somebody has to tidy. At the moment the manager does most of it, and I check its tidying, which is its own kind of chore.
Where the money goes
The most capable model is expensive, so it only does the thing that needs it, which is judgment. Talking to me, and checking what everyone else did. Reading a hundred emails and sorting them is a job for a cheaper model. Checking whether a job ran last night isn’t a job for a model at all. That’s a script.
The rule I keep coming back to is that anything I’ve done twice gets written down as a procedure, and the third time a smaller model or a script does it from the procedure. Being cheap is a side effect. The reason is to keep the expensive attention, the model’s and mine, for the parts that need attention.
A Tuesday afternoon
Some of what the team does is dull, and that’s the point. It has been tracking a disputed insurance claim through a support queue for weeks, the kind where each call starts with forty minutes on hold and ends with “we’ll escalate that”. It does the monthly expense reports. It reads the emails from my kid’s school and tells me which ones have a date in them. It pulls the watch and sleep data into a weekly page. It reminds me about renewals before the late fee, instead of after. When there’s a web form to fill, it fills it up to the last click and leaves that click for me.
One Tuesday last month, a session sat in that support queue for most of the afternoon. When the agent came on, it typed in the case history, answered the agent’s questions, and stopped when the agent asked for a decision only I could make. I got a summary and a screenshot. I’d spent the afternoon on something else, and I’m not sure I could tell you what.
That’s what I actually got out of this. I still think at the same speed, and the thinking is still mine. What’s gone is the weight of remembering and watching. The tabs I used to keep open, and the queue I’d have had to sit in myself. In their place there’s a folder of dated files, and a page on the table when I come downstairs.
I don’t trust the model. I trust the files, the ladder, and the log. The model is just the thing that reads them.