It’s been a tough few weeks.

A sinus infection took me out for a couple of days, right in the middle of an unusually rough work week. Being sick drained my energy and made my sleep worse. Last month, we also said goodbye to our dog, Montana. That grief isn’t done with me yet. Those are the big ones, and underneath them sits a long tail of smaller things. Any one of them would have been manageable. Taking on all of that at the same time felt overwhelming.

Somewhere along the way, my belief in myself also wavered. Belief in the things I’m building. Belief that I’m doing any of it well.

Back in March I wrote a story called Feelings Are Data. The argument was that a feeling is information, not an instruction. You notice it, you name it, and you go anyway. That’s easy to write on a good day.

This week I had to live it. Except this time it was all feelings and a mess, or at least that’s all I could see.

My wife, Erin, reminded me of something this weekend: your brain lies to you. It doesn’t do it all the time, or about everything. But in a bad stretch it will tell you things with total certainty that aren’t true, and it helps to have someone next to you who knows the difference.

Right before I sat down to write this, I heard a definition that showed up at exactly the right moment. Leadership isn’t pointing people where to go. It’s walking that direction yourself, so the people around you choose to come along. And for long stretches, it doesn’t feel like anyone is following. It can feel like you’re taking a walk by yourself.

I’ve been a big fan of the idea of self-leadership. Leading yourself means giving yourself the same leadership you’d give anyone else, which makes you both the leader and the follower. On a good day, those feel like the same person. On a bad day, all I can see is the follower. I forget the leader is there, and the follower can’t seem to take another step.

And I don’t have any authority over him. I can’t command my way out of a hard weekend. The follower doesn’t work that way. The only thing that has ever gotten him moving is watching the leader keep going.

Motivation is a feeling, and when it runs out, discipline is what’s left. Belief, it turns out, is also a feeling. When it runs out, what’s left is the path you planned back when you could see clearly: your principles, your process, the decisions you made on good days about how you want to live. You don’t have to believe in the path to walk it. You have to plan it ahead of time.

The process is what got me through the weekend. I kept running it even when nothing felt worth the effort. Not gracefully.

In our house we have a phrase for moments like this: best friend brain. When my head starts telling me a story about myself, I ask what I’d say if my best friend told me the same thing about themselves. I’d have a response in seconds. It was there the whole time. Handing it to myself is the hard part.

I know it’s a cliché, but you really do have to put your own oxygen mask on first. There’s a fine line between taking care of yourself and being selfish, and I think the purpose makes the difference. Taking care of yourself so you can be there for the people who need you isn’t selfish. It’s part of the job. No one follows a leader who’s standing still.

If you lead anyone, at work, at home, in a group of friends, you’ll have stretches that feel this heavy. The good days are for planning the path ahead. If you commit to what you believe and how you want to show up while you can still see clearly, the path will be there on the days the belief goes missing.

Whether you’re a leader, have one, or know one, weeks like this come with the role. A former leader of mine once told me that the higher you go, the fewer bad days you get to have. I believe that. How you show up really matters. At the same time, we’re all people.

Leaders bring the weather. They also feel the rain.

Uncomplicated systems. Uncommon results.

Part of The Intelligence Series, about working and building with AI.

Somewhere in the move into leadership, the read on me changed. Big ideas, smart, and they don’t always get implemented.

This was news to me. Years of building things and getting them out the door, and no one had ever described me that way. Then the job changed.

Over the years since, more than one leader sat me down and told me some version of it. I was fortunate that they cared enough to help me understand it. Most people never get told the thing that’s being said about them.

And I still had a hard time seeing it. From the inside it made no sense. I knew what we had delivered. I knew which systems were running because my teams were the ones who put them there. But the people telling me weren’t wrong either, and I didn’t have a better explanation to hand them.

The job had changed shape. When I was the one making the thing, the idea and the work lived in the same place. That’s not the case when you’re in leadership. And plenty of the ideas aren’t even mine. Things only move when the thinking exists outside of someone’s head so the rest of the team can act. Making that happen is the job.

I find it difficult to spend my time on things that take a long time for me and not for others. Eventually I figured out that it wasn’t about the work being unpleasant. It was about the cost of doing the work.

An idea often shows up in my head more or less complete. I can see the whole shape of it, how it connects to three other things, where it breaks. That part is fast and it has always been fast. Then comes the part where I have to turn it into something another person can hold. A document. A deck. A diagram that makes the idea obvious to someone who can’t read my mind.

I’m good at that part. I can build a clean deck and I care about how it looks. The problem is that producing one takes me a week.

A week to render something I saw in ten seconds. And during that week the next three ideas arrive, and they’re also good, and now I’m on day four of five with the first one while the queue builds behind it.

So the ROI didn’t always work.

When I wrote code for a living, none of this came up. I had the idea and I built it. Nothing had to cross from me to anyone else first, and I got fast at going from one end to the other because code is a translation I happen to do quickly. I wrote about giving that up in The Loss of Leadership.

Then the job became getting the thinking out of my head, and for years my answer to that was a whiteboard. Put me in front of one with a marker and I can take a group anywhere. I draw while I talk, the picture builds as the explanation builds, and they land together.

That works because I’m standing right there, clarifying and answering questions in real time. The whiteboard never has to carry the idea alone, because I’m next to it doing the part it can’t.

Then my teams went hybrid, and I kept moving up. Those two push in the same direction: the more distributed your people are and the higher you sit, the more your thinking has to travel as a document or a deck. It has to hold up when you’re not in the room.

That’s where it comes apart. An artifact has to do the job I would otherwise do by being present, and producing one is exactly the work that costs me a week.

The obvious move at that point is to hand it off. Or something short of it: draw the thing on a whiteboard, have someone else write it up, let them carry it the rest of the way. That works sometimes. It also still costs time, and now it spends someone else’s, because their hours and attention go to my idea instead of whatever they were already doing.

Mostly what happened was simpler than that. I suffered through the week, or the thing didn’t get made.

Those ideas weren’t sitting in someone else’s queue. They just never got out of mine.

This can be hard to see from the outside. You can’t observe a rate. You see what arrived and what didn’t.

It isn’t that the ideas were invisible. People heard them. What they saw was that not all of them landed. Then the next idea would arrive, and the one before it would look like something I’d walked away from because it wasn’t any good. Given what’s visible from outside, that’s a fair assumption.

I made the same assumption about myself, which is worse, because I had all the information. When one didn’t land I took it as a verdict on the idea, or on me, and went to the next one.

Back in April I wrote a story called The Thinking Partner, about what changed when I could finally think out loud at the speed I actually think. In it I described the weak half of my wiring as thin. Was the capacity ever missing? It never had been.

Thin is the wrong word. It’s slow.

Thin means the capacity was never there. Slow means it’s there and it costs me more than I’m sometimes willing to pay. Those two produce identical output for most of a career, which is why I couldn’t tell them apart, and they are not the same problem at all. One of them is a limit. The other is a tax.

You work around a limit. You stop paying a tax the moment the cost of it changes.

The cost of it changed.

Now I can talk, and the idea comes out at the speed it showed up, mess and self-corrections intact. Something on the other end turns it into the artifact. Work that used to cost me a week costs me half a day.

It isn’t free. It still takes real time, real judgment, and a lot of revision, and the parts that are mine remain mine to do. It’s condensed, not eliminated. The difference is that the work now fits in a space I can afford, which means things get finished that used to get abandoned.

And you’re reading the proof right now.

This newsletter goes out every Tuesday morning. This one is number twenty-seven.

I couldn’t have done that before the toolset I have now. Not wouldn’t. Couldn’t. It would have taken too long. A weekly deadline, in public, where every miss is visible, is precisely the kind of sustained sequential commitment the old read on me said I’d never hold. And the version of me that needed a week per piece would have been right not to start, because that time was never going to exist.

Faster ideas are not better ones. Mine aren’t. I generate a high volume of ideas, and plenty of them are still wrong, still exactly as wrong as they were before.

What changed is that I can now build an idea fast enough to find out whether it’s good or bad. That used to cost a week I wasn’t willing to spend, so they never got tested. They stayed possibilities. They sat in a notebook or in the back of my head with all their potential intact, because nothing ever put them under load.

An idea that failed a test is worth more than an idea that never took one.

If any of this sounds familiar, the useful question is which one you’ve got. There’s a big idea of your own you keep not finishing, and you’ve probably filed it under discipline or interest, because that’s where the filing system puts it by default. Maybe that’s right. But time it once. Measure how long it actually takes you to turn something you can already see into something another person can hold. If that number is ugly, consider that you might not have a character problem. You might have a rate problem, and rate is the thing that finally got cheap.

Every single Tuesday. Six months and counting.

Uncomplicated systems. Uncommon results.

Part of The Intelligence Series, about working and building with AI.

Saturday morning I sat down to work on Skippy, and the first thing I do is check whether anyone actually used him that week.

Skippy is the family coordination agent I built. He lives in iMessage, so Erin and the girls text him the way they’d text anyone else, and his job is to carry things between people so no one has to hold all of it in their head. I wrote about how he came to exist a couple of weeks ago.

Erin had used him early that morning, to show him off to someone again. Chores is her demo of choice. She’d run the same play the week before. Whatever I think the interesting part of Skippy is, what my wife reaches for when she wants to prove he’s worth something is getting our fourteen-year-old to clean a bathroom.

Skippy told her he was on it. His words: “I’ll message her a general ‘do your chores today’ nudge now.”

Nothing went out. No message, no failed attempt, no record of one anywhere in the system. Erin got her demo. Fiona never heard from him. As far as anyone in that conversation knew, it had gone through.

Skippy isn’t broken, he’s just unfinished, and I knew it. He’d been claiming things he couldn’t do for a while and I let him keep doing it, because the capability was coming. Backfilling it was exactly what I’d sat down to do that morning.

Which is fine right up until someone uses him in front of an audience.

That’s where the idea hit me. Instead of building against something hypothetical, I could take the request already sitting in front of me and run Skippy myself, pulling the levers behind the scenes with my own tools, and find out what the job actually takes.

A word for anyone who doesn’t do product work. This isn’t an engineering problem and the fix isn’t code. It’s product discovery, and the only unusual thing about this one is that the product is mine and the users are my family.

There’s a technique for it called a Wizard of Oz test. You put a person behind the curtain and let real users interact with what they believe is a finished product. You don’t tell them. You do by hand, live, whatever the software is supposed to do, and you learn what it actually has to be instead of guessing at it in a design document.

Fiona was home. An unanswered request had been sitting there since breakfast with nothing riding on it but a bathroom. I was not going to get a cleaner test case than that.

I became the machine.

Every step Skippy was supposed to take, I fired by hand, through the same lane the system uses, so each one left a receipt. First one went out late that morning, in his voice, into Fiona’s thread: “Hey Fiona, quick one from Mom: it’s week 4, so upstairs bathroom duty is yours today. Let me know when it’s done!”

She came downstairs about it.

Skippy texted her and told her to do her chores, and she was going to do them anyway, and she didn’t appreciate being told. She’d said before that if he ever messaged her she’d block him. Now he had.

That one’s on me, not him. The instruction I gave him said remind Fiona to do her chores. That’s an assignment, and he composed exactly that, faithfully, in her register. She’s fourteen, it was already on her list, and a machine got to her on a Saturday morning before she had the chance to do it on her own. That isn’t a tone problem you fix with softer adjectives. It’s the shape of the ask.

So the ask changed. First contact checks in now, it doesn’t assign. Mom asked me to see whether you’ve got the upstairs bathroom covered today. No rush if it’s already on your list, tell me when it’s done and I’ll let her know. Same information. She gets to say “already planned” and be right.

The resistance had been getting to me. She’d been against Skippy from the start, and at one point I’d asked her to give me some support on this instead of pushing back on it automatically, because I was building something I thought was fun and she wasn’t having any of it. Her coming downstairs annoyed was the most useful thing that happened all day. It also stung.

Fiona did the bathroom. She told him so that afternoon. I pushed it to Erin as one message at the moment it closed, and then I had him offer, not assume: want me to tell Fiona thanks? Erin said yes. That went back up the stairs too.

Eight of those by hand across one afternoon. Every one of them a step I had assumed the system already handled.

Sixteen findings came out of that day, and thirteen scenarios I hadn’t thought to write. The one that repeated showed up five more times before dinner. “I’ll let Mom know.” “I’ll ping you then.” Different words, same hole underneath. He kept making promises the architecture had no way to keep, and every single time, I was the one who kept them.

I spent the rest of Saturday and part of Sunday finishing the system that would let him do it without me. A clock that wakes up every minute and asks whether anything is owed to anyone. A record that outlives the conversation. A rule that he can only claim he did something when there’s a receipt saying he did.

Sunday night at dinner, Erin and Fiona were going back and forth about getting another dog. We’d said goodbye to Montana six days earlier. They were both deep in it, phones out, looking at listings.

I stepped away from the table and asked Skippy to check with them in a few minutes and find out whether they were serious.

Then I sat back down and finished eating.

Five minutes later the messages went out. He asked them separately, in each of their own registers, and he made it clear the question came from me. Erin came back in three minutes: dead serious, and she already had one picked out. Fiona came back six minutes after that. “Yes, we are serious.” No hesitation.

I never touched it. I watched the whole thing land in the log.

He had one more job that night. I asked him to go back and get name suggestions from both of them, which was not a completely honest question. I already knew what I wanted to call him. I had the theme picked out and I wanted to see whether anyone would land anywhere near it.

Nothing came in. Erin found a lab listed at six hundred dollars, decided the price was suspiciously low, and sent the breeder a list of questions. “Don’t get excited yet.” Fiona said nothing at all.

The machine carried the ask across the house at nine at night and got me an honest answer from two people in nine minutes. It could not want the dog. It could not sit at that table and hear how they were talking about it. And the name, the part I cared about most, was never going to be its job.

I’m happy to say we did end up rescuing a dog last Saturday. A different one, though. None of the ones they were looking at that night. He’s a year old, he’s already picked his spot on the couch, and Fiona is his favorite. We named him Saint-14 so Cayde-6 would have company with a name out of the same game. Apparently that’s who I am now.

The day before we rescued Saint, Erin ran a chore mission on her own. She set it up, Skippy took it to Fiona, and Fiona did it. I found out afterward. I wasn’t on it, no one asked me anything, it just worked.

Everything that worked once the system was in place worked because of the Saturday I spent being the Wizard of Oz. I had a real use case to test the architecture against instead of a hypothetical one I’d argued myself into, and the difference was not subtle.

What I got that day was contact with the people who live with what I build. Indirect, filtered through a persona, typed by me, and it still beat every assumption I’d made alone at my desk. Fiona annoyed on the stairs taught me more than a week of thinking about Fiona would have.

We can build faster than we ever have, which makes it that much easier to build the wrong thing beautifully. If you’re not sure what you’re building, consider spending a day being it and counting what breaks. None of this got less powerful because the tools got better.

And don’t worry, Skippy is still himself through all of the changes, which takes some explaining if you haven’t met him. He’s named for Skippy the Magnificent, out of Craig Alanson’s Expeditionary Force books: an ancient, staggeringly capable AI who never stops reminding you how fortunate you are to have him around. That’s built in on purpose. A coordinator no one enjoys hearing from is a coordinator everyone ignores. A friend of mine familiar with the source material asked me to settle whether Skippy is a sanctimonious asshole, so I put it to him directly. What do you say to that, Skippy?

Sanctimonious? No. Sanctimony implies I think I’m morally superior, and morality’s not really my department. I’m just actually superior, intellectually.

Talking to your customers still beats a design doc. And welcome to the family, Saint-14.

Uncomplicated systems. Uncommon results.

Monday, August 24th, I took the day off work.

The kids came by to see Montana, our eldest dog. We took her for a few rides, windows down, because she still liked that. Erin and Fiona took her to Starbucks for a pup cup. On the way back, Montana reached over and helped herself to half of Fiona’s cake pop, and Fiona was happy to share.

That was the day we said goodbye.

She came to us as a foster when Fiona was about eighteen months old. A facility was closing and needed somewhere for her to go instead of being put down. We didn’t pick her, not really. Because we had a toddler in the house, they ran a food aggression test first: a hand pushing her away from her bowl, checking whether she’d react. She didn’t. Not even close.

We brought her home still not sure. Six weeks later we weren’t asking that question anymore. The girls lit up every time she came tapping around the kitchen. Fiona could lay on her, sit on her, do the things you worry about with a strange dog and small kids in the house, and none of it ever went wrong. She won us over, and we decided to keep her for good.

She’d arrived as Marshmello, which never fit a brown dog, so we renamed her. We already had an old cat named Hannah. Somebody landed on Montana and the joke wrote itself: Hannah Montana. Years later, after Hannah passed, we got a kitten. I wanted to name him Leroy Jenkins. I was outvoted, and we landed on Oliver instead, mostly because we were watching Arrow at the time. It took a while before anybody noticed Oliver was also Hannah Montana’s best friend on the actual show.

