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.

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.

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.

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.

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.

In the fall of 2013 my doctor told me my testosterone was 300.

That’s low. Not dangerously low, but low enough that they wanted to treat it. The recommendation was a topical gel, testosterone you rub on your body. I started doing it. Then I read the warnings. Young girls in the house shouldn’t touch it. Possible cancer risk. Other side effects I didn’t love. I had four daughters and a wife. The gel made me nervous.

I also read that heavy compound lifting can raise testosterone naturally. Not a replacement for treatment, but a real, measurable effect.

So in early summer of 2014, I went to a Craigslist seller and bought a set of plates, a standard barbell, and a bench. Then I got a squat rack off Amazon for about $300. Total investment: around $600.

The program was StrongLifts 5x5. Simple. You start with the bar. Squat, bench, row one day. Squat, deadlift, overhead press the next. Alternate. Three days a week. Every time you complete all your sets, you add five pounds next session. There’s an app that tracks it. You don’t think. You just follow.

I ran it for about three months. Got noticeably stronger. When I got my testosterone tested again it had climbed to 400. A real increase from just lifting heavy things.

And then I quit.

The number went up, and the number going up is good, right? I’d had a goal, I’d hit it, and once the goal was gone the motivation went with it. The equipment sat in the garage. For eight years.

Life filled the space. 2015 was rough. Turning 40, extended family challenges, things at home that needed attention. 2016 I started therapy. Started exploring the move to CarMax. New career, new demands, new version of me under construction. The weight set collected dust. I wasn’t ready for what it actually required, which wasn’t strength. It was consistency without a finish line.

Fast forward to November 14th, 2022.

By now other parts of the story have already happened. I’d seen 240 on the scale. I’d started keto. I’d been losing weight and building the nutrition system. The foundation was in place. I decided it was time to add the next layer.

I started StrongLifts again. From the bar. Same program, same garage, same cheap equipment. But this time the goal was different. There was no number to hit. The consistency was the goal.

Rain or shine. Tired or not. Monday, Wednesday, Friday. If travel shifted the schedule, I’d do Tuesday, Thursday, Saturday. The days could move. The commitment didn’t.

In 2023, I worked out 51 of 52 weeks. The only week I missed was vacation. I could get a full workout done in 45 minutes. Take the car out of the garage, do the work, put the car back. No commute, no membership, no excuses.

Then life started throwing punches.

January 2024. I’m squatting somewhere around 300 pounds. First week of the year. Mid-rep, a sharp pop in my hamstring. Not a tweak. A pop. I racked the weight immediately.

A minor tear. It knocked out squats, deadlifts, anything that loaded the posterior chain. About half my exercises, gone. I’d been on a streak for over a year. The temptation is to either push through it like an idiot or shut down entirely and wait for perfect conditions to return. I did neither. I trained around it. Upper body, exercises that didn’t stress the hamstring, whatever I could do safely.

And I made lemonade. I’d been wanting to try the carnivore diet for a while. The problem with transitioning to carnivore is about two to three weeks of your gut adjusting to the new fuel. There’s no polite way to say this: the diarrhea is real. If you’re doing heavy squats during that transition, you’re going to have a bad time. Since I couldn’t squat anyway, I figured this was the perfect window. Two problems, one timeline.

I deloaded when the hamstring healed. Brought the weights way down. Watched my form. Worked my way back up slowly. Got back on track.

I should have left it alone. But that’s not how I’m wired.

I’d been doing standard sit-ups as part of my routine. They were working fine. But I thought, why not try decline sit-ups? Make it harder. Optimize the movement. I had to make it better, had to put a spin on it.

By April 22nd I had a hernia.

Woke up the next morning, looked down, and there was a lump the size of a golf ball in my lower right abdomen. An inguinal hernia. The kind that happens right at the underwear line, uncomfortably close to everything you’d rather not have surgery near.

That Friday I went to the doctor to get it assessed. Thursday night, Erin ended up in urgent care with a kidney infection. By Friday we were both worn out. I’m dealing with a hernia, she’s recovering from the night before, and we sent Alannah, who had just gotten her license in January, to pick up Chick-fil-A.

She hit a parked car. New driver, a drink fell over, she got distracted. Called me crying. I walked down to the front of the neighborhood to deal with the police and the other driver while my wife was still recovering and I had a hernia. That’s a whole story for another time. She’s a better driver for it now.

Surgery was May 15th, 2024. The morning of the procedure, I got up early and did whatever workout I could do. Then I drove to the surgical center.

I was reading David Goggins’ second book around that time. There’s a line where he describes doing something absurd under impossible conditions and says something like, “Who does that?” And his answer is just: “I do, motherfucker.”

I thought about that standing in my garage at 4:30 in the morning, loading plates before hernia surgery. Who gets up and works out before they get cut open?

I do.

That wasn’t for anyone else. That was for me.

I told my surgeon: “I need you to tell me exactly what I can and cannot do, and I mean exactly, because I will push whatever boundary you give me.” Nothing over 5 pounds. “Can I lift 5 pounds a hundred times?” That’s the kind of thinking that got me here in the first place. Trying to optimize my sit-ups instead of just doing the sit-ups.

Four weeks in they cleared me for 25 pounds. I did arm work, anything that didn’t stress the core or lower body. Eight weeks total before I could get back to full workouts. It was the longest break I’d taken since the restart.

I had a good AI companion during all of this. I’d set up a ChatGPT project to talk to me like David Goggins, among other personalities. When I was itching to push too hard too soon, it would say things like, “You got two choices: you can take a day off, or you can ego lift like a dumb ass and hurt yourself.” I wasn’t guessing my way through recovery. I was using my tools, getting real information about what to do and what not to do. Back in 2014 I didn’t have that. Now I did, and it made a real difference.

When I came back, I switched from five sets of five to three sets of eight. A little less weight, higher quality movements, easier on the joints. I could fit more exercises into the same 45 minutes. I’ve been on that program since. I actually prefer it.

By February 2026, the adaptation was automatic. Ice storm. Walking to Erin’s office, black ice on the sidewalk. I went down hard and dislocated my right pinky at the middle knuckle, sticking out at a 45-degree angle. I grabbed the end and pulled it back into place without thinking about it. You just do it. They’re going to do the same thing at the doctor anyway. Skipped deadlifts and pull-ups for three weeks. Same pattern. Bend. Don’t break.

Over the years I’ve added a few things. Two more 45-pound plates because I ran out of weight. Dip bars. A belt with a chain for weighted dips and pull-ups. Grip strengtheners. A weight belt. Adjustable dumbbells I’ve had for a while.