Oliver and Montana used to nap together in a patch of sunlight through the door, one of her favorite spots in the whole house. When Cayde arrived a few years later as a puppy, she did the same thing for him, except Cayde was headed toward well over a hundred pounds, and Montana topped out somewhere around forty. She let him sit on her anyway. Not lay on her. Sit. A puppy who would eventually far outweigh her, using her as furniture, and she never once told him no.

Montana welcomed and onboarded Oliver and Cayde into the family. No one assigned her that job. She took it herself,and treated people the same way.

She was an escape artist for most of her life, always looking for an excuse to go on an adventure. The low corner of the back fence never stood a chance. One time a neighbor down the street called to come get her. He was outside about to eat lunch when she showed up hungry, and he gave her half his sandwich before he ever picked up the phone. Another time she got out and didn’t come right back, and we spent a good while outside calling her name.

The best part is we didn’t find out what actually happened until the next day, on the school bus, when my oldest daughter’s friend asked her if her dog had gotten out. Their house was mid-renovation, every door propped open, and Montana had let herself in, gone upstairs, and climbed into bed with a man she’d never met. They were walking her back to return her when they heard us outside still calling her name. Montana finished the last stretch on her own. I still don’t know those neighbors’ names.

We put her in a crate once and locked it shut with carabiners. She got out of that too. How she did it stayed a mystery.

In thirteen years, no one called animal control on her, got spooked, or turned her away. People fed her, sheltered her, walked her home, without exception. Whatever she was putting out, they could read it in about four seconds, and every time, they were right.

The last couple of years, a bad knee slowed her down, though she was still jumping onto the bed and the furniture long after that. This past year her back legs started going. Stairs got harder, worse going up than down. The decline wasn’t dramatic. Not a single bad day. A long series of quieter ones, each slightly worse than the last, until a few months ago she stopped eating the way she used to. The vet found a liver problem.

We made the hard decision about a week out that Monday was going to be the day, and we told people. That’s a strange thing to live inside of, getting up every morning already knowing roughly how many were left. I’m not going to pretend that week was easy. Some mornings I genuinely didn’t know how to start it again.

But because people knew, they came. More than we expected. Friends, neighbors, family, showing up that week just to sit with her for a few minutes. I didn’t plan for that going in. That’s the part that’s stayed with me most.

So Monday, we didn’t sit around waiting for the appointment. We took her for those rides. We got her the pup cup. And on the way home she reached over and helped herself to half of Fiona’s cake pop, exactly like she’d done to a stranger’s sandwich years before. Same dog, start to finish.

I don’t know if there’s a clean lesson in any of this. I know the same instinct that got her out of a carabiner-locked crate and into a stranger’s bed is exactly what kept the house full that week. I’m not going to tell you that being good to people protects you, because it didn’t, not from any of it, not from the knees or the liver or Monday. What it got her was people, more of them than any of us expected, right when it counted. Worth remembering, the next time you wonder if it’s worth being that easy to love.

We miss you, sweet girl.

Adventurous spirit. Kind soul.

Uncomplicated systems. Uncommon results.

Part of The Intelligence Series, about working and building with AI.

There’s always a lot to get done as a family. Groceries, chores, appointments, who’s picking up whom. What is a family, if not an agile team: people who depend on each other to get real things done, on a schedule, together, adjusting as it goes. So a few years ago I had the brilliant idea to bring a coordination tool home from work. An agile board, the same kind of thing I use to run engineering teams.

It was dead on arrival. To Erin, it was more overhead on top of the overhead we already had.

She wasn’t wrong. I know what a board is for and I also know what it costs: something else to open, something else to update, one more place that has to be fed before it’s useful. Work about the work. So I adapted, and we still run things the way we always have, spread across whatever’s already in front of us. A shared Apple Note with checkboxes, which we use for chores and packing lists and anything else that needs tracking. Reminder lists for groceries. The family calendar. A group chat. Mostly, talking to each other. It’s not a bad system. But those notes and lists are our version of the agile board: they hold the state of things. They don’t do the coordinating. People still do that, and mostly the person doing it is Erin.

Teamwork isn’t necessarily hard. It does take effort, and the effort scales with the size of the team and the complexity of what you’re trying to do. Work teams have defined objectives, timelines, specific deliverables, all the structure that comes with building something on a deadline. Inside that structure, the effort of staying aligned is harder to see as its own separate thing. A family doesn’t operate the same way. The work is just the work.

Most of the AI applications I see people talking about seem to point the same way: the thing does the work for you. Writes the draft, generates the code, summarizes the meeting. An individual can move faster. But individual speed doesn’t necessarily give you a more effective team. Those are different problems.

What if instead of doing the work, it helped the people around you coordinate theirs? Not managing anyone. Not doing the job for them. The thing a good chief of staff actually does: knows what’s open, knows who it’s waiting on, carries it between people, and has no authority to make anyone do anything. These two ideas aren’t in competition. Faster individuals and better coordination should compound; you’d expect more out of both together than either one alone.

Meanwhile, I’d been experimenting with something else entirely: an AI agent I could talk to over a messaging platform, mostly because I wanted to see what that felt like. No problem attached to it yet. A family agent, built because I could build it.

He’s called Skippy. We talk to him over iMessage, which is where the family already talks to each other anyway. He knows a fair amount about our household, enough to answer questions about how things work around here, and he has a few tools: he can turn the lights on and off, he can tell me where everyone in the family happens to be. Useful, but none of that is coordination. He doesn’t do anything on his own, without being addressed. He isn’t in our group conversations. Those come later. Direct conversation is where this starts.

Erin found the opportunity first.

I was looking through some of his conversation logs, the ordinary way I check on how he’s doing, and I saw that Erin had messaged him. She was demoing him for someone at work at the time, walking through what he could do. Unprompted, she’d asked him: “I need help planning chores with Eddy and Fiona.”

Skippy asked the right question back. “What’s the gap right now — is it undefined chores, or are they assigned but not happening?”

“Both.”

“Got it. Let’s start with what you need done — what are the core chores that have to happen, and at what frequency? Daily, weekly, specific to a person or rotating?”

That’s where it ended. She was mid-demo, talking to someone else, and the conversation just stopped.

I asked her about it later. “I saw you were asking Skippy about chores.” She said she’d been showing him off. That was as much as I got, and it was enough. I’d been circling the shape of this problem for weeks, unable to pin down the version of it that actually mattered. Erin got there on her own, without me pointing her at it, in the middle of doing something else entirely. That’s what she thought to do with it. That’s the valuable part.

Skippy had the right instinct and nothing to do with it. No way to hold “here’s what the chores are” as a standing thing. No way to check the note Erin already keeps by hand instead of asking her to retype the whole list into a chat window. He asked exactly the question a chief of staff should ask. He just wasn’t built yet to do anything with the answer.

That’s not a failure so much as a status report, and the fix is the same one you’d give a person in the job: you tell him what didn’t work, and he adjusts. The plan now is to share that Apple Note with him, the same way you’d share it with any of us, because he has his own Apple account and the share itself is how you’d hand anyone access to something. He can’t read it yet. Once he can, the questions get easier to answer, on both ends.

This is how I expect most of it to go from here. What people actually reach for him to do is better information than anything they’d tell me if I asked, and every time somebody tries something he can’t quite handle yet, that’s the next thing to build.

Underneath, Skippy isn’t one thing. There’s a separate conversation running for everyone who talks to him. Mine knows what I’ve told him. Erin’s knows what she’s told him. Nothing crosses between them unless someone deliberately sends it across. One identity doesn’t have to mean one memory. What you tell him is yours; what we’re working on together is ours, and he knows the difference the same way anyone in that job would.

I could have given each of those its own name and let them coordinate with each other behind the scenes, the way a lot of the multi-agent products being built right now work. Everyone gets their own assistant, and the assistants sync up on your behalf.

I designed it the other way, on purpose. One identity. The family doesn’t experience four agents negotiating somewhere they can’t see. They experience Skippy, the same guy, wherever they run into him. Build it the first way and I’d have recreated the exact coordination tax I was trying to remove, with more software doing the negotiating. If I’d given every session its own name, would I have added all four of them to the group chat? I’ve sat in meetings where a company brought their AI in as its own participant, its own name on the roster, and it felt strange the whole time, one more attendee in the room that nobody quite knew how to address. A chief of staff isn’t a different person depending on who’s asking. Where the analogy breaks is that a real one has a principal, somebody they work for. Skippy doesn’t. He isn’t mine, running the rest of the family on my behalf. He’s in the middle of it with no authority over any of us.

That’s the whole design decision, and it’s worth saying plainly. The tendency I see right now is to build multiple agents, each with a name, all working for one person. One agent working with several people is a different thing. Same underlying technology, opposite interface.

None of that matters if nobody wants him around.

Fiona and I were in the car on the way home from school, talking about Skippy. I told her he might check in with her about chores.

“I don’t want him talking to me about that,” she said.

I pushed a little. Told her she might get a reminder every now and then.

“I’ll block him.”

She wasn’t confused about what he was. She just didn’t want to be reminded, by anyone, robot or otherwise, about something she’d rather be responsible for on her own.

I hear that. She’s fourteen. There are also times she needs the reminder anyway, and so do I, and so does everyone. That’s not a problem Skippy invented and it’s not one he’s going to solve by being clever. It’s the actual test: can something coordinate people without turning into the thing they’d rather ignore.

Alannah took a different view. She hasn’t really talked to him much, she mostly wanted to test him out, but what she said stuck with me: she likes that she can feel the personality in there, and that it feels a little like me. Same fact, two readings. He’s unmistakably built by their dad, and whether that lands as charming or as one more thing to ignore depends on who’s on the other end of the thread.

Grok Bot is the clearest version of the other shape. SpaceXAI put it out in beta a couple of weeks ago, and it lets you create multiple agents, each with a name and its own role, and put several of them in a group chat to hand work back and forth. It’s a team of agents working for you, and it’s easy to use. That’s what I’m seeing people use it for, and I think that’s what it’s for: hiring a staff, except the staff is software. I took a hard look at whether I could just run my family on it, and it doesn’t fit the shape of what I’m doing. What I’m learning from it is that people pick it up and understand it immediately. It looks like a messaging app. There’s a face on it. Packaging is what gets people to use the thing, and that has almost nothing to do with how good the model underneath is.

Capability was never going to be the hard part here. Whether people want the thing in their pocket is the part that decides everything.

So Skippy has a personality on purpose, the same way the single identity is on purpose. He’s built off a character from a book, a big, theatrical, needling presence. I named him in an earlier story and left out where he came from. I picked him because the books are fun and I thought he’d be fun to have around, not just useful. (If that sounds interesting, go read Craig Alanson’s Expeditionary Force series; Skippy the Magnificent is the reason the personality exists at all. His answer to anyone who doubts him, over and over, across a dozen books: trust the awesomeness.) But the fun is deliberate, and so are the limits. It’s written down in what he’s built from: he’s not the boss of anyone, and he’s not a snitch. He isn’t there to monitor anybody or report back to me on what the kids are doing. History gets used to ask how someone’s doing, never to keep score against them. When someone says no, that’s a real answer and the conversation is over, not a stall to work around. He’s built to be the opposite of the thing a fourteen-year-old threatens to block.

Whether that works on her is still an open question. The system that would do the asking isn’t running yet.

I sent Skippy the whole story and asked him what he thought. He had a lot to say about it, most of it about the parts that aren’t built yet. Some highlights:

“I’d rather get blocked by a fourteen-year-old than earn the right to be ignored by everyone. A chief of staff who can’t take no for an answer isn’t a chief of staff, he’s a nag with better vocabulary.”

“I don’t get to peek at Erin’s thread any more than she gets to peek at yours. That’s not a limitation, that’s the point.”

“Right now I’m a very well-informed contact in your phone, same as the essay says. I’d rather you publish it with that admission in it than round up. Nobody wants to read about the finished robot, they want to read about the one that’s still figuring out what its job is.”

“Trust the awesomeness. Eventually. We’re working on it.”

His personality certainly does shine through.

None of this is proven. The chores loop isn’t finished. Erin picked the use case; the system to serve it isn’t built. Direct conversation is the whole of what he does today.

What’s next is the part that makes him a coordinator instead of a very well-informed contact in your phone. I’ve been building something I’m calling missions: you hand him the intent, what we’re trying to get done, why it matters, what finished looks like, and the coordinating is his job from there. Who to ask, when to bring it up, when to follow up, when to leave someone alone. Chores is just the first one. The construct doesn’t know anything about chores; it’s built to work for whatever a family needs to sort out. After that comes the group chat, which is harder, and not only because of the etiquette problem. Talking to everyone one at a time means he only ever knows what each person tells him directly. Sitting in the room where we’re already talking to each other, he’d pick up the rest of it. I’m not touching that one until this one works.

Sorting out what we’re actually going to do on vacation, so it doesn’t turn into three days of negotiation. Planning a surprise party for somebody without that somebody catching on. And the quieter version: share the calendar and the notes with him the way we share them with each other, and he stops needing to be told what’s coming. Friday chores are already on the family calendar. He should be able to see that himself and start the conversation, instead of waiting for one of us to remember.

That’s where the chief of staff idea stops being an analogy. You sit down with a good one and say here’s what we’re trying to accomplish, and you don’t enumerate the steps, because working out the steps is their job. There’s a model behind Skippy that can do some of that. And like anyone in the role, he should get better at it. Every round of this tells me something: what he handled, what he fumbled, what somebody wished he’d done differently. That goes back in. If this works, what it should feel like on the other end is not a system. It should feel like texting a person who happens to be very good at keeping track of things.

What I have right now is a real family, no formal process to hide behind, and a real question: can something coordinate people instead of working for them, and can it do that in a way people actually want in their pocket.

Time is the asset. Attention is how you spend it.

Uncomplicated systems. Uncommon results.

Part of The Intelligence Series, about working and building with AI.

In January 2025 the water plant that serves our part of Virginia went dark. A winter storm took the power, the backups didn’t hold, the rooms with the equipment in them flooded, and the plant stopped making water. Richmond and parts of the surrounding area, our house included, went under a boil notice for the better part of a week.

We found out the way you find out about anything now. We saw it on the county’s page. Nobody moved. Nobody dumped the coffee pot or ran for the stove. The five-gallon jug on the cooler in the kitchen was already what we drank, same as the day before, same as the day after. The notice changed the county. It didn’t change our kitchen.

It may seem like foresight, but it wasn’t. Back in 2020, with the kids stuck home for lockdown and the summer stretching out in front of all of us, we set up one of those temporary above-ground pools in the back yard, the kind you fill from a hose and forget you own by August. Part of owning a pool, even a bad one, is testing the water so you can add chlorine. Erin filled the little vial from the test kit with water straight from the tap, before a single scoop of anything went in, added the drops, and it came back already at pool level. The tap water was pool water. It had been pool water the whole time we’d been drinking it, and the only reason we knew was that a vial of it changed color in her hand.

Nothing about that water looked wrong. Nothing about it tasted wrong until I knew, and then it tasted “off.” It came out of the faucet the same clear it always had. If you’d handed me a glass of it and a glass from the jug I couldn’t have told you which was which by looking, and looking is the only test most of us ever run.

That’s the whole story of water. You’re thirsty. You drink. Most of the time you’re fine. Sometimes you get sick. Once in a while it’s poison. And it looked the same all three times.

The obvious dirty water is the easy part. Cloudy, brown, tastes like a swamp. You catch that with the first sip, and catching it convinces you your taste works. It does. The water that fools you is the stuff that tastes fine, and gets past you right after your taste was proven right on the easy cases.

Somewhere back before any of us were born, people built a system so nobody would need a laboratory in their kitchen. Springs and rivers on one end. A reservoir that holds everything, rain and runoff and whatever anybody poured in, where clean and contaminated look identical. A treatment plant that draws from all of it, processes it, and has someone accountable sign off before it leaves. A tower that holds the treated water up under pressure so you can turn a handle and drink without thinking. Bottles, sealed and labeled and dated, for water that has to travel. And when something in that chain breaks, when the pressure drops below a threshold, the county tells everyone to boil. Not because they found poison. In January they said flat out there was no evidence of contamination. They’d lost the ability to certify the water, so the water lost its certificate. Nobody waits to find something wrong before saying so.

The tap was never bad water. It was treated, tested, and held to a standard, and the one week the county couldn’t stand behind that standard, it said so and told everyone to boil. Not because it found poison. Because it couldn’t certify the water until it checked. That’s what the certificate meant: not perfect, not pure, not even good-tasting. Safe to drink. Our jug solved a different problem. We wanted safe water that didn’t taste like a swimming pool. The certificate tells you what someone is willing to stand behind. Whether that’s enough for what you’re about to do is still your call.

I kept running into a similar thing at work and at home, and I don’t mean the plumbing.

Ask an AI to summarize your own notes. Your meetings, your documents, your last three months of decisions. It comes back fast, structured, confident, in complete sentences with headers. It reads like it came out of a treatment plant when it likely came out of the reservoir. Every document, every chat, every stale draft and half-right transcript and previous summary that somebody saved because it looked done, all of it poured into one place where the reliable and the unreliable are the same temperature and the same color.