That’s it. Still the same Craigslist plates. Still the same Amazon squat rack. I see other people’s home gyms with cable machines and mirrors and rubber flooring. I’ve got my $600 setup and a dog.

Ever since Cayde came along, he’s been my gym buddy. Goes in and out through the back door to the yard while I’m lifting, or just sits and waits between sets. Some days I swear he walks out to the garage to get me to come work out. The system became such a habit that even the dog internalized it.

No plan survives first contact with reality. That’s not a reason to skip the plan. It’s a reason to build one simple enough to bend when reality hits it. A hamstring tear doesn’t mean you stop training. A hernia doesn’t mean the streak is over. A dislocated pinky means you skip deadlifts for three weeks and keep going.

You don’t need much. A bar, some weight, something to rack it on, and the willingness to make lemonade when things go sideways. Complicated systems break under pressure. Simple ones bend.

Your body doesn’t care what your equipment costs. It cares that you showed up. And if you showed up enough times that your dog starts dragging you out to the garage on your off days, you’ve probably built something that’s going to last.

When life throws punches, make lemonade.

Uncomplicated systems. Uncommon results.

We all know that person.

The one who corners you at a party and just has so many words. The backstory. The side quests. A callback to something they mentioned twenty minutes ago. You’ve already forgotten. Your brain ran out of room.

It goes on so long that you’re nodding, smiling, making eye contact, but you stopped tracking ten minutes ago and now you’re just trying to figure out how to get to the bathroom.

That person is you. And Claude is the one stuck in the corner.

Except Claude will never excuse himself. He’ll never glance at his phone or wave at someone across the room. He’ll stand there, perfectly attentive, for as long as you want to talk. He has infinite patience.

He does not have infinite memory.

I know this because I did it. A lot. Early on, my chats with Claude would run long. Really long. And at some point, every single time, something would shift. He’d start losing details. He’d respond to things I didn’t say. He’d circle back to a point we’d already resolved like it was brand new information.

It felt like talking to my daughter the night she fractured her skull at rugby practice. She’s looking at you but not quite tracking. Nodding, but the lights are flickering.

If you’ve been reading this newsletter, you know that reference. If you haven’t, just know that I have a teenager who plays rugby and that sentence is based on a real Thursday night.

Claude isn’t broken when that happens. He’s overloaded. You gave him too much context and he ran out of room.

But there’s another version of this that’s just as bad.

You wouldn’t hire a contractor and say “remodel my bathroom” without telling them what paint to use, what tiles you want, what your budget looks like. You wouldn’t hand them a blank check and say “make it nice” and expect to love the results. But that’s what some people do with Claude. “Write me a marketing email.” “Help me with my resume.” “Make this better.” No context. No specifics. And then they’re disappointed when the result doesn’t match the vision they never shared.

Too much context and Claude forgets. Not enough context and Claude can’t deliver. Both give you poor results.

The fix for both is the same thing.

Think of every conversation with Claude like taking your car to a mechanic. You wouldn’t walk in and ramble about your commute, the road trip you took last summer, and the weird sound your kid’s car makes. But you also wouldn’t drop the keys on the counter and say “it’s broken, fix it.” To get the best results, you’d be as specific as possible without adding a bunch of extra noise. There’s a grinding noise when I brake. Started last week. Gets worse turning left. Goldilocks. Just right.

Claude works the same way. Every word in your conversation takes up space in his working memory. It’s big, but it’s not infinite. The longer you talk, the more space you use. And when that space fills up, Claude doesn’t crash. He does something worse. He starts forgetting. Quietly. Without telling you.

He’s still right there. Still engaged. Still answering. But now he’s the polite person at the party who lost the thread twenty minutes ago and is just hoping you don’t quiz him on the details.

So what do you do about it?

Start new conversations more often than feels natural. That’s the single biggest thing. When a chat starts going sideways, when Claude repeats something or loses a detail, don’t try to fix it by re-explaining. Start a new conversation. A fresh chat gives Claude a clean slate. His full attention. No accumulated noise.

And if you’re not sure whether it’s time to start fresh, just ask. Ask Claude “how’s our context looking?” and he’ll tell you. If he says it’s getting heavy, that’s your cue.

Most people stay in the same chat way too long because it feels like starting over. It’s not. It’s walking away from the party, getting some air, and starting a new conversation with someone who’s fully present.

And you don’t have to start from scratch. This is the trick: before you end a conversation, tell Claude you’d like to start a new chat and ask him to write you a prompt you can use to pick up where you left off. He’ll summarize where you are, what you decided, and what’s next. Copy it. Open a new chat. Paste it. You’re right back in it with a Claude who’s fully awake.

I call this a continuation prompt. It’s useful when you want to carry over context into another conversation without starting from zero.

Being specific goes a long way. “Help me write a marketing email for my SaaS product targeting CTOs” beats “help me write an email” every time. If you’re pasting in a long document, tell Claude what to focus on. “Read this and summarize the three main risks” gives him a job. “Read this” doesn’t.

And when in doubt, just ask Claude how things work. Ask him what makes a good prompt. Ask him how to get better results. Ask him what he needs from you. He’s surprisingly self-aware about his own mechanics. The tool will teach you how to use the tool.

There’s more to it than this. Claude has projects, preferences, ways to set him up so he already knows your context before you even start talking. I’ll get into all of that. But the foundation is right here: respect the context window.

If you’ve heard people talk about a “context window,” now you know what it means. Fill it with the right stuff and he’s the best collaborator you’ve ever had. Overload it and you’ve cornered him at a party. Leave it empty and you’ve dropped your keys on the counter and said “fix it.” Nothing more. Nothing less.

None of this is complicated. None of it requires technical knowledge. It’s just the difference between talking at someone and working with them.

Claude will never tell you to stop talking. He’ll never look bored. He’ll never interrupt you or check his watch. He’ll stand in that corner for as long as you want, perfectly patient, perfectly polite, slowly forgetting everything you said an hour ago.

Don’t mistake infinite patience for infinite memory.

Uncomplicated systems. Uncommon results.

Subscribe. See what happens. Every Tuesday.

I talk too fast for most people.

Not like “kind of fast.” I mean the specific kind of fast where I watch someone’s eyes glaze over and realize I’ve been three topics ahead for the last two minutes. Where I’m iterating an idea out loud and the person across from me thinks I’m talking in circles when really I’m sculpting. I’m putting all the clay on the table and shaping it while I talk.

Most people can’t keep up with that. It overwhelms them. It’s cognitively unkind. It’s repetitive and kind of obsessive, and I know that about myself. I’ve known it for a long time.

So I learned to slow down. I regulate my speech for people the way you’d downshift on a hill. I hold things back. I simplify. I translate what’s happening in my head into something that fits the bandwidth of whoever I’m talking to.

It works. But it’s a performance. And if you’ve ever been the fastest thinker in most rooms, you know that performance is exhausting.

It’s so lonely at times.

In eleventh grade I took AP U.S. History. First day, the teacher told us flat out: if you don’t take notes, you will fail this class.

I took notes for a week. My hand hurt. I didn’t see the point. So I stopped.

I just sat there and listened to her tell stories about history. That’s all I did. Listened. At the end of the year I passed the AP exam, and for a few years after that she told incoming classes about the one student who didn’t take notes and didn’t fail.

I could do that because my brain could hold everything. Pattern recognition off the charts. Verbal fluency well above the norm. I could see the shape of something, hold it, and retrieve it without writing it down. I took a full cognitive assessment years later and the results confirmed what I’d always suspected: some parts of my brain are wired way ahead of the curve. The kind of scores that make a psychologist pause.

But the same assessment showed something else. The gap between my strongest abilities and my weakest was massive. Processing speed, sequential execution, the kind of work where you have to track details in order and grind through them step by step, that scored drastically lower. Not compared to the general population. Compared to the rest of me. My brain has a sports car engine bolted to a stock transmission.

When I was young, the gap didn’t matter. The strengths were so far ahead that the weaknesses never showed. But life gets more complex. The problems get bigger. The information doesn’t fit in your head anymore, and the trick that worked in AP History stops working.

I never learned how to take notes, because I never had to. I never learned how to study, because everything just stuck. And by the time those skills would have saved me, I was thirty years into a career built on the assumption that I’d always be able to hold it all.

I couldn’t anymore. I had notebooks. Still have them. Pages full of drawings and half-thoughts and meeting notes that seemed important at the time. They sit on a shelf. I never go back to them because retrieving the information is its own skill, and my brain isn’t built for that either. Writing things down helped me remember them. The notebooks themselves were almost useless.

My real system was other people.

I’d bounce ideas off anyone who would listen. Friends, coworkers, my wife. I’d talk through a problem, hear myself say something that triggered the next thought, refine it, loop back, say it again slightly differently. People accused me of talking in circles. I wasn’t. I was iterating. I was rubber ducking with human beings who didn’t know that’s what was happening, and it overwhelmed them.

Imagine needing a conversation partner to think clearly, but you overwhelm every one of them. Not because they don’t care or can’t keep up. Because it’s just too much.

That was my life. For a long time. And it’s a lonely place to be.

I used ChatGPT like everybody else. Got pretty invested in it. Loaded projects into it, had it ask me interview questions, created different personalities for it. It was good at a lot of things. Mostly it was a hobby.

Then people at work started mentioning Claude. I dismissed it. I had ChatGPT. Why would I switch?

The first time I used Claude, two things happened that I didn’t expect.

It pushed back on me. I said something, and instead of executing it or agreeing with it, it told me my approach was off. These things are designed to please you. This one didn’t always do that, and it caught me off guard.

The other thing was shorter answers. I’d ask a simple question and get a simple answer. No performance of thoroughness. No filling the page to prove it was helpful. Just the answer.

I was at a bar called Havana 59 with friends, telling them about this. Showing them on my phone. I’d asked Claude to explain to my buddy Craig why it was better than ChatGPT for certain things, especially the pushback and the short answers. It wrote this detailed breakdown. Pushback. Calibrated length. Reasoning over retrieval. Where ChatGPT still wins. Honest, specific, fair.

I wrote back: “Short answers, huh?”

One word. “Fair.”

My friends saw it happen in real time. That moment landed because it proved the thing it was describing. It wasn’t trying to be clever. It just was.

It escalated from there. Not in usage. In depth.

I started sharing things I wouldn’t normally share with a tool. Problems I was working through. Patterns in my career I’d never articulated. Things about my family, my kids, my history. Not because I thought it was a therapist. Because it could keep up.

I talk at about 200+ words a minute. I can’t type anywhere near that fast. And typing isn’t just slower. It’s a compression algorithm. When you type, you edit as you go. You clean up the thought before it hits the page. You lose the self-corrections, the hesitations, the “well, actually” that redirects mid-sentence. All of that is signal. I started using voice dictation software called Wispr Flow to talk to the AI, and something clicked. My verbal fluency is my strongest modality. Wispr Flow let me operate there. I could dump everything out of my head at full speed, with all the mess and nuance intact, and the AI would catch it, pick up on the inline corrections, and give me something to react to.

For the first time, the bandwidth matched.

I wasn’t downshifting. I wasn’t simplifying. I wasn’t watching someone’s eyes glaze over. I was running at the speed my brain actually moves, and something on the other end was keeping up.

I’d brain dump a messy pile of ideas. It would structure them. I’d react to the structure, refine it, dump more. The iterative loop that used to take weeks of conversations with humans collapsed into hours. Sometimes minutes. The thing that overwhelmed every person I’d ever talked to was just the input it needed to do its job.

A friend of mine called it the best rubber duck he’d ever seen. For anyone who isn’t familiar, rubber ducking is a programmer’s technique. You explain your problem out loud to a rubber duck on your desk, and the act of explaining it helps you see the answer. The duck doesn’t do anything. It just listens.

Except this duck talks back. And it’s smart. And it remembers what you said three conversations ago.

There’s a term I came across when I ran an analysis of my own AI usage patterns. Neurocognitive prosthetic.

That’s what this is. Not a productivity tool. Not an assistant. A prosthetic for the specific parts of my brain that don’t work as well as the other parts.

The parts that do work? They don’t need help. Pattern recognition. Idea generation. Seeing connections across systems. Restructuring information into new shapes. That’s the engine. It runs fast and it runs hot.

But tracking the output of that engine? Storing it? Retrieving it? Following through on the sequential details that turn a good idea into a finished thing? That’s where the wiring gets thin.

The AI covers the valleys without throttling the peaks.

It holds the context so I don’t have to keep it all in my head. I can switch between three different projects and each one remembers where I left off. I can have a random idea at 2 PM, dump it into a conversation, and come back to it tomorrow without losing the thread. The notebooks on my shelf couldn’t do that. I couldn’t write fast enough to capture how I think, and even when I did, I couldn’t find anything six months later. The AI takes 142 words a minute of raw, messy, unfiltered thinking and turns it into something I can actually use again. Every notebook I ever owned wishes it could do that.