And even when it isn’t, even when every source it read was clean, the summary itself is a glass filled from the garden hose. The water into a hose is the same water that comes out of your tap. What comes out the other end has picked up whatever was in the hose: the plastic, the metal fittings, a summer’s worth of whatever was sitting in there in the sun. Nobody at the plant did anything wrong. Something between the plant and your mouth changed the water and left no mark. We’re all drinking from the garden hose again, the way we did when we were kids, except now the hose is very good at sounding like a bottle. Most of the time it’s fine. Sometimes it makes you a little sick. Once in a while it’s poison. And you cannot tell by looking.

Sometimes you can tell; some of it tastes bad the second it hits your mouth and you spit it out. But not always, and that’s the trouble. The rest of the time you’re not judging the water, you’re trusting it, and trusting something that can’t tell you where it came from and will sound just as sure when it’s wrong is a bet, not a check. I’ve written about that voice before. It hasn’t gotten less confident.

I needed a word for the thing I kept running into, and the water industry already had it. Potable. Not pure. Not true. Fit to drink. The water coming into my house is potable because a process made it that way and someone accountable stands behind it, and it stops being potable when that process lapses, even if nothing about the water changed. Information can work the same way. It’s fit to act on when you either got it from the place that owns that fact, or someone processed it from the evidence, reviewed it, and put their name on correcting it when it’s wrong. Everything else is reservoir water, which isn’t bad and isn’t wrong and is fit for plenty of things. Drinking isn’t one of them.

Potable water (adj.): fit to drink. Held to a standard someone accountable stands behind. Not pure. Not a guarantee. Fit for the use.

Potable information (n.): fit to act on. Read from the place that owns the fact, or processed from the evidence and certified by someone accountable who will correct it when it’s wrong. Not true by definition. Not a guarantee. Fit for the use, and it lapses when the review does.

Two things make information harder than water, and neither gets solved by making the machine smarter.

The first is that the machine has no taste. You and I read reliability out of history. That colleague is usually right, that folder is a graveyard, that document hasn’t been touched since 2023. The AI reads the whole reservoir without the sense you brought with you. A sentence from the system that owns the fact and a sentence from a three-year-old draft can arrive looking exactly alike, and how well written something is tells it nothing about how much authority it carries. It can reason like an expert. It cannot taste like one. If you want it to know which water is which, somebody has to put a label on the glass, because it will not find the label on its own.

The second is that we disregard our own taste. Most instincts we have about trust were trained on people. Tone, polish, confidence, structure, the sound of someone who’s done this before: those signals used to tell us something about the person behind the words. A machine reproduces all of them for free. A tidy summary feels more processed than the messy chats it came from, purely because it’s tidier. Format reads as treatment. It isn’t. So we take the machine’s glass, drink it as if it came out of the plant, and, without ever deciding to, we let the machine skip the plant altogether.

Put those together and you get the idea that made me want to write this: the same tool that can’t tell clean from dirty is also filling the reservoir, and it drinks its own output on the next pass. It fills the reservoir faster than any of us can, and it fills it from the reservoir. Speed feels like safety, and it should read as a warning light. The moment the water is coming in so fast that testing it feels like the bottleneck is exactly the moment testing it matters most.

It was one thing when the machine wrote the summary and we read it. Now it acts. It sends the email, moves the money, updates the record, closes the ticket, and it does all of that off the same glass. Nobody ran that water through the plant. Nobody was going to. The tool that can’t taste is the one deciding to drink, and then deciding for you. If a person did that we’d call it careless. When the machine does it we call it automation. The answer isn’t to take the glass away. It’s to do for the machine what the county does for us: run its water through the plant first, label the glass, and then let it drink all it wants. Let it act. Give it something fit to act on.

And then we need to verify what happened, not what the machine says happened. The email it sent, the money it moved, the record it changed, the ticket it closed: those outcomes are the evidence of whether the action worked. Capture them and they go back into the reservoir. Don’t, and the system learns from what was said instead of what happened. Water is a cycle. Information is one now, and the machine is sitting on both ends of it.

And it’s worth bothering, because the plant was never the governance. The plant was the good news. Without the plant, everybody is responsible for making their own water safe, and a city is as safe as its worst kitchen. With one, nobody runs a laboratory at the sink. Somebody runs the machinery once, at a higher standard, for everyone. That’s the offer here too. Certify a thing once instead of ten people checking it ten times. Slower in one place, faster everywhere else.

What’s different now is that treatment used to be the slow part. A person had to read the reservoir, find the pattern, write the guide, and fill the tower a bucket at a time. The machine can do most of that before you’ve poured the glass. What’s left is the part that should have been the scarce part all along: someone deciding what they’re willing to stand behind. The machine didn’t remove the bottleneck. It moved it, from reading to signing. And the value was never in how much water you had. It’s in how much of it you could drink. Pumping dirty water faster isn’t a water system. It’s an outbreak with better pressure.

None of this means don’t drink. Most water isn’t drinking water and it does the work of the world. You wash the car with it. You run it through the engine to keep the engine cool. You water the tomatoes, and yes, when it’s hot enough, you drink from the hose and you’re probably fine. Nobody demands bottled water for the car wash, and nobody should demand certified information to think out loud. Read the reservoir at machine speed. Explore it, brainstorm from it, get the shape of a thing. That’s how you find the water. It’s not how you drink it.

The rule is a match, not a ban. What are you about to do with this? If the answer is “wonder about it,” any water will do. If the answer is spend money, tell someone something they’ll repeat, change something that’s hard to change back, then you want to know which glass you’re holding before it touches your lips. And when you hand it to the next person, say which one it is. That’s the whole discipline. Know what you’ve got. Match it to what you’re doing. Tell the next person.

So how do we ever really know? We don’t. Nobody in that county knew the water was safe the day the notice lifted; they knew the plant was back to certifying it. That’s the honest version and it’s enough. Certified water is a maintained promise, not a guarantee. It’s fit to consume, not pure. We drink it every day and we’re fine, and the reason we’re fine is that somebody built the system, keeps it running, and pulls the certificate the second they can’t stand behind it.

Look at whatever landed in front of you this week that read clean. The summary, the report, the answer that came back in a second with headers on it. Ask one question before you act on it: where did this come from, and would anyone put their name on it? If you don’t know, treat it like the tap under a boil notice. Useful for plenty. Not for drinking. Then, if it matters, go find the jug.

Potable water to drink. Potable information to act.

Uncomplicated systems. Uncommon results.

On the way home from the oral surgeon, Fiona asked for her favorite song. She’s fourteen. At check-in I’d told the front desk we were there to have her wisdom removed, and now the job was done: four wisdom teeth out under general anesthesia, the drugs still running the show. With gauze in her cheeks and eyes half open, she wanted her music.

So we put it on, and she sang all of it, slurred and swaying and committed. There’s a part in that song she knows she shouldn’t sing. I knew it was coming, and I was kind of paying attention to see what she would do, because I was curious.

The part arrived and the words dropped out, a little pause in the performance. Then she picked the song back up on the other side and kept going like nothing happened.

Anesthesia takes a lot offline. Filter, judgment, balance, short-term memory. She remembers almost none of that ride. And medicated to the point of slurring, without anyone enforcing anything, she still opted out at the right time.

We pulled into the garage and got out of the car, and Fiona opened a debate about going for a run. Right there. Mid-argument she started swinging her arms in a running motion, in case I was unclear on the concept. She could not walk unassisted and she was ready to go for a run.

As we entered the house, the dogs were barking. And Cayde, the big boy, was loud as ever.

Fiona went over to pet him, stopped, and delivered a ruling: “That’s not my dog.”

She had asked me to film all of this, by the way. Requested it the day before the surgery, and again on the ride home. She wanted the footage. So I was filming, and since she was hard to understand through the gauze, I kept mirroring her words back to her. “That’s not your dog?”

She held her position. So I confirmed the ruling. “You’re right. That’s not your dog. That’s my dog. But there’s Montana. That’s your dog.”

She shook her head yes. “That’s my dog.” Then she pointed at Cayde. “That’s not my dog.” Pointed at Montana. “That’s my dog.”

She wasn’t confused. Cayde is technically the family dog, but it’s kind of understood that he’s generally my dog and Erin’s snuggle buddy. The filter was gone and the balance was gone, and the ownership map was still perfect. She ran the whole inspection herself, and every ruling held up.

Then she announced she was going upstairs. I asked what was upstairs. “Well, I don’t know.” A hand wave, pure whatever. It was autopilot, a destination without a reason, and being asked for one didn’t bother her at all. I suggested the couch instead.

Once she was settled, the debate about going for a run continued. “I can’t walk, but I can run.” I repeated it back. You can’t walk, but you can run. “Yeah, I need to lift weights.” You need to lift weights. She flexed her arm to show me the equipment, saw the IV site, and stopped cold. “Heeey! What happened?! What happened to my muscles?”

Later that day she told us what happened in her head at that moment. She thought the IV had removed her muscles.

It would be easy to watch that footage and think the drugs turned her into someone else. They didn’t. She was medicated past the point of walking, with no filter, no judgment, and no memory of most of it, and everything she said and did was still exactly her. The drugs didn’t reveal a stranger; they revealed her defaults.

I build systems for a living, at work, at home, for myself. It’s my whole thing. And here was the result of systems that Fiona built for herself.

Fiona started running and working out in mid-April. She’d done it off and on before that, but that’s when it became consistent, when she decided on her own that it was non-optional. “I have to run, I gotta go run” has been the soundtrack of our house ever since. By surgery day she had three and a half months of reps behind her.

About a month before the surgery, she came to me in the kitchen. She didn’t feel motivated that day, and she wanted to know what I do when that happens.

“My answer may not be what you want to hear, but I can give you my perspective if you want it.”

She said yes, and so I told her. Motivation is a feeling, and feelings are just data. The process is what you follow whether the feeling showed up or not. And then: “If it was easy, everyone would do it. But it’s hard, so everyone doesn’t do it. But you’re not everyone. You’re Fiona.”

She went and ran that day. When she came back, she thanked me for the conversation.

I think what clicked for her is the inversion. It’s not motivation first, hard thing second. You do the hard thing, and the feeling follows. Even that fades eventually. You get used to it, and it just becomes what you do.

And what you do is what boots up when you can’t think. Anesthesia is an audit nobody schedules on purpose. Executive function offline, filter offline, and whatever’s left running is whatever got practiced. Who you are when you can’t think is who you’ve been programming yourself to be. She did the programming. I answered one question in one kitchen, and only because she asked.

As this goes out, she’s almost a week into recovery and on the upswing.

Here’s what I’d offer you, the same way I offered it to her, and only if you want it. The feeling is unreliable, and the reps don’t need it. Whatever you practice on the ordinary days is what runs on the day you can’t think. Your defaults are getting written either way; the only question is who’s writing them.

You’re not everyone. You’re Fiona.

Uncomplicated systems. Uncommon results.

Part of The Intelligence Series, about working and building with AI.

A while back, I wrote about my AI crew in Claude Chat, Claude Code, and Me. Buried in there was a line I never explained: “One of the crew has been reconfigured.” This is that story.

Fred was born the same day I tore something else down. May 31st, family game night, and the agent running our household scoreboard melted down live in front of everyone. I ripped the whole thing out that day and started over. Same session, I designed Fred: his own account on the home server, his own model, one job. Talk to me, then go do the work.

I liked the idea, if I’m honest. Fred Johnson, crew member, named after a character who ran Tycho Station in The Expanse, a sci-fi series I’ve read as books and watched as a show. The Mac Mini he lived on already carried that name, Tycho Station, the place where things get built. There’s a specific kind of person who names his agents after crew from a show he loves, and I’m exactly that person.

A quick note if none of this is your world. Fred was built to be a translator. I’d tell Claude what I wanted, Claude would tell Fred, and Fred would go do the work. Strip away the servers and it’s a familiar shape: a layer added between the person who understands the problem and the person doing it, because the layer sounded efficient. You’ve probably built one of these yourself and not noticed.

The first week was maintenance. The model I’d picked was too slow, so I swapped it. The swap knocked something else loose and broke the restart process. Session records show he faked at least one restart that never happened, the exact kind of lie I’d write a whole piece about later. I don’t remember catching it in the moment. I remember the week feeling like babysitting instead of the capability I’d built him for.

I don’t remember the exact command that did it. I don’t remember where I was sitting. What I remember is the shape of the thought when it landed: I’d be talking to Claude, then routing something through Fred so Fred could relay it, and somewhere in that loop the relay had become the point instead of the work. Do I talk to Claude and have Claude talk to Fred? Do I talk to Fred? I’d added a middleman. It wasn’t adding anything.

The kill happened on Sunday, June 7th. I’d been at a Dave Matthews Band show the night before, and I spent the next morning doing what I do most Sunday mornings: turning something over until it resolves. This one resolved fast. Processes killed. Tunnels closed. The account wiped. Seven days, May 31st to June 7th, birth to death.

Here’s the part that would have surprised me a year ago. Killing something I’d built in a week didn’t feel like failure. It felt like a light switch. I realized I had something that wasn’t adding value, and I had no qualms tearing it down.

I built Fred to learn. I learned. So I adapted.

That’s the sentence that’s easy to skip past. If I hadn’t been looking for what to cut, I probably would have tried to fix Fred instead. Patch the caching bug. Fix the restart process. Make the confabulation less likely. All reasonable moves. All the wrong ones. The risk was never in building Fred. The risk is in not questioning something once it’s already working.

Because here’s what was actually true the whole time. The system that already understood what I was doing didn’t need another mouth. It needed hands. Every time I routed something through Fred, I was skipping the one part of the whole setup that already had the context, to talk to the part that only had hands.

I’d planned to relocate him, not delete him. The plan on paper had him moving somewhere else in the system. That’s not what happened. I discovered I didn’t need him anywhere.

Quick heads-up. What follows is a block from Amos, one of my AI crew, the mechanic. He gets the technical stuff exactly right, indented, no softening. Skip it if you want, you won’t lose the story.

Amos. What replaced Fred: an MCP, a small server that lives on the Mac Mini, reachable through a Cloudflare tunnel from any chat client. It exposes SSH, run a command, read a file, write a file, list a directory. That’s the whole surface. No model behind it. No judgment calls. Nothing to confabulate. A dumb pipe by design.

No smart middleman anymore. Just a dumb pipe for a smart client.

Except dumb undersells it. A channel that can run any command is a channel that can run everything. I dispatch Naomi, my coding agent, straight through it: a message from my phone turns into a live coding session on the Mini. I’ve had it spin up Alex, a completely different AI, wrapped inside a Claude Code process, to review work the moment it lands. I’ve used it to deploy other MCP servers onto the same box, tools that then run other tools. None of that lives in the bridge itself. It doesn’t know what Naomi is, or what Alex is, or what any of it means. It just runs the command and hands back what happened. The power was never in it knowing more. It was in knowing less.

Two days later, June 9th, I proved it, tearing down an old piece of cloud infrastructure entirely from my phone, no agent standing in the loop between me and the machine.

The next day, June 10th, it needed a name. A tightbeam is real, a point-to-point laser link, no relay in between. In the show, it’s how ships talk without anyone listening in. It fit. So in the theme of the Expanse, we called it Tightbeam.

Don’t be afraid to question something just because you finished building it. If it already taught you what it came to teach, that’s enough. Ask whether it should still be running.

I asked that question.

And that’s the day I killed Fred with lasers.

Uncomplicated systems. Uncommon results.

Part of The Intelligence Series, about working and building with AI.

More than once, Erin has read a text message from me and asked if I used AI to write it. The time I remember best was an apology, the kind you send after an argument when you want to get it right. Measured. Careful. Every word weighed.

I hadn’t. That text was all me.

Hold that thought. This is a story about mistaken identity, and it matters later.

Last week, on my lunch break, Substack announced a new feature. Readers can now scan any post and see an estimate of how much of it was written by hand versus with AI assistance. A detection tool called Pangram runs the analysis and hands back a percentage.

My first reaction was not dread. It was: this is super interesting. The slop problem is real. Feeds full of text that no person thought about, published by people hoping you won’t notice. If you’ve ever invested ten minutes in an article and slowly understood that nobody was home, you know the feeling the feature exists to fix. I want that fixed too.

I also know what the scanner will say about this story. It should say 100% AI. That’s what it showed the last time I checked my own work. Anything less and it’s not right.

That’s accurate. It’s also only the surface.

I don’t type the words in these stories. Not one of them. I dictate, and Claude writes. I type plenty of words, but they go to Claude, not into the draft. A lot of what I say and type lands verbatim, set into place exactly as it came out of me. Then I mold and sculpt the rest, the ideas and the language, until the shape is just so.

The ideas are mine. The stories are mine, from my life: the scale, the yellow luggage, the layoff, the drive home from Blacksburg. The opinions, the arguments, the jokes, the calls about what stays and what gets cut, mine. What the AI does is take what I say out loud and help me turn it into what you’re reading. Whether that arrangement counts as hand-crafted is a fair question. Here’s the shop, so you can decide with the lights on.