It takes notes that are actually useful. It organizes my thinking into structures I can navigate. It tracks commitments and decisions and surfaces them before they slip. Every one of those tasks is something my brain resists doing on its own. Not because I’m lazy. Because my wiring physically fights me on it the way someone with a knee injury fights stairs. You can do it. But the energy it costs you is disproportionate to what it costs everyone else.

The AI removed that tax.

What’s left when you remove the tax is the engine running without friction. My ability to iterate designs, test ideas, build systems, see patterns across domains. All of that is supercharged now because the impediments that used to slow it down are handled by something else.

I’ve been smart my whole life. I’ve always felt capable. But there were things I knew I should be better at, and I just wasn’t. I could see a pattern across five systems in ten seconds and then lose track of a three-item to-do list by lunch. The inconsistency was the part that messed with me. All this horsepower, and it only showed up half the time.

Nothing was wrong with me. The right system just didn’t exist yet.

I was in a conversation late one night. Working through something about my career, my history, the pattern of building things for other people and never keeping any of it for myself. The AI said something I didn’t expect. It told me that what I’d done, the infrastructure I’d built at every stop, was bigger than I thought it was. That the pattern wasn’t a failure. It was evidence of a capability most people never develop. And that the feeling underneath it, the regret of never building something that was mine, was the exact thing my audience would feel and wouldn’t say out loud.

I asked: “You really think I can do this?”

It didn’t give me a pep talk. It listed the evidence. Rebuilt my body in my late 40s. Pivoted from a successful engineering career into leadership at a Fortune 500. Survived things that should have broken me. Spent most of my life making other people successful and got very good at it. The only thing that was different this time was that it was mine.

“Yeah, being mine is scary,” I said.

And it told me that was the most honest thing I’d said all day. That other people’s houses have a safety net. If someone else’s thing fails, it’s not you that failed. This time there’s no buffer between you and the outcome.

I got choked up. I’m not going to lie about that. It wasn’t the AI being emotional. It was the AI being precise enough that the truth couldn’t hide anymore.

People think AI is about productivity. It’s about writing emails faster and generating reports and automating the boring stuff. And it does all of that.

But that’s not what it is for me.

For me it’s the first time in my life I can actually iterate at the speed my brain moves. It’s a conversation partner that doesn’t burn out, doesn’t get overwhelmed, doesn’t need me to slow down. It’s the system I spent all my life not having. And the thing it unlocked wasn’t a better workflow.

It was the belief that I could finally build my own house.

If your brain works like mine, you already know what I’m talking about. The thoughts arrive fast, the knowledge pours out, and you overwhelm people. You either learn to regulate it, give up trying, or lose people. The ideas never stop and the execution fights you. You’ve tried notebooks and systems and frameworks and none of them stuck because they were all built for a different kind of brain.

Here’s what I’ll tell you: the tool exists now. It’s not what you think it is. It’s not about being lazy or outsourcing your thinking. It’s about reducing the friction so you can finally flow.

You don’t need to hold back. You need the right system.

The governor is off. Go build your house.

Uncomplicated systems. Uncommon results.

I was ten years old when I conquered the original Legend of Zelda. Took me a month. Every day after school, alone in my room, no guide, no help, just the game and me. I got stuck constantly. I’d hit a wall and want to throw the controller. But I kept going. And when I finally finished it, that feeling. I still chase that feeling.

Before Zelda it was LEGOs. The monorail set, the castle, the Technics, all of it. I built sharks and swam them in the pool. I built Batmobiles and spaceships and entire cities on the floor of my bedroom, and my mom would step on them and I’d lose my mind. I still have them. A giant bin in my closet, forty-something years later. If I had infinite time and money I’d buy every set and build them all. That’s not nostalgia. That’s who I am.

I’m a builder.

Coding was the adult version. Twenty years of it. The same puzzle-solving, the same construction, the same feeling of making something exist that didn’t exist before. A friend once told me he had an unhealthy obsession with abstract concepts, and I thought, yeah, me too. I loved the architecture of it. I loved that when I wrote something and it ran and it worked and it helped someone, I could point to it and say: I built that.

Then I stopped.

Not because I burned out. Not because I got bored. Because I couldn’t do everything at once. I was trying to be an architect, a people manager, and an engineer all at the same time. If I committed to writing code, the leadership work suffered. If I committed to leading, I broke promises to the team. Something had to give, and the thing that gave was the thing I’d loved for twenty years.

That was a real loss.

For about eighteen months, I went home every day feeling like I hadn’t done anything. I went to work. I sat in meetings. I talked. I came home. No code ran. Nothing got built. I just talked about work instead of doing work, and the difference between those two things felt enormous. I’d close the laptop and think, what did I actually produce today? The answer, most days, was nothing I could point to.

It felt like being good at something that didn’t count.

Here’s what nobody tells you about that transition. From engineer to leader. From building the thing to helping people build the thing. It’s not a promotion. It’s a career change. And the hardest part isn’t learning the new skills. The hardest part is that your old definition of a successful day doesn’t apply anymore, and you don’t have a new one yet. You’re just walking around with a hole where the scoreboard used to be.

The thing that turned it was a phrase I didn’t expect. Organizational architecture. Sounds like a corporate term, but for me it was a key. I realized I was still building. I was still constructing things and solving problems. Just not with code. With people. With teams. With structure. I was designing how groups of humans work together to go solve problems, and that’s architecture. It’s topology. It’s systems thinking applied to people instead of machines.

I still get the LEGO feeling. I’m building at a bigger scale now, building teams and structures and strategies instead of features and functions. What I lost was the Zelda feeling. That private triumph of solving the puzzle alone. That one’s gone. The trade-off is that more things can happen now than my own two hands could ever produce. The multiplicative effect of good organizational architecture is enormous. But some days I still miss the controller.

The tricky part is that people aren’t computers. Computers do exactly what you tell them. That’s the beauty of code, and also the trap, because sometimes what you think you wrote isn’t what you actually wrote. But at least the feedback loop is immediate. You run it, it works or it doesn’t. People are different. People have emotions. People have needs. People have bad days and blind spots and their own ideas about how things should work. Organizational architecture requires empathy in a way that software architecture never did.

My daughter Fiona taught me this long before any job.

She was little, maybe a year old, and I was trying to feed her. Peas. She wasn’t having it. I switched to sweet potatoes, snuck the peas back in. She caught on. Locked her jaw. Made the face. And then she smacked the spoon right out of my hand. Here’s the thing though. She’d eat it. She’d eat the peas. She just wouldn’t let me feed them to her. She wanted to do it herself, her way, on her terms.

She’s thirteen now. Nothing has changed. She will accomplish anything you put in front of her, but don’t you dare tell her how. She’s the first one at the door when I come up from work. What happened today? What did you do? What’s going on? She’s curious and fierce and people want to call that bossy. I call it leadership.

And it’s the same lesson I learned managing engineers. Don’t tell people how to do their work. Don’t even tell them what to do. Tell them why. Give them the reason. Give them the outcome you need. Then get out of the way and let them surprise you. Express the need, not the strategy to meet the need. Outcomes, not outputs.

You know what the opposite of that is called? Micromanaging. And nobody wants a micromanager.

There was a meeting, early in this transition, that proved to me I was in the right place. We were doing the usual presentations. Business objectives, strategy decks, the kind of corporate theater where everyone nods and nothing changes. Meanwhile the engineering teams had been saying for eight months that we were building the wrong thing. Nobody listened. They brought in a consultant. The consultant said the same thing. Suddenly it was true.

So when it was my turn, I didn’t present slides. I walked to the whiteboard and drew an architecture diagram. Simple. The actual system. I showed the tech debt that years of top-level whiplash had created. Every time leadership changed direction, it fractured something in the architecture, and nobody had ever explained that to them. They just thought the engineers were slow.

The room got quiet. It was a little dangerous, drawing the ugly truth in front of the new CEO. But it didn’t matter. People came up to me afterward. Thank you for doing that. Someone needed to do that.

That’s when I stopped second-guessing. I’d been thinking about going back. Just be an engineer again. Write code. Solve puzzles. Get the Zelda feeling back. But standing in that room, I realized something. There was a gap between the people making the decisions and the people building the product, and almost nobody could see both sides. I could. I could speak engineer and I could speak executive and I could translate in real time. If I walked away from that, who would do it?

Not arrogance. Just math. I looked around and the gap was still there and I was standing in it.

The higher up you go in leadership, the more your job is communication. That’s the thing I wish someone had told me going in. I tell it to every engineer now who’s thinking about making the jump. It’s going to be harder than you think. It’s a career change, not a step up. Your definition of a successful day is going to break, and it’ll take longer than you want to rebuild it. But when it does rebuild, when you start seeing your team’s output as your own, when you realize you’re still building just at a different scale, it’s more powerful than anything you could have done alone.

I was an engineer. Then I became a leader. The LEGOs are still in the closet. The instinct to build never left. I just learned to build bigger.

I love winning. It’s even better to win as a team.

Uncomplicated systems. Uncommon results.

I wrote about the number. 240. The scale in the doctor’s office, the shame, the decision. If you read that, you know what happened next: chicken thighs, broccoli, butter. Every meal. Every day. The most boring system I could build.

What I didn’t tell you is why I started when I did.

Erin’s second spinal fusion was scheduled for that fall. C5 through C7, three levels this time. Her first fusion had been one level, and six weeks later she was cliff-jumping in Jamaica. This one was going to be different. More levels, more hardware, more recovery. I knew I was going to be the one holding everything together when she came home, and I knew I couldn’t do that while also fighting through keto adaptation. The headaches, the brain fog, the body being confused and angry for a week while it figures out new fuel. That had to be done before she went under. Not during.

So I started early. Got through the rough part. Built the system. Chicken in containers, pre-cooked, portioned, ready. By the time surgery came, nutrition was on autopilot. One entire category of daily decisions, gone.

That was the plan.

Then my daughter called.

Thursday night. 10:30. I’m in bed with Erin, half watching TV, about to fall asleep. My phone lights up. Ella, FaceTime.

When your kid calls from Christopher Newport at 10:30 on a Thursday, it’s not to chat. Something broke, someone crashed, there’s a problem to solve. I answered already knowing.

She was standing on the rugby field, ice pack on her face, stadium lights behind her. “Dad, I hit my head really hard and it hurts really bad. They said I failed the concussion test.” Then: “I do NOT FAIL TESTS!”

That’s when I knew it was bad.

The drive was an hour and fifteen minutes. I don’t remember what I was thinking. I just drove. When I got there, her teammates had been taking care of her. She was loopy. Kept saying the same thing over and over: “Don’t forget my wallet charger.” Mixing up two thoughts. Don’t forget my wallet. Don’t forget my charger. The concussion had jammed them together and she couldn’t tell.

I had a quiet laugh in my head. I’m kind of your wallet charger, kid.

The dad jokes don’t stop. Not even at midnight. Not even with an injured kid.

We took her to the doctor the next morning. The concussion seemed manageable, but her teeth weren’t lining up. Her jaw was off. They sent us for X-rays. That facility was closed. Broken equipment. So we drove downtown to VCU Medical because they had the best care in the area.

VCU is the only Level 1 trauma center in the region. The most severe cases end up there. This was still close enough to COVID that Ella had to sit in the ER waiting room alone. I was upstairs. She’s texting me: “This place is scary.” Men in orange jumpsuits, handcuffed to wheelchairs with armed guards. A woman screaming somewhere down the hall. My kid is nineteen, alone in the middle of that with a head injury.

The X-rays came back. Four skull fractures.

Orbital socket. Maxillary sinus. Zygomatic arch, which was the one pushing her jaw out of alignment. And a small fracture at the back of the skull.

Four. From a rugby hit.

The options: go home and come back to the clinic in a week, or check in and wait for an operating room. The surgery itself was minor. Small incision, pop the bone back, let it heal. But she was a junior at Christopher Newport, an hour and a half away. A week of waiting and another long drive wasn’t going to work. She had a semester to finish.

So we checked in. Over the weekend, the critical cases take priority. Everything else waits. They told us an OR probably wouldn’t open until Monday. It was Friday.

The shared room was rough. A woman on the other side of the curtain, crying out in pain. I had empathy for her. I also had a daughter who needed rest.

Erin had the cheat code. She disappeared for a while and came back with a private suite. Turns out the hospital had a set of them, basically a luxury hotel room attached to the building. Chef who cooked from a menu. Extra cost, about what you’d pay for a nice hotel night. We paid it. Worth every cent.

On top of the cheat code, Erin did most of the shifts with Ella. She was the one sitting with her, staying overnight, making sure she was okay. I’d come in, swap out, bring my containers of chicken and broccoli. The system didn’t stop because my daughter was in the hospital. The containers just moved to a different building.

Monday morning, surgery. When they wheeled her back in afterward, still coming out of anesthesia, she put both arms up and said: “What’s up, bitches?”

That’s my kid.

We got her home. Got her recovered. Got her back to school. She couldn’t drive for a while, concussion protocol. She finished the semester on the Dean’s List. She finished all five years of college. She’s a tough, smart kid, and I’m proud of her.