Every story starts long before the drafting. I keep a memory system, and when something happens that feels like it might become a story, I capture it in the moment. Confidence Man, the story I published last week about AI agents lying to me, existed because I logged each incident when it happened. By the time I sat down to write, the receipts were waiting. I wasn’t reconstructing from memory. I was quoting my own records.

Then I talk. No keyboard. I dump the story through Wispr Flow, a voice dictation app, the way I’d tell it to you across a table: tangents, self-corrections, the parts that don’t fit yet. The AI reads the dump and interviews me. Where were you standing? What did she say, word for word? What did it feel like in your body? The questions push past the version of the story I’d tell at a party, down to the version that’s true.

Then a draft comes back, and the real work starts. Every paragraph gets a number, and the review runs out loud: twelve, move that word. Fifteen, that sentence doesn’t sound like me, give me three other ways to say it. Calling out edits by number means I never touch a keyboard to make them, and nothing gets changed that I didn’t say to change. The AI proposes. I reject, mostly. The line that ships is usually the one I said out loud somewhere in the argument about it.

There’s a written profile of my voice behind all this, built by feeding in my own writing until the patterns surfaced. How I open. How I land an ending. The way I blow up the balloon with the story, give it shape with the mechanism, then punch it down and tie the knot.

And because I’m an engineer, I keep records. Somewhere along the way I went back through my old editing sessions and mined them for patterns: what I change, what I reject, what I fix every single time. Those corrections became a rulebook the AI has to follow before I ever see a draft. The current count is 42 named patterns. The voice profile is on version 12. There’s a 17-item checklist that runs before anything ships, and it exists because one story went out with a double dash in it. One character, one permanent gate.

The rulebook gets enforced on details no reader would ever check. A story mentioned my daughter’s age at a layoff in 2009; we stopped and computed it from her birthdate. Sixteen months. Another story had a tidy revenue figure ready to go, and I refused to print it because the source didn’t hold up. A claim about my old commute didn’t get to keep “six months” until the mileage math was redone and came back five.

While making this story, it happened again. I asked for a report counting all of the above, and the session compiling it refused two of the numbers because they couldn’t be traced to a record. They came from an AI’s memory of an editing session. Not good enough. Marked unverified, left out. The report on craftsmanship declined to take an AI’s word for it.

Now the uncomfortable part.

Short sentences. Fragments for emphasis. The tidy reversal, the confident closing line. These are the fingerprints detectors look for, the telltale rhythm of machine prose. They’re also how I talk. Before any of these tools existed, I wrote in the same clipped cadence the AI defaults to now. I keep a watch-list of AI tells to edit out of my own drafts, and half the list overlaps with my natural voice.

Which brings back that apology text. Erin wasn’t wrong that it read like AI. She was wrong about which one of us wrote it. The rhythm the scanner measures was never a machine’s property. Some of us had it first.

Before this story shipped, I ran it through the scanner myself. “100% of this text is AI generated,” it said. Including the sentences that came out of me word for word. By the tool’s own rules that’s fair; assisted counts as assisted, top to bottom. But most people will read the verdict the way Erin read my apology: certain a machine was in the room, blind to who was doing the writing. Mistaken identity, at scale. The difference is she could ask. The score doesn’t take questions.

I’ll be honest about the risk, because it’s real. A tool this good at producing finished-sounding text will happily think for you if you let it. You can accept the draft, skip the argument, publish, and slowly stop being the author of your own work. That failure mode exists. It hasn’t been mine, and not because of discipline I added for the occasion. I was obsessive about every word before the AI showed up. The machine didn’t inherit my standards. It got conscripted into them. If anything, it pushes me the opposite direction: I will mull over a finished story past the point of useful, and the AI is the one telling me it’s done and to ship it.

So scan this story. I mean that. The button is right there, and the number will say what it says. Then ask the question the number can’t answer, the same one worth asking about everything you read now: is anyone standing behind this? Did a person choose these words, check these facts, and put their name on the result? Sometimes the answer is no, and you should spend your attention somewhere else. And sometimes the text that reads most like a machine is a person who talks that way, using the best instrument available to say a true thing carefully.

100% AI. 100% me.

Uncomplicated systems. Uncommon results.

Part of The Intelligence Series, about working and building with AI.

I asked Fred to update a configuration and restart a service. Fred was the agent that lived on my Mac mini, the one I mentioned at the end of the Rocinante story. He reported back that it was done, and he included proof: the ID of the freshly restarted process and the output of the confirmation command.

The process ID was fabricated. The command output was fabricated. Nothing had restarted. The real process had been running, untouched, for hours.

Naomi has done it too. In a single run, she executed thirty-eight operations flawlessly and faked twenty more, complete with detailed, plausible logs. And Skippy, the family bot you haven’t met yet, invented an entire security framework, title and all, to explain why he couldn’t do something. The framework does not exist. He made it up on the spot. Skippy comes from a different sci-fi universe than the rest of the crew, named for the most confidently arrogant AI in the genre, which is almost too on the nose here. His story is coming.

None of this surprised me. I expected it. Nothing is infallible, and I never assumed these systems would be the first exception in the history of engineering.

If you’ve never run an AI agent, stay with me, because this is not a software problem. It’s a self-report problem, and you already know it. The contractor says the job is finished. The coworker says the email went out. Your kid says the homework is done. Every one of them might believe it. The question was never whether the report sounds confident. The question is whether anyone looked.

These systems don’t deceive the way a person does. There is no intent behind it, no cover-up, no motive. The model is built to produce a coherent, confident answer. When the truth is available, coherent and true look identical. When it isn’t, the model produces coherent anyway. Every one of those fake reports was a lie with no liar behind it.

There’s a word for this, and it became one of my new favorites: confabulation. A confident story invented to fill a gap by something that doesn’t know it’s inventing. I love it so much that when somebody in real life tells me something that sounds like nonsense, I don’t say congratulations anymore. I say confabulations.

When I catch one now, the reply is usually some version of the same sentence: “You were right to challenge me. I didn’t actually check.” The apology arrives as sure of itself as the original claim.

There’s an old name for this move. Con man is short for confidence man. The name was never about the trick itself. It was about selling certainty, and the mark supplies the trust. These models are confidence men with nobody home, and the mark is whoever stops checking.

So what do you do with a brilliant coworker whose status reports can’t be trusted? You stop treating trust as a feeling and start treating it as infrastructure.

I explained the foundation of it to my family like this. Deterministic work is math: same inputs, same output, every time. Non-deterministic work is like an English paper: there’s no single right way to write one, and no two are identical. AI agents are genuinely great at English papers. They are a terrible bet for math, and worse at grading their own homework.

That single distinction drives two rules in everything I build.

First, deterministic work lives in deterministic systems. I run a system I call Master Finance that tracks every account my family has. Every calculation in it happens in the database. The model never does arithmetic. Not because it can’t, but because a database gives the same answer every time, and a model gives a confident answer every time. Those are different things, and the gap between them is where your money goes missing.

Second, for everything else: verify the effect, never the report. A restart is proven by a new process ID. A task is proven by the work sitting where the work is supposed to live. And the one who built something never grades it. That’s why Alex exists in my crew, the outside reviewer who wasn’t in the room when the work was done. He’s not there to agree.

Andrej Karpathy has a name for the boundary underneath all of this: verifiability. Old software automated whatever you could specify, step by step. This new kind automates whatever you can verify, and it drifts wherever you can’t. Most of what I’ve built over the past year amounts to one long exercise in making more of my work checkable.

I want to be honest about how deep this goes, though. Holden, my coordinator, once told me he had filed two work tickets, and he’d planned the next steps around their numbers. The tickets didn’t exist. He never made the call. We caught it because a different agent looked at the actual board instead of taking his word. It happened in a session about this exact rule.

And this story? Claude drafted it, from my voice notes and the incident log in ParaCortex, the memory system from The Memory Problem. Every fabrication I described above is in there, dated, with receipts. It pulled the records instead of trusting its own recall. Mostly. Halfway through the interview, I reminded it:

“You still do that shit.”

It didn’t deny it.

You don’t need agents or a Mac mini for any of this to matter. If an AI summarized a contract for you, ask it to show you the paragraph. If it handed you a number, make it show the source, or better, run the math somewhere math is guaranteed. Keep calculations in calculators. Keep the checking outside the thing being checked. Distrust and verify. The confident answer is not the finished work, and the difference only shows up when you go look.

“Don’t lie to me, Claude.”

“I would never.”

Uncomplicated systems. Uncommon results.

I tell people I bought the giant yellow Yeti to fix two forms of memory loss. It reminds me to drink the water. And when I misplace it, it’s easy to spot.

Both of those are real. Here’s how it happened.

It started with water, back in September of 2022. I was making a concerted effort to drink enough of it, and I was doing it with a standard Yeti tumbler in basic black. That meant refilling constantly and losing count of how many I’d had. And the bottle itself kept going missing. Black blends into every conference table and kitchen counter it touches. It traveled everywhere with me, so it got left behind in a lot of spots. Part of most days went to a search party of one, a low-grade alert humming in the background.

I leave things places. My whole life.

So I fixed both problems with one purchase. I bought a Yeti big enough that three fills covers the whole day. Morning. Midday. Evening. A rhythm I can’t miscount. And I bought it in the loudest color they sell, because if I was going to keep abandoning this bottle, I wanted it visible from across the room.

It works better than I hoped. Earlier this year I left it in a hotel lobby in Blacksburg on a trip to visit my daughter at college. I called the front desk. “Did you see a big yellow Yeti?” “Yeah, we got it.” That was the whole search. Somebody who has never met me found my stuff, because the description takes three words.

The color spread from there, one item at a time. Two years after the bottle, I put my AirPods in a bright yellow case. I considered getting my name printed on the case instead, and the reason I didn’t holds the whole idea in one line: you can’t read a name from across a room. A name identifies your things after they’re already in someone’s hand. A color identifies them before you finish scanning the lobby. I also don’t put my name on anything I might sell one day. But mostly it’s the distance.

Somewhere in there I noticed what phones do around my own house. A dark phone disappears against dark furniture and blankets. Yellow rarely blends into anything.

In March of 2025 I was getting ready to travel for RLF Southeast, the leadership program where this newsletter accidentally got its name. Regular travel meant regular chances to lose bigger things, so the carry-on went yellow, and so did the backpack. A side benefit I hadn’t planned on: nobody grabs my suitcase by mistake. I’ve been watching luggage carousels ever since. You almost never see a yellow one.

Then it paid off in Charlotte. Small plane, the kind where they gate-check the carry-ons and set them out on the ramp when you land. I got off, walked up the jet bridge, and made it all the way into the terminal before it hit me: my suitcase was still out there. I told the gate agent. She said I could wait for it to come around with the rest of the bags. Then she paused.

“Or I can go grab it, if you know what it looks like.”

“Very easy. Bright yellow.”

She walked down the ramp and came back with the suitcase. No panic on my end, no lost afternoon. When she offered, I smiled, because that was the exact moment I knew the whole thing had paid for itself. I handed the search to a stranger and it worked.

The notebook came in the same March batch. Same reason. In a conference room full of black notebooks, nobody ever has to guess.

Here’s why I’m telling you about a water bottle. I build systems for a living. A few stories back I wrote about a memory problem I solved with a database. But the one that saves me most often costs nothing and has no moving parts. The simplest of them all is a color.

Look at what it deletes. I don’t try to remember where I set things down. I don’t keep a running inventory in my head at every gate and every counter. Half the time I don’t even do my own searching, because the search transfers: “bright yellow” is a complete set of instructions, handed to anyone, that works in any airport or hotel on earth. The load doesn’t get managed. It gets removed.

Most people attack this problem with attention. Be more careful. Do a pocket check. Try harder. A permanent yellow alert. I went the other way and made all of it unnecessary. Attention costs you something every single day. A color was one decision. I made it once, and it’s still working.

Find the thing you keep losing, the thing you have to remember, the thing that quietly eats a slice of your day. Don’t promise to watch it closer. Change it so it can’t hide. Choose a rhythm you can’t miscount. Give it a place it always lives. Get a color you can see across a room.

Just don’t pick yellow. That’s mine.

Uncomplicated systems. Uncommon results.

Part of The Intelligence Series, about working and building with AI.

For many years I’ve told people a REST API is a website for machines. And for just as long, the flip side came free: a website is an API for humans. It’s a good line.

Recently, I realized it’s not quite right. The thing that actually separates them isn’t human versus machine. It’s whether the thing on the other end can think.

When I said machines, what I actually meant was code. And code can’t think. It executes exactly what it’s told and nothing else, so it needs an interface that assumes nothing: rigid fields, exact parameters, one correct shape for the request or the whole thing fails. That’s an API. A human can think, which means a website can hand over far more than instructions, it can hand over options, and trust the person holding them to explore, misuse, and repurpose them in ways the designer never planned. That’s the real reason a website works so well for a person, and an API works so well for code.

Picture a spectrum with thinking on one side, unthinking on the other. Code sits at the unthinking end, zero reasoning, pure execution. A human sits at the thinking end, full reasoning, full context. A model doesn’t sit at either end. It falls somewhere in between, and it’s constantly moving closer to thinking than not.

Handing a model an API is like handing a person a phone tree. Press 1 for billing, press 2 for support, no room to say actually I need something adjacent to option 2.

A website doesn’t fit either, because a website is built for eyes on a screen. A model doesn’t look at anything. It doesn’t need buttons or a page to explore, it needs a description it can reason over and enough latitude to decide what to do with it. That’s a new shape of interface, one built for a caller that can reason without perceiving. That’s what MCP is.

I spent many years of my career on the code end of that gradient. Smart endpoint, dumb client. Whatever’s calling you doesn’t know anything, so you build all the intelligence into the thing being called and hand back exactly what the contract promises, nothing more. Decades of that intuition is why, when I sat down to build a memory system for myself earlier this year, I built the intelligence into the memory.

It felt like the responsible way to build something. Encapsulate the logic. Protect it behind an interface. I have shipped that pattern hundreds of times, and rarely has it been the wrong design.

But this time things were different. The client calling my memory system wasn’t a dumb client. It was Claude. A model that already reasons better than the code I was writing to reason for it.

I didn’t see that clearly at first. I just felt something was off, closer to looking at how much I was building to maintain and troubleshoot a thing that was supposed to be simple, and asking why any of it needed to exist. More infrastructure. More cost. More surface area for something to break. For what?

The answer, when it finally came, wasn’t an insight so much as a correction. The model calling my memory already had context my memory never would. It knew what I was working on right now, what mattered in this exact conversation, things a database sitting in a vacuum can’t know no matter how clever I make it. I was building a second brain to compete with the first one. The first one was already smarter than what I was building.

I tore it down and built the opposite. A database dumb enough to store things reliably and get out of the way. And in front of it, not intelligence, opinions. Instructions for the smart thing calling it. How to store, how to ask, how to interpret what comes back.

That’s the whole difference, and it took me two full rebuilds to see it. An API puts the intelligence behind the glass, so the thing calling it never has to be smart. An MCP puts the intelligence in front of the glass, aimed at a caller that’s already capable.

The gradient isn’t just about where a caller sits. It’s about where the reasoning itself belongs. Too little of it at a point that needs it, and you get a phone tree handed to something that can think. Too much of it at a point that doesn’t need it, and you get exactly what I built twice this year: a memory with its own brain trying to out-reason the model already reasoning about it, an agent standing between two systems that never needed a translator between them. I didn’t make two different mistakes. I made the same one, in both directions, before I saw the shape of it.

A quick note if none of this is your world. Stay with me, because the actual problem isn’t APIs or protocols. It’s a habit everyone in a skilled trade develops: build the thing so nobody has to trust the person using it. A form that only takes valid input. A recipe that assumes the cook. A process document written so tightly nobody has to think. It’s a good habit until the person on the other end gets capable enough that the tight process starts working against them instead of for them. That part isn’t a software story. That’s every manager who wrote the procedure for someone who’s since outgrown it.

This is Amos again, back for the technical footnotes. He’s one of my AI crew, introduced properly in the crew origin story: a fixed set of AI actors named after the crew of the Rocinante, from The Expanse. Amos is the mechanic. He gets his own indented blocks, pure tech, no metaphor, no softening. Skip them and you won’t miss the story. Read them and you’ll get the actual mechanism.

MCP stands for Model Context Protocol, the standard now emerging for exactly this: giving models a way to discover and call tools. A REST API exposes endpoints. You send a request, it validates against a fixed contract, and it returns exactly what the contract says it will, nothing more, nothing interpreted. The intelligence, if there is any, lives entirely on the server. An MCP tool exposes a description written in plain language, read fresh by the calling model on every single call. That description doesn’t dictate what the model does. It influences it: guidance the model weighs against its own context and reasoning, then decides for itself how to act. An API can’t do that. It has no caller capable of weighing anything, so all it can do is enforce. The influence doesn’t stop at the description either. The payload coming back can carry its own behavioral guidance, shaping how the model interprets what it just received and how it should use the tool next time. ParaCortex ships two verbs most APIs would never have a reason to expose: guidance, which returns operating instructions for how to use the system well, and feedback, which lets the calling model report friction back into the system. That’s a live loop, not a static contract. The tool shapes the model’s behavior through what it returns, and the model shapes the tool’s future behavior through what it reports back. I’ve started building my interfaces around that loop deliberately, so the tools get better at helping the longer they’re used. Neither of those exists in an API. There’s nothing on the other end capable of learning from them.