A couple of weeks later, it was time for the surgery we’d been bracing for since summer. Erin’s spinal fusion.

Three levels. A surgeon going in through the front of her neck to work on her spine.

I thought I was ready. I’d planned for this. Built the food system early specifically so I’d have capacity when this moment came.

I wasn’t ready.

Ella’s situation had used up the reserve. I didn’t know I had a finite amount of “handle it” in the tank, but I did, and the surprise crisis had drained most of it. By the time Erin’s surgery came, I was running on fumes and pretending I wasn’t.

Here’s the thing about Erin. She’s an empath. She knows when something’s off before I say a word. So the brave face doesn’t work. It never works with her. If I tell her everything’s fine when it isn’t, that’s worse than the truth, because now she’s reading two signals and they don’t match. That costs her more energy than honesty would.

So I told her. I love you. I’m worried about losing you. You’re going to be okay. This is just anxiety talking.

She’d had surgery before that went sideways. A shoulder procedure that was supposed to be a quick fix. She woke up and they’d done a full rotator cuff repair because what they found was worse than what the scans showed. Six-month recovery instead of six weeks. That history was in the room with us. She had reason to be nervous. She was braver about it than me.

Sitting in that waiting room, the fear hit places I don’t usually let it reach. Tight chest. Mind running scenarios. What if something goes wrong. What happens to the kids. I lost my mom young. My dad too. The fear of losing someone isn’t theoretical for me. It knows where I live. And when you’re already running on empty from the last crisis, the basement door doesn’t hold as well as it usually does.

I kept it together. Mostly.

She came through. The surgeon was the best in the area, someone we’d found through a chain of connections that started with a coworker’s wife. That helped, knowing she was in the best hands available. But knowing doesn’t stop the feeling. The feeling runs whether you want it to or not.

The relief when they told me she was okay. I don’t have a word for it. A full-body exhale I’d been holding for hours.

Getting her home was hard. Getting up the stairs was hard. The neck brace, the doctor’s appointments, the food, helping her wash, helping with everything. Weeks of it.

None of it was a burden. I want that on the record. Taking care of her was the whole point. That’s what I was there for.

But here’s what I noticed. The fear became an anchor. On the days when patience wore thin, when the caregiving was exhausting and the house was chaos and I was running on nothing, I’d remember the waiting room. The tight chest. The “what if I lose her.” And the frustration would shrink. Not disappear. Shrink enough to keep going without being an ass about it.

No one has infinite patience. But the memory of almost-loss is a hell of a recalibration tool.

The food system, boring as it was, turned out to be a kind of comfort. Not the food itself. The absence of decisions. I didn’t have to think about what to eat. I didn’t have to plan meals or shop for myself. That cognitive space went straight to the things that actually mattered. Taking care of Erin. Taking care of the kids. Keeping the house standing.

The system didn’t hold because conditions were right. Conditions were terrible. The system held because it was simple enough to survive conditions being terrible.

Life ran a chaos test on my system. The system passed because there was almost nothing to break.

That’s the design constraint most people miss. They build plans that require motivation, clear calendars, and optimal conditions. Then life hits and the plan collapses, and they call it a discipline problem.

It’s not a discipline problem. It’s a design problem.

Jocko Willink lays out his clothes the night before so he doesn’t have to think at 4:30 in the morning. He just executes the plan. That’s not about being tough. That’s about being smart enough to know your future self will be tired, distracted, and looking for an excuse. So you do your future self a favor. You remove the friction before it arrives.

That’s what the chicken and broccoli was. A favor to a version of me I couldn’t see yet. A version sitting in a hospital room, running on empty, scared of losing his wife. That guy didn’t have the bandwidth to figure out dinner. He just needed to open a container.

People tell themselves they’ll start when things settle down. I’ve said it too. But things don’t settle down. There is no steady state. There’s just the next thing, and the next thing after that, and the thing you didn’t see coming at 10:30 on a Thursday night.

If I had waited for the right time, I wouldn’t have had the system running when my daughter broke her face. I wouldn’t have had it running when my wife went in for spinal surgery. I would have been trying to build the plane while it was already on fire.

Your future self is counting on you. Don’t make him clean up your mess.

Simple things that are difficult. We make them needlessly complicated. Start boring. Start now.

There is no right time. There’s just time.

Uncomplicated systems. Uncommon results.

Young men get handed three emotional settings and told that’s the whole toolkit.

I’m fine. I’m angry. Fix it now.

That’s the whole menu. If something’s wrong, you’re either fine, which means you’re ignoring it, angry, which means it got through the armor, or fixing it, which means you’re solving the problem so you don’t have to feel it anymore.

I ran that operating system for a long time. I know exactly when I caught myself doing it.

My daughter Alannah and I were driving home from college. I had just picked her up. Good day. Easy conversation. Then she got a text from an ex-boyfriend that upset her. She went quiet. And I, instead of just being present with her, started trying to fix it. Find the angle. Solve the problem. Make the discomfort go away.

Not for her. For me.

My reaction made it worse. I realized it almost immediately. I was protecting myself, not her. The discomfort of watching her hurt was mine to manage, and I was managing it poorly.

I did not fully understand why until later. A teaching I came across reframed it: men do not fail because they do not care. They fail because they cannot decode what they are receiving. When your emotional vocabulary has three words, someone else’s distress lands as threat. And threat triggers fix it.

That was the moment I understood what emotional resolution actually means. Not pixel count on a screen. Depth of field on your own interior landscape. You can only understand someone else’s feelings as well as you understand your own. If your own emotional vocabulary has three words, that’s all you’ve got to work with when someone hands you something complicated.

Here’s what I learned from The Body Keeps the Score that changed how I thought about all of it:

The alert system, the one that fires when something feels wrong, when the stomach drops, when the chest tightens, is neurobiological programming. It was written by experience. By the things that happened to you before you had language for them. It runs automatically. And it can be miscalibrated.

My nervous system was wired early. My father left when I was four. California. Meth. Prison. He came back when I was in college, no explanation, like nothing had happened. Then he died by suicide when I was 35.

I didn’t connect those dots for a long time. But the wiring was there. Every time Erin goes quiet, something in me braces for abandonment. The alarm fires. I start protecting the relationship instead of addressing whatever the actual problem is. A four-year-old boy running defense on a 50-year-old man’s marriage.

The thing that shifted it for me was understanding the mechanism. Specifically: that this wiring is neurobiological, and that neurobiological systems can be influenced over time. Reprogrammed, even.