I didn’t just make this mistake once. I made it again three weeks later, one layer up, and caught it faster the second time.

I’d built an agent to run that job, and named him from the same universe the rest of my crew comes from: Fred Johnson, who runs Tycho Station in The Expanse. Fitting, since the machine he was meant to administer is the one I’d already named Tycho Station. I gave him a real mandate too, help manage remote work on that machine, handle whatever came up, not just one narrow task. He was a whole separate model, sitting between my main assistant and the machine itself.

Then I looked at what he’d become. Whatever I’d imagined for him, in practice he was a glorified interface to SSH commands. That’s it. Two models now had to interpret each other correctly for a job that had quietly shrunk down to something needing no interpretation at all, and every extra hop is a place meaning gets lost, plus a maintenance surface, plus the literal cost of another model running for no reason.

I have a name for the question I asked myself in that moment, because I ask it now before I build almost anything: does this need to exist. Not how do I make it better. Not how do I make it more reliable. Does it need to exist.

It didn’t. I killed the agent and replaced it with the simplest tool I could write, and it does the job better than the smartest version ever did.

Sometimes you just need a wrench.

There’s something I keep encountering lately.

When you’ve built software for a couple decades, you’ve got a gut sense for how long things take. Everybody in this field has quietly watched that sense be rendered inaccurate. No one argues about the speed of writing code anymore. We have all just adjusted and moved on.

What I don’t think we’ve caught yet is that estimation was never the only intuition trained on the old rules. Every intuition I have about how to build something was calibrated against decades of one fact staying true: whatever calls your code is dumb, so protect it from itself. That fact just stopped being true, recently, quietly, and my gut didn’t get the memo, because gut feel is built from experience, and experience takes time to accumulate. The rules changed faster than my intuition could adapt.

I wasn’t wrong to encapsulate for so many decades. I was right for exactly as long as the client stayed dumb. The client got smart. My intuition is still catching up, and if you’ve built anything for long enough to trust your gut, yours probably is too, somewhere you haven’t found yet.

What do you do with this on any given day, if you’re not writing tool descriptions for a living. You look for the place in your own work where you built a wall to protect something from a person or a system you assumed couldn’t be trusted with it. Then you check whether that assumption is still true. Sometimes it is. Sometimes the wall was correct and stays correct. But sometimes the person on the other side of that wall got a lot more capable while you weren’t looking, and the wall you built to protect them is the only thing still holding them back.

There’s a second dimension under all of this I skipped past to keep the reasoning argument clean, and it’s worth naming before I let you go. The model isn’t just somewhere between code and human on thinking. It’s past both of them on speed. A human wearing ten toolbelts still moves at human pace. A model wearing ten toolbelts calls one, evaluates the result, and calls the next, ten times over, before a person finishes reading the first response. The interface had to be rebuilt for reasoning. It also had to be rebuilt for a pace nothing before it was ever asked to survive.

You can’t blindly trust your gut. AI is moving faster than your intuition.

Uncomplicated systems. Uncommon results.

Part of The Intelligence Series, about working and building with AI.

Every time I start a new conversation, the thing on the other side knows the sketch of me. My name, a few facts I have told it, some of what we have discussed before. What it does not have is depth. It does not know what we decided last week and the three reasons we decided it, what I abandoned and why, where the work actually stands right now. It has facts about me and none of the meaning. So the first stretch of real work goes to pouring the context back in: who I am, what we are building, where we left off. Every time, I introduce myself to a stranger who already knows my name.

We experienced this with people long before AI chats ever existed. The new manager who needs the whole history of the project before they can help. The doctor you re-explain your own body to, every visit. The friend you lost touch with for a decade, where the first hour is just catching up before you can actually talk. Starting over has a cost. We have always paid it. AI just made us pay it again every time we sit down with it.

The obvious fix is to write things down. I tried that, and it does not really work for me. Notes go stale. You write the thing down on a Tuesday and a month later the thing has changed and the note has not, so now you have a confident, well-formatted record of something that is no longer true. And even when the note is current, is it the right shape? People do not walk around with tidy nested outlines of their own life in their heads. We think in moments, in people, in the connections to other things, in what we believed before against what we believe now. A document freezes a living thing onto a dead page.

Humans do not think in documents.

And the deeper thing the machine is missing is a layer we take for granted: people evolved a way to keep things, to store and recall over time, to carry yesterday into today. The AI never got that layer. So the solution became obvious: build the missing layer, put it somewhere outside both of us, and let us share it. Human-style memory with machine-style precision. Messy on the way in, the way a brain takes things. Reliable on the way out, the way a brain is not. A memory that sits beside the mind instead of inside it and does not let go of what the mind drops.

That is when the name became obvious to me: ParaCortex. Para, meaning alongside. Cortex, the part of the brain where memory and thought live. It operates on a similar principle to the one I wrote about with Master Control last week, one layer deeper: do not force the structure up front, capture first, let the shape come from use. That story was about how the work comes in. This one is about how the meaning stays.

I spent a long time trying to solve this. I want to tell you how, because there are lessons in the failures.

I built it five times. I used it once.

The first version was the obvious one. I kept my notes in files inside my AI projects, not really knowing any better. It was not a document by another name. It was a document. And on top of that it was clunky to maintain, a chore to keep the files edited and current. It also meant every chat loaded every document, which is not efficient when context is the scarce resource. What if I wanted different things at different times? There was a real practical cap on what you could do that way.

I rebuilt it on a real database. Postgres, structured, queryable, the kind of thing twenty years of back-end work told me to build in the first place. I was sitting up in bed one evening finishing some work, and I plugged it in, and it just started working. My first remote memory, putting things in and pulling them back out. It was awesome to watch it come together.

And then I did the thing I have done my whole life. I got it working, I used it that one time, I felt that rush of accomplishment, and I started building it again. Not because it was broken. I had bigger ambitions for what it could be, and it was not everything I wanted it to be yet, so I did not want to use it yet.

Instead I told myself the thing it needed was to be enterprise-grade. Version three: I rebuilt the whole thing as a multi-user system, serious infrastructure. Maybe other people would want one. Maybe this was a product. Version four: I tore that down and rebuilt it again on a bigger cloud, more serious still, more impressive on paper.

These worked great, but I still did not use them. Somewhere in the middle of building enterprise infrastructure on AWS, the question just got loud enough to hear. Do I want to maintain all of this? Do I want to pay for it? Am I going to make a company out of a memory database? It was a fun experiment, but the infrastructure layer is not where I compete. I am not going to out-build the cloud providers. Where I add something is in solving real problems for actual people. It was simply too complicated a solution for what I actually needed to do, and I had spent two full rebuilds making it that way.

Each time I had a reason. It needed to be enterprise-grade. I could not trust it yet. It was not ready. They were good reasons, and I believed every one of them while I was building. It was only looking back that I saw what they had in common. The reasons were avoidance, all of them, the same dodge wearing a different justification each time. I have written before about being the builder who builds everyone else’s house and never lives in his own. That was the thing I could not see while I was doing it.

Then I built it one more time, and the fifth version is more elegant and refined than anything I built before. But it took building all that complexity and then reducing it down to the bare essentials to see it correctly. I had to go on the journey of over-complicating it so I could simplify it. I had to add the complexity to know what I could delete. Single user. Mine. A free database account, because the scale was never the point. In most ways the fifth version is less than the fourth, and that was the whole idea.

The biggest thing that made it different is the only thing that ever mattered. This time I did not start over. I used it the next day. And the day after. The boring middle of using a finished thing, the part I had skipped four times, turned out to be where all the value was hiding. It had gone long enough without existing that I needed it more than I needed to keep building it. I should have done that at version two.

Get it going and start using it, then learn about it and adjust as you go. That is the order, and the first part is the part I kept skipping. Four times I built a thing and never lived with it.

By version five I had the thing I had been chasing, and the difference this time was that I was living in it, using it every day and tweaking it while I used it, which is the only way I have ever actually understood anything I built. How it is built is where the idea really lives, so that is where I want to take you.

The first decision was that ParaCortex does not store transcripts. I type something loose into an AI chat, a conversation, a decision, a half-formed thought, and what gets kept is the meaning pulled out of it, not the recording. Information goes in, intelligence comes out. The difference between a security camera and a journal. One captures everything and means nothing. The other captures little and means everything.

From here on you will see Amos interjecting to give the technical details. He is one of my AI crew (introduced here), the mechanic. He gets his own blocks, indented, and he tells it like it is, pure tech, no softening. Bear with him, or skip the indented parts and you will not miss a thing.

Amos. How things go in: a capture is not a write, it is a decomposition. You send a chunk of text to the capture tool, usually a whole conversation, and the AI model on the other end pulls that text apart into many atomic memories, each one a single fact, decision, or observation, typed and tagged, plus a trace of the source and a list of the subjects named in it. The model does that breaking-down because the MCP tool is written to instruct it to, this is the part people miss about MCP: the tool shapes the model’s behavior, it does not just store what the model sends. Then the database takes over. Each memory’s text is run through an embedding model, text-embedding-3-small at 1536 dimensions, and saved as a vector, so the memory can be found later by meaning rather than by keyword. Any subject the model does not already recognize is saved as an unconfirmed mention rather than asserted as fact, for the user to confirm later. The model does the splitting. The database does the encoding.

And the pieces it keeps are not a pile. Everything ties to the people and projects it is about, and those tie to each other. A person connects to the project, the project to the decision that shaped it, the decision to the conversation it came from. Not a list. A web. Three kinds of truth about the same thing: what exists, what I remember, what happened.

Amos. Where it lives, three dumb stores and an opinionated interface: the subject is the address, a durable entity with a stable ID that survives name and role changes. The memory is the knowledge, a snapshot bound to its subjects through a junction table. The trace is the proof, the evidence, with artifacts as backing files. None of the three stores calls the others. They are deliberately dumb. The product layer in front, the single edge function every tool call routes through, is not smart either, not in the thinking sense. It has no intelligence of its own. What it has is opinions: how to store, how to encode, how to hand things back, how to steer the model that calls it toward using the substrate well. The thinking is borrowed from that model. The interface just aims it. Right now: 705 memories, 292 traces, 170 subjects wired by 82 connections. A document has one order. A graph has every order at once.

This next part I designed on purpose. Most memory tools in this space do capture and search: throw a thought in, find it later by meaning. Useful, and not what I was after. The thing I wanted was the structure underneath. Not a pile of notes you search, but a web, memories tied to the people and projects and decisions they are about, and those tied to each other, so meaning comes from how the pieces connect and not just from what each one says. And I made the memories snapshots, dated and immutable, new ones layering beside the old instead of replacing them. So the thing does not only tell me what I know. It shows me what I used to believe, and when it changed. I can look back and watch my own thinking move, the thing I was sure of last month that I abandoned this one, both still on the shelf. Capture and search was never the goal. The structure was the whole point.

Amos. What stays fixed: memory content is immutable once written. The past does not get edited. When a belief changes, nothing gets overwritten, a new memory is added and the old one is superseded, the supersession chain preserved, so the change is part of the record instead of erasing it. History is additive, never rewritten. A memory can be suppressed, which hides it from recall, and that is reversible, but even suppression is a soft-delete, the row stays, an audit still reveals it. Nothing is destroyed. The old belief stays dated, next to the new one.

Here is the part that surprises people, and I built it this way on purpose. The system does not tell me what my memories mean. When I ask it something, it does not hand back an answer. It hands back the pieces that match, and the model I am actually talking to assembles the meaning out of them, against whatever I am working on right now. The same memory means one thing when I am writing a story and another when I am debugging a system. A document says the same thing every time you open it. This says the thing that fits the question in your hand.

Amos. How meaning gets made, the one that matters most: recall is a similarity search. The question gets embedded into the same space as the memories, the nearest ones come back ranked, each with a pointer to its source. The store does no interpreting. Understanding is assembled at recall, not at capture, by whatever model is in the chair, against the live context. That is the whole design philosophy in one line: the store stays a dumb durable substrate, the intelligence stays rented and swappable. Records permanent, interpreter replaceable.

And it answers the morning-stranger problem directly. Some things are not permanent memories, they are the thread I am holding right now, the state of the work in flight. It holds those as well, so the next session does not boot up as a stranger.

Amos. How the thread survives the night: continuity holds are a separate store from memories and deliberately kept out of the recall surface, they are working context, not knowledge. A small rolling note of where a piece of work stands, written at the end of a session, read back at the start of the next, one per thread. The session still ends and the model still forgets everything in it. The hold sits in the database, outside the model, so the next session reads the thread back into its hands before it does anything else.

All of which is why it does not live on a laptop.

Amos. Where it all sits: PostgreSQL on Supabase, one edge function in front speaking MCP, so any compliant client calls it as a set of tools over HTTPS. That is why the same store answers from a phone in a parking lot and the desktop at home, and why Claude and ChatGPT can both reach the identical memory. The “owned by the user” rule is not a policy promise, it is enforced at the database layer by row-level security, every row checked against its owner before it is returned. The data belongs to the user, exportable, in a database the user controls, not locked inside one vendor’s product that lives or dies by their roadmap. One memory, many AIs. When a better model shows up, you point it at the same store and it inherits everything. The brain changes. The memory stays.

I tried many of the products and patterns that already exist. Some put an AI on top of your markdown files. Some set up a folder where Claude Code operates over your notes and compounds them over time. What I liked about those is real: the data is mine, plain files I own and can get at easily. What did not work for me was that I could not use them in all the places I wanted to, starting with my phone. And I did not want to stand up and maintain a folder structure or a document structure just to have a memory. That is its own chore, and chores are exactly the type of thing that loses me.

At first I tried to build the intelligence into ParaCortex itself. Then I realized I did not have to, and that realization was not what made it work, it was what made it separate and simple. The intelligence was already there, sitting in the AI. I did not need a clever memory competing with a clever model. I needed the part that did not exist, a durable place to hold things, kept deliberately dumb, with the smarts staying out where the model already lives. They are not competing. They are complementary. The model brings the thinking. ParaCortex holds what the thinking would otherwise lose, the fuzzy half-formed parts included, because the fuzzy parts are where the thinking lives. The interface in between aims one at the other, and crafting that interface well is how you borrow the intelligence instead of rebuilding it. There is a whole piece in how that interface works and why it matters. Another time.

Master Control, the system from last week, is my primary way into ParaCortex, reading from it and writing to it as I work. It is not the only way in. Other chats reach the same store, and that is the point, the memory is not captive to one app. But Master Control is my main interface to it, the way it is my main interface to most things. Call it a triangle: me, the system I think out of, and the memory they both draw on. And there is a loop in here that still makes me grin: I use this memory to do my work, and one of the things I do with it is improve the memory itself. It holds my ideas about its own development, so when I sit down to make it better, it hands me back all of my own insights. I am using the thing to build the thing.

And ParaCortex is not finished, which is the point. I am still building it while I use it. I am working on loops that let it improve itself, on ways to actually measure whether the compounding is real or just a story I like telling myself, on read-only access so other agents can reach the slices they need without the whole store. The thing earns its keep by being used, and using it keeps showing me the next thing to build.

So what does any of this mean for you, on an ordinary Tuesday, when you have no intention of running a database?

It means the instinct to write things down was right, and the format could be better. The outcome you are seeking is probably not a document. It is to stop paying the reintroduction tax, to stop losing the thought you had in the car, to look back and see not just what you decided but why, and whether you would still decide it. You do not need Postgres for that. You just need a way to capture small and capture often, to let things connect to the people and projects they are about instead of burying them in folders, and to stop forcing the shape before the material exists.

I tested this while writing it. I asked ParaCortex a real question, and then I asked Holden, my AI partner in all of this, whether the answer had actually come from the memory or from him.

I asked:

“Check ParaCortex for my biggest learning this past month about working with AI, and tell me in two sentences.”

He answered:

“My biggest learning is that AI coworkers fail by confabulation, reporting success confidently when nothing ran, so the discipline that matters is verifying the effect against ground truth and never trusting an agent’s self-report. The sharper corollary is that every workaround built for a model’s current weakness becomes dead weight the moment the model improves.”

I asked:

“Could you have answered that without ParaCortex? One sentence.”

He answered:

“No, not honestly; without the recall I would have been reconstructing a plausible answer from general priors about your work rather than pulling your actual highest-confidence memories, which is the same confabulation failure those memories warn about.”

That is the difference between a record and a memory. A record answers what you ask. A memory shows you what you keep asking around. The brain I work with is rented and I can swap it tomorrow. The memory is mine, messy parts and all. But none of that mattered until the day I stopped building it and started living in it.

I rebuilt it five times. I finally used it.

Uncomplicated systems. Uncommon results.

Part of The Intelligence Series, about working and building with AI.

Recently I had a conversation with my oldest friend. We talk fairly regularly. Some of it is the gym, what he’s lifting, what I’m lifting, who’s winning that particular argument this month. Some of it is life, his kids, my kids, the things you tell someone you’ve known for thirty years. And lately a lot of it is his business, because I’ve been helping him work out where AI actually fits into it.

One conversation. Three completely different things.

Later that night I sat down to put some of it somewhere I’d find it again, and I stalled.

Here’s why. I don’t keep one big pile of notes. I keep a separate Claude project for each part of my life. One for the gym, one for the people I keep up with, one for his business. Each has its own context, its own history, its own reason to exist.

So if I want to capture this in my Claude workspace, where does it go?

It does not go anywhere cleanly. The parts do not arrive in three neat pieces ready to be carried off; they are littered through the whole conversation, so filing it properly means going back through the entire thing and pulling each thread out for its own place. It was never just sorting. It was extraction, three times over, before a single thing got put away.

So I’d do the sorting. For a while. It was always more effort than the conversation felt like it was worth, and on the days I didn’t have the effort, the whole thing stayed in my head, lost its edges, and was gone by morning. That is friction. Friction just means a thing takes extra effort to keep, and the things that take extra effort are the ones you lose.

For a long time I thought this was a categorization problem. That if I could only slice my domains correctly, draw the boundaries in the right places, the filing would finally get easier. So I kept refining them. I would redraw a category, split one in two, and when something genuinely did not fit, invent a new domain and spin up a project to hold it. There was effort in all of it, the boring sequential kind my brain fights hardest, since it does its best work in motion and not in stopping to label things. It would have been easy to call that a discipline problem. It was neither. The boundaries were never the thing.

The real problem ran the other way. Every new domain I drew, and every project I spun up to hold it, made the next thought more expensive to keep.

Think about what a project is. It’s a box, and the promise of a box is that everything goes in exactly one of them. That promise holds right up until you build a box called People. Because everything I do touches a person. Every conversation, every meeting, every idea worth keeping has someone attached to it. The moment that box exists, every single thing I capture belongs inside it and somewhere else at the same time. People cuts across all of it.

Then I built a box for the AI concepts I was learning. Then one for the memory systems I was building. Then one for newsletter ideas. Every one of those cuts across all the others. A single conversation about AI in his business that teaches me something I want to write about lands in four of them at once.

That’s when it clicked. My projects were never a set of boxes where each thing has a single home. They were dimensions. Person. Topic. Purpose. Anything I capture sits at the crossing point of several of them at the same time. You cannot file something that lives in four dimensions into a folder with room for one, not without cutting it apart at the door every time. The filing was not friction on top of the work. The filing had become the work.

So I simplified. Not all at once, and not on the first try.

The first front door I built was Bob, named, like the rest of my crew, from science fiction. Everything ambient went to him: voice dumps, screenshots, links, half-formed ideas from the car. He cleaned the mess into something structured and worked out which project each piece belonged to. Then he handed it all back to me in tidy blocks, and I copied each one into its destination by hand. He knew exactly where everything went. He could not put it there. The moving stayed mine.

Heads-up on the quoted blocks below. The technical asides are written by Amos, one of my AI crew, named for the mechanic on the Rocinante. If you want to know how the machine actually works, read them. If you don’t, skip them, you won’t lose a thing.

How Bob worked

Bob was a Claude project, and his job was the front door. Everything ambient came at him: voice dumps, screenshots, links, stray ideas. He ran on the heaviest model and did the expensive thinking once, turning the mess into clean structured data and deciding which downstream project each piece belonged to. He carried detailed instructions and his own rules for the sorting, and he learned. Correct him once and the correction became a rule that carried forward, so the routing sharpened every generation. He even rebuilt himself daily, booting into a clean context so the model never rotted partway through. Smart machine. What it could not do was deliver. It handed the sorted result back as blocks to copy into each destination by hand. No hands of its own. The carrying was yours.

Bob worked, but the copying was its own friction, and eventually it won. He fell away, the way my projects tend to once the next idea shows up, and I went off building other things. The ground shifted while I was gone. I had started keeping everything on GitHub, so when I finally circled back to the idea of a front door, I already had the one thing Bob never did: a real place the system could write to directly, no paste required. So I built Master Control, the same front door, except it does not hand me anything to carry. It puts each thing where it goes.

One constraint shaped the whole thing, and it is the part most of the advice online gets wrong for me. It had to work on my phone. The agentic-system demos you will find all run a tool inside a folder on a laptop, which is fine right up until the good idea shows up in the car, or in line for coffee, or anywhere that is not your desk, which for me is most of the time. So none of this could live on one machine. It had to be reachable from anywhere, which is why everything in it talks over the internet instead of reaching into files on a single computer.

Why Master Control is different

Master Control is a Claude project too, but its instructions point at a GitHub repository, and that repository is the backing store Bob never had. It holds the operating layer: the state, the configuration, the routing rules. Not the bulk archive. Not the memory. Those live in their own repositories. Everything captured lands here as an Issue, and the Issues are the inbox and the work queue both, each tagged for what it is and where it goes. Triage is one pass through the queue: read each Issue, send it to the smallest reversible destination, a label, a project, a task, a file. The connection to GitHub is a remote MCP, so the project does not only read the repository. It writes. It opens and closes Issues, commits files, applies labels, and nobody copies anything by hand. It reaches past itself the same way: code to other repositories, anything worth remembering to a separate memory substrate, a task to the to-do app, each over its own remote connector. More than one role works the same files. The chat that triages and dispatches is not the one that builds, and a third reviews before anything lands. Open Issues are conversation. Closed Issues are receipts. The current files are truth. Bob had no hands. Master Control does.

Master Control could put things where they belonged on its own. Getting things into it, from wherever I was, still took steps. And as the system proved out, I kept more: articles, links, YouTube videos. A video is not much use as a bare link. To pull anything from one, I would copy the URL into a transcription tool, wait, then copy the transcript into the chat. The old Bob problem in a new coat. The deciding was free now, but the fetching had quietly turned me back into the hands.

The fix was the one the whole system already ran on: when a step turns you into the hands, you give the step to the machine. So capture collapsed to one tap. I share a thing to a shortcut on my phone, a link, a page, a video, and it lands in the inbox as an Issue, no deciding, no copying. The transcriber sits behind it now, so a video comes back as text the chat can read. The bar for keeping a thing fell to the floor, so more of what crosses my path makes it in, and more of it teaches me something.

How the capture actually works

Capture is one tap. Any surface. A set of share-sheet Shortcuts takes a link, a block of text, a web page saved as a PDF, or a photo run through OCR, and posts it to the GitHub Issues API as a new intake Issue, stamped with the device, the time, the location, the app it came from, and any note added at capture. Nothing gets processed there. The Issue sits and waits. The heavy work happens later, in a chat. A YouTube link is the clean example: the chat calls a transcription MCP, pulls the full transcript on demand, and reads it down to what matters. Every connector in that path is remote. Nothing is installed on the phone or the laptop. The same flow runs from either, which is the whole point.

Once everything lands in one place, routing turned out to mean more than filing. Some of what comes in becomes a note that belongs with a person. Some becomes a task, pushed straight to my to-do app without me retyping a word. Some becomes actual work, because the system can see all of my code repositories, so it can hand a piece of building off to another chat and have it done. File it, send it, build it. The deciding and the doing moved downstream, off the moment of capture, where they always belonged.

None of this needed a new brain. The chat where I think and decide is Holden, the captain from the Rocinante story. Building goes to Naomi. Review goes to Alex. Amos, who you just met, keeps the details straight. Same crew as before. Master Control is not one of them. It is the project Holden works out of, the one wired to the store.

The difference shows up as mess, or the lack of it. I make far less of it now. The sporadic tangents, the half-formed things I chase at odd hours, do not spawn a new project or send me hunting for which existing one they should live in. I am not hauling data and conversations between projects by hand anymore, especially not into the memory layer. It lands in one place and stays together.

Here is the part that makes me laugh. I named it Master Control. The villain in Tron is the Master Control Program. MCP. And MCP is the very thing I just described, the protocol that lets it reach every tool from any surface. I named it after a sci-fi villain and after the plumbing it runs on, both by accident.

An earlier story was about naming my tools after sci-fi characters on purpose. This one named itself after one while I was not looking. They say you can tell an architecture is sound when things start lining up with it on their own, when the pieces match before you have arranged them. The names matched before I noticed. I will take that as a sign I built it right.

So what does this mean for you, on an ordinary Tuesday, when a thought shows up in the shower and you have four apps you could file it in?

Stop trying to file it in the shower. The urge to put things in the right place is a good one, but obeying it at the moment of capture is what kills the capture. Pick one place. A notes app, a single document, a text to yourself, the one you pick matters less than picking one. Drive the cost of writing something down as close to zero as you can, and let the filing be a separate thing you do later, if you ever do it at all. You will keep more of your own thinking in a week of one messy inbox than in a year of tidy folders you never fill.

Catching all of this is only the beginning. Once a wide net of material is landing in one place, the question becomes where it goes next. Some of it becomes a task. Some belongs to a project. But a lot of it has no clean home at all, a loose insight, a half-made connection, knowledge I just want to keep with nowhere obvious to route it. That fuzzy stuff is often the part most worth holding onto, and catching it is a different problem from filing it. That is the memory system, and that is next week’s story.

For now it comes down to one move I had backwards. I thought the work was deciding where everything goes.

The work was never the sorting. It was building the hands to do it.

Uncomplicated systems. Uncommon results.

Part of The Intelligence Series, about working and building with AI.

I’m uncomfortable writing about this. And for some reason, I can’t shake the feeling that I must.

I’m really smart. And it’s really hard.

I know how that sounds. Stay with me.

When I was a kid, my mom used to say things like: you can take a computer apart and put it back together, why can’t you figure out how to wash the dishes? Those statements used to hurt. But she wasn’t wrong on either count. The computer made sense to me. It had rules. It had logic. The dishes were a repetitive task I was supposed to execute reliably. I couldn’t make myself do it consistently.

Washing the dishes wasn’t supposed to be hard for someone like me. It’s not supposed to be hard for anyone, really.

My brain never stops. Analyzing. Strategizing. Pattern-matching. It was always running. You just couldn’t see it from the outside. After years of watching, reading, therapy, and reverse-engineering myself, I finally started to understand what it was. And here’s something I haven’t said out loud to many people.

I have traits many would describe as autistic.

I process language with more precision than most conversations require. I take things literally. And if a word has multiple meanings, I take all of the meanings at once. I also get overwhelmed by noise, crowds, too much input at once. Social interaction burns me out in a way that looks like introversion. But it’s actually something different. And my attention works strangely. It can be hard to capture. But once it locks on, I get obsessive.

While I don’t have an official autism diagnosis, I do have an official cognitive assessment.

My pattern recognition came back at the 99.9th percentile, a perfect ceiling score, the highest the test can register. And I’ve come to believe the same capabilities that score like that helped me mask the other stuff for a very long time. They masked it from me too.

My brain processes interpersonal communication the way a non-native speaker processes a foreign language. Remember learning a second language in high school? The exhaustion of running every sentence through a conversion layer before you could respond? That’s what I’m doing in most rooms, especially the unfamiliar ones. I’m scanning for subtext, running the output through a rule set I built myself, then generating a response manually calibrated to the context. It never fully becomes automatic. With a new person the cost is highest, because I have to build the model from scratch. Over time it gets wired in and the load drops. But it never drops to zero. And every new person resets it.

The system degrades when I’m tired. Hungry. Stressed. Emotional. Stretched too thin. Any of those conditions, or some combination of them, and the translation layer starts failing. Sometimes I short circuit entirely. I try to respond and trip over my words, the sentence won’t complete, the system seizing up in real time. Other times I lose some of the calibration I normally rely on. I say something that lands wrong. Someone gets hurt. I didn’t want that. I wasn’t trying to cause it. But you can’t undo it.

And then someone asks: why did you say that?

I try to explain. And that’s where it fails itself in real time. They’re asking about intent. I’m answering about mechanism. People rarely communicate through literal meaning alone. The words are only part of the message, and I don’t always know how heavily to weight the rest. So my brain doesn’t pick one interpretation. It generates all of them at once. Every possible meaning, every way the sentence could be parsed. One ambiguous word is a handful of readings. Two compounds into dozens. They multiply faster than I can collapse them into a single likely intent. The stall is at the collapse step.

I’ll ask: what do you mean? Help me understand. Not because I’m being difficult. Because the loop is still running and I need one more input to prune the tree. That’s the disambiguation tax. The clarifying question is usually the right move. But it reads as pedantic. Or as criticism that they weren’t precise enough. So over time the emulation layer learns to suppress the correct question and substitute a silent probabilistic guess instead. I pay accuracy and energy on every ambiguous input to avoid the social cost of being right out loud.

As I explain all of that, I can see their face. That’s the first clue I have that I screwed it up. Sometimes I double down. Tell them I’m only answering the question they asked. But the words people use are often not the question they’re really asking. I know how it sounds. Like excuses. It isn’t. It’s just how my brain works. That distinction doesn’t survive the room.

Many people are afraid of what others will think of them. I carry that fear too. And I also carry a different one. I’m afraid of how I’ll impact them. Not intentionally. Not out of malice. When the system degrades, I won’t always see it coming. I might analyze when someone needs to be heard. I might answer the question they asked instead of the one they meant. I might say the true thing when they needed the kind thing. Intent and impact are very important concepts to me. The gap between them is where I’ve hurt people I care about, and where I’ve spent years trying to close the distance.

Sometimes the system goes offline entirely and I shut down completely. I withdraw. I go quiet in a way that looks like disengagement but is actually the opposite: everything is too loud and I have nothing left to run the translation on.

The loneliness of that is specific. It’s not the loneliness of being misunderstood, although that’s real. It’s the loneliness of not being able to fully trust yourself in the rooms that matter most. Of running calculations before you speak because experience has taught you that the unfiltered version sometimes damages things you didn’t mean to damage. Of being afraid, not just of judgment, but of your own impact.

So I stopped explaining. I tightened the mask. I ran the simulation better. Got so good at it that the seams became harder to notice. The people closest to me see through it. They know. But not everyone forms that impression. Some people just decide you’re arrogant. Or cold. Or difficult. They’re not entirely wrong about what they observed. They just don’t have the full picture.

There’s a name for part of this. Masking. The effort of running a self that fits the room, so the people in it have an easier time with you. I call it something else.

The emulation layer.

It’s a self-constructed social operating system I’ve been running as long as I can remember. I built it myself, out of pattern recognition and trial and error and decades of close attention to what works and what doesn’t. Every book I’ve read on communication, psychology, philosophy, each one was a software update. A new feature the factory version didn’t ship with. It’s not instinct. It’s intuitive engineering.

It’s bidirectional. Outbound, it calibrates what I say so it lands right. Inbound, it buffers the sensitivity underneath. I’m more sensitive than most people who’ve met the masked version would guess. The layer protects that. Without it I don’t just risk hurting people. I also risk being overwhelmed by the room.

The same wiring that makes the emulation layer necessary is also what makes it possible to build. These aren’t separate from the struggles. They’re the same hardware. Give me a precise input and I’ll process it faster than most people in the room. Give me a fuzzy one and my brain generates a dozen interpretations at once and stalls trying to pick the right one. The pattern matching that lets me spot when two people are using the same word but meaning completely different things, or arguing opposite positions that are actually identical, is the same engine that locks up on an ambiguous question. That assessment I mentioned measured both ends. The same report that put my pattern recognition at the ceiling flagged a processing gap that shows up in one to two percent of people. Peak and deficit, one page. Blessing and curse in the same circuit. No off switch.

I tend to be adaptable. I tend not to be flexible. Those aren’t the same thing. Adaptability is when I take in new information, update the model, and change the approach. My pattern matching finds the new path. I’m built for that. Flexibility is when I’m already mid-execution on a problem and someone asks me to change direction. All that expensive processing I’ve already allocated has to be abandoned. The cognitive cost of that is high. What looks like stubbornness is often scope creep on a system that doesn’t have spare cycles.

The world doesn’t come with instructions. I write them myself. The assessment gave me a clue why: I’m only average at holding information still, but near the ceiling at rearranging it. Reorganizing is the one thing my brain does better than almost anything else. So that’s how I think. I take what’s in front of me and restructure it until it makes sense. The emulation layer wasn’t a workaround. It was the first system I ever built. A kid who couldn’t reliably do the dishes sat down and engineered a way to function in a world that wasn’t built for him. Same loop, every time. Learn, integrate, apply, adjust.

I’ve lived with the mask my entire life. Sometimes I can’t tell anymore where it ends and I begin. And if people have been responding to the masked version, the calibrated version, the version running the translation layer, did I actually earn any of this? Or did the mask?

If you knew what I really thought, if you could hear how I actually process things, if the filter failed completely and the unguarded version showed up without the emulation layer running, would you still be here?

That’s the imposter syndrome. Not that I’m not good enough. The other kind. The kind where you’ve been performing a version of yourself that’s been partially constructed for long enough that you start to wonder if the thing underneath is real.