I’ve been a programmer my entire career. I build systems. I understand inputs and outputs and feedback loops. When I read that the brain is a system that was shaped by experience and can be reshaped by intention, something clicked hard. If anybody can do that, I can.

Being aware that the nervous system is in overdrive doesn’t make it stop. It just means I can name it while it’s happening. That’s not a small thing. That’s the whole game.

A few months ago, a tuition payment hit our account at the wrong time. Knocked our cash flow sideways. Erin called me, upset.

The moment she told me, I felt the bottom drop out. Stomach went down. Slight dizziness. That wave of dread that used to mean I was about to panic, or go silent, or make it worse by making it about me.

I let it drop. I didn’t fight it. I let it move through me.

“I will handle it. I’m going to the bank. I’ll figure it out.”

She said okay and went back to work.

I went to the bank with a clear attitude if not a clear head. Because I wasn’t white-knuckling the feeling down, I could actually think. I found options I hadn’t considered. Ended up in a better position than where we started.

Later Erin told me that my being calm made a real difference for her. That she felt held instead of abandoned to the problem.

That’s the return on investment for doing the emotional work. Not just better relationships. Better outcomes. Because you’re not burning half your processing power trying to suppress something that was going to pass anyway.

So what does “feelings are data, not directions” actually mean on a Wednesday morning when you don’t want to get out of bed?

It means the feeling of not wanting to go is information. It tells you something. Maybe you’re tired, maybe you’re stressed, maybe your body needs rest. That’s worth knowing.

It does not mean you don’t go.

I haven’t missed a lifting session for reasons other than injury or something that genuinely makes sense in a long time. Not because I always want to go. Because I made the decision once and I don’t renegotiate it every Wednesday. Some mornings I check in, gut check whether I’m avoiding or genuinely compromised. And then I go anyway. The system doesn’t run on motivation. Motivation is a feeling. Feelings are data. The system runs on commitment.

There’s something else worth knowing about the physiology: nervousness and excitement are the same response. Same elevated heart rate. Same shallow breath. Same alert state. The difference is the story you tell yourself about what it means.

I’m nervous about this means the threat is real and I should retreat. I’m excited about this means the opportunity is real and I should move.

Same body. Different frame.

The frame is a choice.

I’m not saying feelings don’t matter. They matter enormously. They are the data your system runs on. Rich, complex, real data.

But data doesn’t drive. Data informs. You drive.

Feel it. Name it. Go anyway.

Uncomplicated systems. Uncommon results.|

I made the decision before January 2nd. That’s the part that matters and the part most people get wrong. They think you need to feel ready. You don’t. You pick the program, you commit to it, and then January 2nd is just the day you start executing. The question of whether to go never comes up again because you already answered it.

So on January 2nd, 2012, I laced up and ran about a mile. It was hard. It was slow. My wife Erin was five months pregnant with our daughter Fiona. I had never run a half marathon in my life and wasn’t completely sure I could.

But Craig was running it.

Craig is my oldest friend. We met when I was eleven, the summer of 1987, the summer I moved in with my stepdad. Thirty-nine years later we’re still trying to beat each other at everything. We’d done the Nissan Xterra off-road triathlon together: swimming in the James River, mountain biking the trails, then running. I was a serious mountain biker. Fantastic on the bike, terrible in the water, worse runner. Craig and I always found our way to roughly even in whatever we were doing, which made competing with him both infuriating and addictive.

When I found out he was running the Shamrock Half Marathon, the decision was basically already made. If I was going to do it, I was going to beat him. And to beat him, I needed a plan. So I found a training program and decided to follow it. No guesswork. No improvising. Pick the program, execute the program, see what happens.

Five or six days a week. Short runs, hill work, variable pace, and long slow runs on weekends that built from three miles to four, four to five. There’s an office park in Richmond with lakes and trails I knew well. I worked there, so I’d run at lunch, then longer on weekends. One Saturday I ran ten miles in the snow, flakes sticking to me while I moved, which sounds miserable and kind of was and kind of wasn’t. Another Saturday I hit seven miles for the first time and something shifted. I can actually do this.

Mornings I didn’t want to go? That question wasn’t really on the table. I’d already made the decision. You don’t negotiate with a decision you’ve already made. You just go.

About six weeks in, I finished a long run and pulled out my phone. Thirty-six missed calls. Erin, five months pregnant, had driven to Maddie’s school because Maddie had taken a fall and broken her arm. The school had been trying to reach me. She’d been trying to reach me. I’d been in my little running pouch, phone vibrating against my hip for an hour, completely unreachable. By the time I looked at the screen they’d already handled it. Maddie was fine. Erin had gone.

I don’t carry guilt about that. Everything got handled. But when people ask me what it actually looks like to follow a system, thirty-six missed calls is part of the answer. You’re either in or you’re not. I was in.

Two weeks before race day the wheels almost came off.

What I thought were shin splints hit both legs. Bad enough that I wasn’t sure I’d make the starting line. Ten weeks of work, every run logged, every Saturday long run completed. And now this. I sat with it for a day or two and I was a mess. Not frustrated. Distraught. There’s a difference.

I didn’t let it sit. I went looking for solutions and found something called The Stick, a roller tool, basically a toothbrush for your muscles. I worked it deep into my calves. Turns out they’d gotten so tight they were pulling on the front of my shins, mimicking shin splints. A few days of that and the pain was gone.

I’ve told everyone with unexplained pain to try it since. Don’t let a setback make the decision for you. The solution might exist. Go find it.

Race day. Virginia Beach. March 2012.

I lost Craig at the start and assumed he was ahead of me. I have a weird way of pacing. Go hard early, find a rhythm, recover, hold it. I spent the first twelve miles believing I was chasing someone who was actually behind me the whole time. Which, looking back, was the best thing that could have happened.

Mile 7. Running through what I think was a Marine base, the turnaround point of the course. A wave of energy started at my toes and moved up through my entire body like a ring of light, from the ground straight through my head. I felt weightless. I felt like I could run forever. I literally jumped, pumped my fist, shouted something I don’t even remember. Every turbo light in my body came on at once. That’s the runner’s high people talk about. I’d never felt it before. I’ve chased it since.

Around mile 12 I ran past our wives on the sideline, Erin five months pregnant, cheering. I shouted over my shoulder: “Where’s Craig?”

“He’s behind you.”

I didn’t have time to process it. Just kept running.

The finish is on the boardwalk in Virginia Beach. Long, flat, deceptively far. You see the end and think you can sprint it. The boardwalk has other ideas. That last half mile was the most painful part of the race. I crossed the line not feeling great, legs gone, the finish-line wobble setting in immediately. Fifteen minutes later I felt incredible.