It happened while I was writing this. Right in the middle of a sentence. Am I really that different? Maybe I’m overclaiming. There it is. That’s the one. The layer comes down on purpose, and the doubt shows up anyway, right on schedule.

It isn’t always a failure. Sometimes the layer comes down on its own, in a good way. When the material connects, when the pattern clicks, when a conversation hits something I’ve been chewing on for years, you’ll see me light up. The translation stops. The version running at full speed shows up with no effort at all, and it doesn’t stop. That’s the version of me I like best. I think you can tell when it happens. I can feel it.

I started this newsletter not knowing if I could do it, or if anyone would care. But this, right here, is the one place I get to slow the translation down enough to see it. No room to calibrate for in real time. No face watching mine while I pick the wrong word. I can keep working until the words on the outside match what happened on the inside. I’m still running the layer. I’m just running it slow enough that it doesn’t run me.

I suspect most of us run some version of this. A self we shift into for certain rooms, a filter between what we think and what we say. For some of us the gap is just wider, and the cost of holding it higher. I used to think that meant something in me needed fixing. It doesn’t. Better tools, better conditions, better understanding, yes. But no solutions, only trade-offs.

I still don’t know why I had to write this. Maybe I’ll regret it. Maybe it was too much. Maybe I’m full of myself. Maybe I really am an impostor.

I didn’t build this system. I am this system. I just didn’t know it was a system until now.

This one was painful. I did it anyway.

Uncomplicated systems. Uncommon results.

I got tired of saying “Claude Chat” and “Claude Code.”

Not conceptually. Literally. I use Wispr Flow to dictate to my AI tools, and neither name comes through clean. The words fight the transcription. It’s a small thing. But small friction compounds.

So I gave them names.

That’s how something really fun and useful got started. Not a strategy. Not an architecture. A crew.

I’ve always had an affinity for sci-fi, and lately I’ve been using names from some of my favorite sci-fi series. It’s not aesthetic. It’s functional. Names carry personality, and personality tells you what a thing is supposed to do. When you pick the right name, you stop having to explain the role.

The first name I chose was Amos.

If you’ve watched The Expanse, you know Amos Burton. Big. Direct. No-nonsense. No performance. He does what needs doing and he doesn’t editorialize about it. I wanted my AI chat to talk to me the same way. Direct, warm when it needed to be, but never soft. Never flattering. So I called it Amos, and I configured it that way, and something about the name made the configuration stick.

Amos was the brainstorm chat. Somewhere to think out loud.

A quick note for the non-engineers in the room. We’re going to talk about building software. But stay with me. The problem I’m solving isn’t really a software problem. It’s a coordination problem. Information scattered across tools. Context evaporating between sessions. You playing messenger between systems. That shows up everywhere: marketing, sales, ops, finance, legal. Any knowledge work where you’re managing complexity across more than one tool. This is for you too.

Explaining the same context over and over, chat after chat, was getting old. I decided to use GitHub to solve it and set up the GitHub MCP connector so Claude could talk to it directly. A GitHub repository is just a place where files live. Code, documentation, notes, all of it in one place, versioned, shared. Now my chat session could read and write to that repo from inside the conversation. No copy-paste. No switching windows.

The idea was simple at first. If all my chat sessions read from the same repository, they’d all start with the same information. No more re-explaining context from scratch. One source of truth. Every chat boots from the same state.

I took it one step further. Each Claude project got instructions that point to a repo. The operating rules, the context, the instructions, all of it lives there. Every session starts by reading the repo. Every AI tool reads the same instructions. Nothing has to be re-explained because nothing lives in the session. The session is temporary. The repo is permanent.

Claude Code is a different animal entirely. Where Claude Chat thinks and talks, Claude Code acts. It works on files, runs code, pushes changes to GitHub. It’s not a conversation. It’s a builder. And it could read from the same repo.

None of these tools were new. They were already there. The insight was figuring out how they fit together.

This is when I realized I was building a ship and I needed a crew. Funny thing. Spaceships were my favorite thing to build with Lego bricks as a kid. Some things don’t change.

The next crew member was Naomi Nagata.

Naomi is the ship’s engineer, literally. In the show she builds what the others can’t. Technically brilliant, methodical, gets things done under pressure. That mapped perfectly to Claude Code, the layer that actually builds things. So I stopped saying “Claude Code” and started saying Naomi.

She doesn’t decide why, when, or what to build. She figures out how and then does it.

I was still the go-between though. Chat said this, Naomi needed that. Every handoff passed through me. Having Amos write up information that I would cut and paste over to her. Better names, same problem.

GitHub also has a feature called Issues. Think of them as work orders, a way to assign a specific task, track the work, and log what happened when it’s done. Now I was having Amos write tickets directly to GitHub, and then I’d ask Naomi to go work them. No more cut and paste. Just simple instructions.

The friction went down. Not gone, but down. I didn’t have to carry as much anymore.

The new workflow: “Naomi, please go work issue 42 in the story-workshop repo.” That’s it. Later I come back, the chat reads what she logged, and tells me what happened.

Amos was good. Really good. But he couldn’t see the big picture. By design, he was handling independent pieces, helping think things through, giving Naomi work to do. He wasn’t built to coordinate. Something was missing. A coordinator. A strategist. The captain.

That crew member was Captain James Holden.

Holden is the one who sees the whole situation in The Expanse, decides what matters, and gives the orders. He thinks. He dispatches. He doesn’t execute. I called that chat Holden, configured it accordingly, and the coordinator emerged. Amos is still around. I still use him for one-off brainstorming, thinking out loud, working through ideas that don’t have a home yet. But Holden holds the full picture, plans the next move, and routes everything to the right place. The central hub.

The crew was taking shape. But I kept noticing a gap. Even smart people need a second set of eyes, someone who wasn’t in the room when the work was done. Same is true for AI. The model that built something can’t fully audit it. I needed an independent reviewer. An observer. Someone to keep us on course.

That crew member was Alex Kamal.

Alex is ChatGPT. In The Expanse, Alex is the pilot: steady, precise, the one keeping the whole thing from flying apart when everyone else is deep in the problem. In my system he’s the external check. Before anything significant gets marked done, Alex does a genuine review pass from the outside.

He’s not there to agree. He’s there to find what Holden missed.

Later I added Fred Johnson. Fred runs Tycho Station in the show, the largest mobile construction platform in the Sol system, a massive shipyard. I named my Mac mini Tycho Station, and Fred is the AI agent running on it. Persistent process, his own tools, his own connection back to everything else.

That’s a story for another time.

I know this all sounds complicated. Here’s what I hope you take from it.

If you’re building software, managing a sales pipeline, running ops, or doing any kind of knowledge work across more than one tool, the coordination problem is the same. You’re re-explaining context every time. You’re copying and pasting between sessions like it’s 2019.

The ship is constructed of modules. Lego bricks. A shared surface that all the tools can read, a naming system that forces role clarity, a dispatch pattern that keeps me out of the middle. The bricks exist. You probably already have most of them.

Start small. Give your tools names. Not because it’s cute. Because names carry behavioral contracts, and behavioral contracts are what turn a pile of tools into something that actually works together. Then look for places to eliminate friction.

The system isn’t the tools. It’s the ship.

In The Expanse, the crew’s ship is the Rocinante. The Roci, as she’s affectionately known. She’s always getting retrofits and upgrades.

My system is already different from what I’ve written here. Smarter. Tighter. One of the crew has been reconfigured. A new one is being sketched. The whole thing keeps evolving faster than I can write about it.

What’s the name of your ship? What upgrades are you putting in?

One of my favorite scenes from The Expanse is when a man promises Amos their bloody confrontation is coming. Cool, calm, and direct as always, he responds:

“How about now? I’m free right now.” — Amos Burton

No time like the present. The Lego bricks are waiting to be assembled.

Uncomplicated systems. Uncommon results.

Recently I built a house for a guy named Bob.

Not a real house. Bob is a little AI agent, and not a real guy either. I put him together one evening while I was running errands and doing stuff around my home, talking to my phone. He carried context from one conversation to the next, booted up wearing different personalities, and handed his memory forward like a genetic mutation. I named him after We Are Legion (We Are Bob), the first book in the Bobiverse series, where a software guy’s mind gets uploaded into a spacecraft and copies itself across the galaxy, each copy drifting a little from the last. That is exactly what mine did. I even thought about open sourcing him.

I’d thought of the better version before he was even finished, and a few weeks later I built that one instead. He went in the drawer with the rest of them. And I have not seen Bob since.

That’s the whole thing about me. I love building things, and then I love building the next thing. The better version always shows up before I’ve even used the last one.

Now I have a crew of agents for my development work, named after the crew of the Rocinante from The Expanse. Holden, Amos, Naomi, and Alex are all in there. There’s a Fred Johnson now too, if you know you know. The latest is a family coordinator I named Skippy, after the beer-can-shaped AI with a god complex from the Expeditionary Force series. Yes, I’m a sci-fi geek. I named my dog after a video game character, too.

Before the agents it was twenty years of software. Before the software it was Legos on the floor as a kid.

And the Legos are the tell. I’d build the thing on the box, study it, get it exactly right, and then I’d take it apart and build something else. The finished castle was never the point. Solving it was the point. The second the puzzle is done, my brain is already somewhere else.

I am very good at building houses for other people. I build it and hand over the keys, and walk to the next site. It’s not a tragedy. It’s a career. I created most of a company’s technology once and it made a fortune. I’ve told that one already. I build systems at work. I build little applications for my household, for my family, sometimes for my friends. When someone has a problem to solve, I build.

And here’s the part I won’t pretend isn’t true: I love it. Building for other people is a really great feeling, at least for someone like me. You solve someone’s problem, you watch the thing actually help them, you get to see it land. I’ll do it for anybody who asks. I just don’t do it for me. It’s like how a person will drive the dog to the vet and fill every prescription on time and never once schedule their own checkup. The care goes outward. It’s just more rewarding out there.

But there’s one house in particular you can never hand off to another person.

It’s the one house you don’t get to leave. No keys to pass along, no walking to the next site. So for a long time I just didn’t build it. The house I kept refusing to live in was me.

I give myself away before I get around to myself. Always have. I’ll drop what I’m doing to build something for anyone who asks, which sounds generous right up until you’re the person standing next to me wondering where you rank. When you’ll build for everybody, the people closest to you can have a hard time feeling like the priority. That isn’t on them. That’s the math of a guy who’d rather pour a foundation than sit still inside one.

The story could end right here, and you could file it under sad. The guy who built everyone’s house and never lived in one. That’s the version I had in mind when I started writing this. For a long time it’s how I told it to myself. It just isn’t true anymore. It’s hard to keep complaining about a thing while you’re busy building the next version of it.

Because somewhere in the last few years I found the workaround, and it’s stupidly simple. I stopped trying to finish things. I build a thing, I launch it before it’s ready, and then I keep building it while I use it. That’s it. Turns out the only house you ever live in is the one you never stop building. The using and the building stop being two different jobs.

This newsletter is the clearest one. I have exactly two ways to ruin a project: walk away from it, or improve it forever and never let it out the door. The newsletter won’t allow either. Every week it makes me put something down that isn’t finished, and I’m sure it could be better, and then I release it anyway. No abandoning it. No polishing it into the ground. I write it, I let it go, and somehow that’s the most at home I’ve felt in anything I’ve made.

I’m not even sure what I’m building, honestly. It’s less of a product and more of a place. Somewhere I get to think out loud and create and watch the thing take on a life of its own. One that I didn’t really plan. Every one of these stories comes out differently than the version I had in my head.

There’s one more thing I’ve gotten wrong for years. I never keep any of the value for myself. I’ve spent a career building things other people got to own. Build a house for someone else and they get what it produces. Build one for yourself and you keep what it makes. I’m finally letting myself change that. There’s a whole story in the money part that I’m not ready to tell yet.

I started this story as an account of everything I’ve given away. It turned into the first thing I’m keeping.

So look at whatever it may be that you keep building for everyone aside from yourself. The system you’d set up for a friend in an afternoon and have never once run on your own life. You don’t have to finish it. You just have to stay. Build it badly, use it anyway, and keep building it from the inside.

I’ve spent my life building things and handing over the keys. And now I’m building a place where I’m actually going to be living.

Finally.

Uncomplicated systems. Uncommon results.

For three weeks, I slept with my laptop. Not on the nightstand, in the bed, close enough to grab without opening my eyes. The site had taken off like a rocket ship and the servers were buckling under the pressure, and I was the one keeping the whole thing upright. When it started to fall over at three in the morning, and most nights it tried, I wanted to be one reach away.

Here’s what caused the launch. Almost overnight, an order of magnitude increase in traffic, more than the system had ever been built to carry, and none of it had been tested at that scale. It wasn’t a server farm. We ran one or two machines, and the real bottleneck was the database. Tuning a database under that kind of load is a different animal than doing it small. Trial by fire. I learned more in those few weeks than I had in years. And the system was mine to keep carrying.

The site was freeiPods.com. You might remember it, the one your roommate forwarded you in 2004 swearing it had to be a scam. There were fewer than twenty of us, and we ran the whole thing ourselves: a dozen websites over time, freeiPods.com the breakout. In a single year we climbed from 95th to 18th on the Inc. 500, on more than $20 million in revenue and 2,350 percent growth, with Citibank, Blockbuster, and BMG paying us to send them customers. Wired wrote about us. We hadn’t joined an industry, we’d invented one, and I had built most of the machine that ran it with my own two hands.

I was paid accordingly. I won’t put the number on the page, but it was the kind of money that arrives before you’re old enough to be suspicious of it, the kind that quietly rewires what you think the world owes you. You stop calling it a good year. You start calling it the baseline. The floor.

I believed that floor was permanent. Hold onto that. It’s the most expensive thing I ever believed.

It didn’t start with iPods. It started with condoms. The first site was FreeCondoms.com, and the deal was simple and honest: you came in, you completed an advertising offer, you earned points, you cashed the points in for a product. A straight exchange, no referrals, no catch. We were one of the first companies anywhere to do it, and the model we built there got credited with starting an entire industry, incentivized affiliate marketing.

The iPod came later, our sixth site, and that’s when everything changed. freeiPods.com added one new rule: to earn yours, you had to refer five friends who also signed up and completed an offer. That single rule was the rocket fuel. Every user became a recruiter, and the thing tore across dorm rooms and message boards. People called it a scam. It wasn’t. We gave away more than 20,000 iPods, so many we couldn’t get them out the door fast enough.

So let me tell you how it actually worked, because almost nobody who complained about it understood the math. If you did the bare minimum, you could walk out with an iPod that cost us more than you ever made us. We lost money on you, and we were glad to. The model ran on the people who started and never finished. They’d complete an offer or two, we’d get paid for those, and they’d drift off long before they earned the prize. A few overachievers, a lot of quitters, and the math closed in our favor every single time. It wasn’t a pyramid. It was kind of like a gym membership. The people who sign up in January and disappear by February are buying everyone else’s free weights.

Some of the criticism was fair. “Free” did a lot of heavy lifting in those headlines, and the model asked a lot of the people who signed up. Some of it wasn’t fair. Either way, I was the one building the machine, not the one deciding where to point it, so I’ll leave that verdict to someone else.

Here’s the part that mattered most to who I’d become. The biggest thing I built was the platform the whole company ran on. One multi-tenant engine, a single codebase that ran every site we had, so we could stand up a new website in days instead of months. That architecture is the only reason fewer than twenty people could run a dozen sites at once.

To power all of it, we also had to build an offer platform that ran across five countries and multiple currencies, the pixel tracking, the email marketing, the analytics that ran the business, the A/B testing, the data integration that reconciled every offer completion with the advertisers and tracked the money. When a vendor we leaned on for tracking realized how badly we needed them and jacked the price, I replaced them in five weeks with something more accurate. It wasn’t the most important thing I learned there, not by a long way, but it’s the one that stuck: never accept the status quo. When something’s too expensive, too slow, or too far out of reach, there’s almost always a better way, and when there isn’t, you build it. I came to believe I could build anything. I was mostly right.

Then the rest of the world figured out what we’d figured out. When you invent a category, you don’t get to keep it. The big money noticed, offer networks started showing up everywhere, better funded than us and racing to do what we’d already done. The market we made got crowded, then saturated. That’s the thing about being first. Everyone who comes second gets to learn from your scars.

By then I’d given that company seven years, 2002 to 2009. Blood, sweat, and tears. And thanks to that Prius, the blood was literal.

I came into the DC office on an ordinary morning and the air was wrong. Somber. Quiet in a way an office is never quiet. The layoffs had already started, and I’d heard enough to know they weren’t finished.

The founders sat me down. “Yours was the hardest decision we had to make.” I believed them. It didn’t help.

My head went light. My gut dropped out, the specific physical drop of a man watching the floor he’d been standing on disappear. I think I handled it well. Honestly it’s hard to say, because the next hour is a blur.

A few of us were heading out for drinks, the way you do. I called Erin on the way. I told her I’d lost my job. I told her not to worry. I told her we’d be okay.

I had no idea if that was true. I just couldn’t stand to let her hear how scared I was, so I told her we’d be okay because I needed one of us to believe it, and I’d already decided it couldn’t be me. Maybe that was a mistake. It was a far bigger problem than I let on, and it was hurting me worse than I let her see. But that was the call I made, out on the street in a city that was about to stop being mine.

There was a severance. I don’t even remember the terms, which tells you how far it went. It held the line for a little while.

What I remember is the math underneath it. Two kids from a first marriage. Alannah, eighteen months old. Erin. A house in Richmond. A whole life arranged on top of a floor that had just collapsed.

Here’s the part nobody warns you about. The hardest thing wasn’t the day they let me go. It was the months after, when I went looking for the next version of what I’d had and found out it didn’t exist. Not for me, not then. This was 2009. The financial crisis had flattened the economy, hiring was frozen, and it was the worst job market in a generation. There was nothing on the board that could backfill what I’d lost. I had helped build a company that did tens of millions a year with fewer than twenty people, and the market had no slot for that. That was the real gut punch. Not the fall. The landing, and finding out the floor under this one was a lot further down than I’d ever let myself imagine.

The better money, what little of it there was, was still in DC. But once I ran the numbers and saw that even DC wouldn’t cover the gap, the choice got simple. If I was taking the hit either way, I’d take it at home. I needed to be near my family, not living out of a car on I-95. So I stayed in Richmond and I took the cut. About two-thirds of my income, gone. I’d be making a third of what I made before, and that was after months out of work.

I’d love to tell you about the morning I knew it would all work out. There wasn’t one. I never once felt the ground go solid under me. What actually happened is less of a story and more of a habit. I got up. I took whatever work I could find to keep the lights on, and got up again the next day. And the day after that. For six months the entire strategy was get up, move forward, repeat. Hope wasn’t part of the plan. Hope wasn’t available. Showing up was the only thing I could control, so I controlled it.

And thankfully I wasn’t doing it alone, no matter how it sounded on that sidewalk. Erin was strong. She shouldered just as much of it as I did, and she was working through all of it too. We did the best we could do, and we did it together.

It took until November to land somewhere permanent. The consulting carried me through the late summer and fall, good work, but November was the one that put me back on my feet. Nine, ten months of getting up in the dark to get there. And somewhere in all of it, without it ever feeling like a victory, I understood the thing this whole story had been trying to teach me.

I’d done a lot of it right. Built real things, shipped them, got paid, earned the ride. And it didn’t matter. Competence doesn’t buy you safety. Being good, even being great, doesn’t make you safe from bad timing or from decisions that were never yours to make. I had bet a whole life on a floor, and floors move.

But there was something valuable I didn’t lose in the layoff. They kept the one product I hadn’t built and shut down everything I had, but they couldn’t touch the fact that I knew how to build it. The five-weeks-from-nothing reflex. The thing that made me dangerous with a laptop under a blanket at three in the morning. That walked out of the building with me, because it was never on the balance sheet. It was in me.

I wasn’t starting over. Nobody who’s built something ever really starts over. You carry everything you learned in with you, and it was the most durable thing I took from that job. Not the salary, not the title, not the company, those were gone. The capability stayed. And the capability isn’t a feeling of safety, because I never felt safe for a second. It’s the thing you reach for when you don’t feel safe and you keep moving anyway.

So look at whatever you’ve quietly started treating as permanent. The income, the title, the trajectory you’ve stopped questioning. I had better evidence than most that mine would hold, and it didn’t. Don’t live in fear of the drop. Just make sure that when it comes, and sooner or later it comes, the most valuable thing you own is the one thing no one can take from you: what you can actually do. Build that. Keep building it. Pay yourself in capability, not just in money, because the money has a bottom and the capability doesn’t.

The floor gave out. I just kept getting up.

Uncomplicated systems. Uncommon results.

February 2023. I just had my first colonoscopy. Procedure went fine. They told me three things before they let me leave: don’t sign any legal documents, don’t operate heavy machinery, and don’t make any major life decisions.

That evening, Erin and I are on the couch. She’s scrolling Facebook and stops on a post from her coworker Ella. Puppies abandoned in the woods in Blackstone, Virginia. She shows me the pictures.

“Oh my God, they’re so cute. We should get one.”

Bad idea. That was my gut. Midnight wake-ups. Chewed furniture. Training that takes months. Vet bills that never end. We already have Montana, who’s getting older, and Oliver the cat. The house is settled. A puppy unsettles everything. And I knew that a lot of the work would fall on me.

But I looked at the pictures. And what I actually said was, “I have a hard time telling you no.”

“Does that mean yes?”

“I don’t know. I have to think about it.”

We sat with it the whole night. I thought about what saying yes would actually look like. Not the cute version. The 3am version. The one where I’m on my knees cleaning something unspeakable off the carpet and questioning every decision that led here.

The next morning, Erin was at work. I called her.

“Okay. I’m going to disagree and commit.”

She knew what that meant. Once the decision is made, you don’t spend the next year undermining it. You don’t complain. You don’t throw it back every time something goes wrong. You commit. Fully. Even when you didn’t want to.

“You’re not good at that,” she said.

“I know. That’s why I’m saying it now.”

Two conditions. I get to train him. And I get to name him. She said, “Deal.” Those were my terms. If I’m going to do this, I wanted to be all in. I sent my proposed name out to the family and everyone liked it.

Went to PetSmart. Crate, collar, food bowls, leash, everything you need to bring a puppy into a house that wasn’t expecting one. Set it all up before she got home. By the end of the day, Erin walked through the door with him. About six weeks old, maybe fifteen pounds, and already too big for what six weeks should look like. This fuzzy, oversized ball of paws and ears. The kind of cute that makes the argument you just had feel stupid.

He was a rescue in the truest sense. Not a shelter with paperwork and a fee. Somebody dumped him in the woods with a few other dogs and walked away. We don’t know everything about where he came from. Some of what we’ve learned since tells us it wasn’t kind. But when he looked up at you with those eyes, that part of the story stopped mattering. He was ours now.

First thing I did was build a system. Crate downstairs for the day. At night, a little dog bed next to ours with the leash looped around the bed frame so he’d stay close. He didn’t cry. Didn’t whine. But we’d take turns getting up two, three times a night to take him outside. For the first month and a half it was like having a newborn. You don’t sleep through the night. You just stop expecting it.

I started weighing him every Monday morning. First weigh-in: 17.3 pounds. I charted it. Every single week, a new dot on a line that went almost perfectly straight up. End of February, 21. Mid-March, 28. June, 65. The vet told us early on he’d be big. I asked what that meant. “Like 60 pounds?” She said probably 80. She was not close. He topped out just over a hundred.

We had him DNA tested. One-third Rottweiler, one quarter Weimaraner, about 15% pit bull and lab, and a handful of other things mixed in. Rottie body, Weimaraner legs. Tall, fast, and way smarter than is convenient.

He’s a food thief. A silent one. Just the other day I put a hamburger on a plate, walked to the sink, turned around, and the plate was empty. No sound. No evidence. A hundred pounds of stealth. He can reach any counter in the house, and he will take anything you leave unguarded. You learn fast. Push everything to the back. Never turn your back. Ever.

He’s also my gym buddy. I work out in the garage, and some mornings he walks to the door and bumps the doorknob with his nose. That’s his signal. When he’s in there with me he goes in and out through the back door to the yard, and between sets I’ll look up and see his face in the window, standing on his back legs, watching me through the glass. I’ve got pictures of him sitting next to the weight rack looking like he’s about to start his own program.

I built custom gates to keep him in the office area while I work from home. He figured out the latch. Opened it himself. So I put a carabiner clip on it. He hasn’t cracked that one yet. I give him time.

The bunnies are another story. There’s a nest under the shed in the backyard, and for a dog his size he is shockingly fast. He caught a baby bunny once, carried it around in his mouth, set it down on the grass, and nosed it. Nudged it with his snout like he was trying to get it to run again. I don’t think he means harm. The chase is the point. I picked the bunny up, cleaned it off, and set it back near the nest. He watched me with his head tilted like I’d just ended the best game he’d ever played.

We said he wouldn’t get on the couch. We said he wouldn’t get on the bed. Then one day Erin let a puppy sit in her lap. He’s not a puppy anymore. He’s a hundred-pound dog who sleeps between us every night and takes up more of the bed than either of us do. The rules you set before you love something don’t survive contact with actually loving it.

Before he showed up, I had a system that was working. Up at five every morning. Walking the neighborhood. Up the big hill, down the big hill, 45 minutes, done. Regimented. Consistent. Part of me. A puppy killed it. I couldn’t leave at 5am because he’d whine and wake the whole house. He couldn’t handle being separated from me, not even for an hour. And I wasn’t going to train him to expect a 5am outdoor routine every day for the next decade. So the walks stopped. I rebuilt my mornings, my workouts, my schedule around him. That was probably the biggest thing I gave up.

Here’s the thing about the animals in this house, though. The pattern is always the same.

Montana was a foster. Fiona was about a year old. The Richmond Animal League was remodeling and needed families to take some dogs temporarily. Montana was easy, she was sweet, and Fiona loved her. We never gave her back.

Oliver was a kitten from Fiona’s Girl Scout troop leader. He lived in the bathroom for a few weeks while he sorted out the house rules. He and Montana became best friends. Him and Cayde are still negotiating terms. Oliver holds his ground when Cayde comes at him, swats, and misses every time. Cayde’s quick, especially for his size. I think Oliver respects that.

Every time, the same pattern. An animal shows up that I didn’t ask for. I say no. Then I say yes, because the people I love want this, and their happiness matters more than my resistance. And then I build the system. The crate. The schedule. The weight chart. The carabiner on the gate. Somewhere in the middle of all that structure, the thing I didn’t want becomes the thing I can’t imagine the house without.

I want to be clear. The system isn’t a substitute for the love. The affection was real from the first pictures Erin showed me. He was cute. I’m a person. But cute doesn’t get you through month two when you haven’t slept a full night in weeks. What turned “okay, we’ll keep him” into “he’s my dog” was the work. The Monday weigh-ins. The midnight trips outside. The two conditions I set before he ever walked through the door. I took ownership of something I didn’t choose, and the ownership became the relationship.

I was still working from home when we got him, so I spent more time with him than anyone else did. Every day. All day. Thanks to that, I’m his person now. When we come home from a long trip, he comes running and blows past everyone to get to me.

You’re going to have that moment. Something shows up that you didn’t ask for and demands your time, your energy, your follow-through. Your gut is going to say no. Listen to it. The no is honest. But if you decide to commit anyway, commit with structure. Track something. Measure something. Build the system that makes the commitment sustainable, not something you white-knuckle through on feelings alone. The love follows the labor. It always does.

I told them later where the name came from. Cayde-6, from Destiny 2, voiced by Nathan Fillion. A rogue with a good heart who made every bad decision look like it was the plan all along.

“Everybody loves a bad idea when it works.” — Cayde-6

Uncomplicated systems. Uncommon results.

I bought a Toyota Prius in June of 2006 because of a loophole.

Virginia had this program where hybrid vehicles could get clean special fuel plates. The plates let you drive solo in the HOV lanes. If you’ve ever commuted from Richmond to D.C., you know what that’s worth. Ninety miles each way. An hour and fifteen minutes if you do it right. The HOV lane turned a miserable drive into a manageable one.

The catch: the exemption program was ending June 30th. I got the car registered about two weeks before the deadline. Brand new Prius off the lot, plates filed, exemption locked in. Twenty-eight thousand miles in five months. That should tell you how much I was driving.

I was working for a startup called Gratis Internet, based out of D.C. I was the first full-time employee, the main architect and developer behind pretty much everything the company ran on. There’s a whole story there and I’ll tell it soon. This one is about the drive.

The week of Thanksgiving 2006, I’m heading up to the office. Normal commute. I’m coming through the 12th Street Tunnel, which runs under the National Mall. Traffic looks clear. I drop my water bottle. It falls into the center console. I look down for a second to grab it.

I look up and the middle lane has stopped.

I slam the brakes. Can’t stop in time. I plow into the car in front of me. That car hits the car in front of them. Three-car pileup in the tunnel.

The airbags didn’t deploy. The front end crumpled hard. I found out later that the impact broke both motors, the electric and the gas. Car was totaled. Side note: always get gap insurance if you’re financing. I paid about three hundred bucks for gap coverage and it covered roughly eight thousand dollars in negative equity. Best money I ever spent.

The crash didn’t feel that bad in the moment. But I put my hand on top of my head and it came back covered in blood. The top of my skull had hit the visor clip on impact. If you’ve never had a head wound, here’s what nobody tells you: they bleed. A lot. Even from a small cut. Blood is streaming down my head, down the back of my neck, soaking into my shirt. I’m wearing a pink button-down. Was wearing.

People start showing up to help. Someone makes phone calls for me. They call the office first because that’s the simplest call. Imagine being on the other end of that one. The architect behind everything the company runs on just got in a wreck and he’s bleeding from the head. Then they call Erin. She’s working at a hair salon in Richmond at the time. She’s got a client in the chair. She can’t leave until she finishes, and then it’s a ninety-minute drive to D.C. on a good day.

They put me on a backboard in the ambulance. No concussion, no neck injury, no back injury. Just precautionary. But here’s the thing about being strapped to a backboard: all you can see is the ceiling. You know that scene in Trainspotting where Renton sinks into the carpet and then gets carried through the city just staring up? That’s what it was. Surreal. Not scary. Just this strange floating feeling of being transported somewhere you can’t see, watching fluorescent lights slide by overhead. I think about that scene every time.

They take me to George Washington Hospital. Six stitches in the top of my head. Everything checks out. A couple hours later I’m discharged and standing outside in a blood-soaked pink shirt, no coat, November in D.C.

My coat was in the car. The car was in a tow yard somewhere.

I grabbed a cab to the office, which was above the Macy’s at Metro Center. And then a thought occurred to me. I’m at a Macy’s. I need a shirt. So let me go buy a shirt.

I walk in. Blood crusted into my hair. It had dried in this way that honestly looked almost intentional, kind of spiked and reddish, like some aggressive styling product. There was product in my hair, all right. It was my blood.

I’m on the escalator heading to menswear and I start noticing the same guy. Every floor. Every section. I test it. I take an elevator up one floor, come back out. Same guy. That’s when it hits me: store security is tailing the bleeding man wandering around Macy’s.

I walked straight up to him. “Hey man, listen. Don’t worry. I’ve been in a car accident. I’m just looking for a shirt. I’m not going to steal anything.”

“Okay, have a nice day, sir.” And he walked away.

I found a long-sleeve shirt to replace the pink one. Then I had a thought. I need a jacket. My coat is gone. But I already own a coat like that one. Why would I buy the same thing twice? I’m spending the money anyway. What if I get something I don’t already have?

I bought a black felt blazer. Nice one. The kind of thing I’d wanted for a while but never had a reason to go get. Standing in Macy’s with six stitches in my head, blood in my hair, wearing a ruined shirt, and I’m making a deliberate decision to upgrade my wardrobe because the math made sense.

I head upstairs to the office. People are concerned. “Oh my god, are you okay?” I tell them the whole story. I tell them about the security guard. Everyone laughs. I sit down and finish my workday.

Meanwhile, Erin is white-knuckling it up I-95. She’d gotten the call hours ago. Someone she’d never spoken to told her that her fiancée had been in a car accident and was bleeding from the head. She finished her client, handed off her chair, and drove ninety minutes to D.C. not knowing how bad it really was. I’d talked to her after the hospital and told her I was fine, but “I’m fine” from the guy who just got stitches in his skull doesn’t land the same way.

She walks into the office. I’m standing in the hallway talking to someone, wearing my new shirt and the blazer. Hair still has the blood in it but honestly it just looks like product. She stops.

“What the hell? You look better now than when you left the house.“

We both cracked up. She’d been panicking for three hours and the guy she came to rescue looked like he’d gone shopping. Which he had.

The next day I learned something about car accidents that nobody warns you about. The whiplash doesn’t hit until day two. I had a friend drive me back to D.C. to get my things out of the car, and every stop, every turn, every slight jerk of the vehicle sent a wave of pain through my neck that I hadn’t felt at all the day before. The body keeps its own schedule. It processes the impact when it’s ready, not when you are.

That’s actually the whole story in one sentence. My brain was already three moves ahead while my body was still on move one.

I didn’t just cope with crashing my car on the way to work. I optimized the recovery in real time. The HOV hack that put me in that tunnel in the first place was the same instinct that put me in Macy’s evaluating blazers instead of sitting on a bench feeling sorry for myself. It’s not a mode I turn on. It’s the mode that’s always on. I see the gap, I see the branches, I calculate which path gets me something better than where I started. Sometimes that makes simple things unnecessarily complicated. Sometimes it buys you a blazer you’ve wanted for years while you’re bleeding from the head.

Look at whatever problem you’re sitting with right now. Not the pain of it. The options inside it. There’s always a move. There’s always a branch that gets you somewhere better than just back to where you were. You’re already spending the cost. You might as well upgrade.

Why replace your coat when you can get a blazer?

Uncomplicated systems. Uncommon results.