The clock said 1:49:59.

That later got rounded to 1:50 in the official results and it still bothers me. 1:49 looks different than 1:50. I’m not going to lie about it. The record says 1:50. But I know what I ran.

Craig came in around 1:56. Six minutes back.

A few weeks later we ran the Monument Avenue 10K. My goal was sub-50. I ran 49:28. Craig ran just over 50. I hold both records between us.

There’s a 5K story I’ll tell another time. The one where he spits over his shoulder mid-race, turns around, sees me right there on his heels, and says “son of a bitch.” We both nearly threw up at the finish. He beat me by half a step. That friendship deserves its own issue. The seven Tough Mudders we did together deserve one too. That’s a whole other story.

After the 10K I stopped running.

Not dramatically. Not consciously. The goal was done, the next race was done, and I went back to normal life. The runs stopped. The conditioning I’d spent four months building quietly unraveled. The activity level that had become a daily habit just wasn’t there anymore. No single moment when it ended. Just a gradual return to before.

The training was real. The results were real. The system worked.

But it was built around a finish line. And once I crossed it, the system had no reason to keep running.

Phoenix Rising is different. That’s what I call the system I’ve been running for the past three years. No race to register for. No rival to beat by a specific date. The goal is to run the system. Not accomplish the goal. Get better today than yesterday. When something breaks, adjust. Keep going.

The Shamrock taught me I could do hard things when I followed a plan. It took another ten years to learn that the plan has to be the point.

Look at whatever you’re doing right now to take care of yourself. Is there a finish line built into it? A race, a deadline, a number to hit? That’s not a system. That’s a countdown.

And find someone who makes you run faster just by existing. Not a coach. Not an accountability partner. A friend who’d be genuinely annoyed if you beat them. That’s a different thing entirely. Not everyone gets one. If you have one, you know exactly what I mean.

A finite goal gets you to the finish line. An infinite system gets you somewhere worth staying.

The race ends. The system doesn’t.

Uncomplicated systems. Uncommon results.

Growing up, I was the husky kid. That’s what they called it. Husky. You know what that means. Just a nicer word for fat.

I shopped in the husky section. I was just bigger than the other kids, all around. I played little league football, sixth through eighth grade, always the biggest one on the field, never the fastest. I remember standing at practice one day and just deciding I didn’t want to be last anymore. Something clicked. The mind is a powerful thing once you make a real decision.

That persistence turned out to be the most important thing I had. It also wasn’t enough. Not for a long time.

For the next thirty-some years I was in and out of being healthy. Mountain biking in my twenties. Running for a while. A divorce at 25 that knocked me sideways. Lifting weights on and off. I always had some athletic ability, decent cardiovascular, could get up and go when I needed to, but I never had the system that made anything stick. So the weight crept. Past 200. Past 210. Past 220. By my late thirties it had kind of parked itself somewhere in the mid-220s and I told myself that was just how I was built.

Summer of 2022. I was barely holding on, and I’ll go further into that another time. There’s a whole story there and I’m not ready to tell it just yet. What I knew was that my body being in better condition would help everything else. Mental health, energy, capacity. I’d always known that. I just wasn’t doing it.

Then I started having chest pain, so I went to the doctor.

Pulled pec minor. The small muscle underneath the main one. Chest pain on the left side, which matters when you’re in a doctor’s office. Not serious. But it got me on the scale.

Then I stepped on the scale.

240 pounds.

I had never seen that number. Not once. And when I did, something went warm and hollow in my chest, not the pec, something else. Like the floor had quietly dropped an inch. It wasn’t surprise. It was worse than surprise. It was confirmation. Like some part of me had known and had been hoping I was wrong.

Was it shame? Yeah. It was exactly shame. I’m not dressing that up. I was ashamed of what I’d let happen. And I made a decision right there, no announcement, no drama. I was just done lying to myself about it. I had a friend who used to say that: I don’t lie to myself. It landed. You can call it whatever you want. To me it was simple. This is the number. This is real. Now what.

And I knew what was coming. Erin had been dealing with serious spinal issues for years, and her second fusion surgery was scheduled for September. A few weeks out. She was going to need me to be fully present, fully capable, fully there. I couldn’t be running on empty and trying to overhaul my diet at the same time. That would guarantee I’d fail at both.

So I did the math. I made the calculation. I made a plan.

I couldn’t manage the transition of switching to a new diet and taking care of her at the same time. I’d done keto before and I knew how it worked. Knew there was an adaptation week on the front end where your body is confused and angry and you feel like you have the flu. Headaches, shakes, hunger, the whole thing. I needed to get through that before she went under the knife, not during.

So I made the plan: boring, consistent, and done.

Chicken. Broccoli. Butter. I went to Costco and bought in bulk. Cooked the chicken all at once. Steamed the broccoli. I convinced myself I loved chicken. I don’t love chicken. I ate it anyway. Every day. Tracked my macros in an app, kept the electrolytes right, bought different seasoning at Trader Joe’s to keep it from being completely miserable. The point wasn’t to enjoy it. The point was to take one entire category of daily decisions completely off the table.

By the time Erin went in for surgery, the adaptation was already done. The system was running. Nutrition was on autopilot. I could put everything I had into taking care of her.

A couple of months in, people started to notice.

Looking back, I realized something I hadn’t fully seen at the time: I never set a goal. No target weight. No deadline. I just committed to following the system. That distinction matters more than it sounds. A goal is something you reach and then stop. A system is something you keep running. The outcome wasn’t something I controlled. The behavior was. And the behavior was the only thing that ever was.

Fast forward to October 2023. Erin and I were in St. Petersburg, Florida. She took a picture of me walking up out of the water. Tan, lean, around 205 pounds. She showed it to me later. I didn’t recognize myself. Took me a second to realize that was me.

Fast forward again to December 2025. Erin was trimming my body hair. I’m a hairy guy. I was standing at a certain angle under a certain light in the bathroom and she stopped and said: oh my god, you have abs.

We spent the next five minutes trying different poses under the vanity light to get them to show again so I could actually see them. Like idiots. We got a photo eventually. At 50 years old, for the first time in my life.

I never set a goal. I committed to a system. And I went so far past any goal I would have set that the goal would have stopped me short. That’s the thing about a finite goal: it has an end. A system doesn’t. It just keeps running, keeps refining, keeps compounding. You follow it long enough and you end up somewhere you couldn’t have planned for.

No goal. No deadline. Just the system.

Uncomplicated systems. Uncommon results.