I delegated the knowing.

28 April 2026

There is a file at the root of my project called CLAUDE.md. Every AI session reads it before doing anything else. It contains domain knowledge, architectural decisions that are not to be revisited, critical business rules, and the account-specific quirks of every data source the app ingests.

It is, in a real sense, the institutional memory of the project.

I did not write a line of it.

At the start, I asked Claude to research and scaffold a set of best practice documentation, including a conventions file that would be read at session start. It produced a reasonable first version. I started building.

Over the next two months the file changed in almost every working session. The git history shows it clearly. Commit after commit. Often co-authored. Often tagged docs alongside feat or fix. I was not sitting down to document. I was building, hitting edges, and asking Claude to keep things current.

Some of what accumulated is obvious. Architectural decisions. Phase completion records. Known bugs and their fixes, written in the voice of someone who has debugged them once and has no intention of debugging them again.

Some of it is stranger.

There is a section called Domain Knowledge. It contains family dates of birth because the app calculates capital gains tax and age affects the numbers. It contains the expiry details of a particular tax residency regime I am under. It contains quirks of common spreadsheet exports from investment platforms. One labels itself .xlsx but is actually a .csv. Another encodes trade direction through credit and debit columns rather than an explicit field.

Every one of those lines is a scar. Something broke, or nearly broke, and the knowledge got encoded.

I did not put most of it there deliberately. At some point I got tired of repeating the same context session after session. I said something like "remember this for next time." I did not specify how. The file grew.

What I did not notice until recently is that I stopped reading the changes.

The feedback loop had become good enough, for long enough, that checking felt unnecessary. The work was going well. Sessions started coherently. The system behaved as if it understood.

I trusted the file the way you eventually trust a colleague who has been reliable for long enough that auditing their output starts to feel like poor judgement rather than diligence.

That is the moment that matters.

Because what I delegated was not just the work.

It was not even the correctness of the work.

It was the knowing.

If I opened that file right now and read it properly, I would be reading it as an outsider. Not because I cannot understand it, but because I no longer track it. I no longer know what is in it without looking.

The system runs. The outputs make sense. The loop holds.

And somewhere along the way, responsibility for what is true inside the system moved slightly out of my direct awareness.

There is a version of this story that is about AI and documentation practice. That version is not very interesting.

The more interesting version is about what happens in any working relationship over time. Trust builds. Feedback loops stabilise. Attention shifts.

I have built systems with people for thirty years. I know what it looks like when a team starts assuming the other person is handling something. I know the failure mode where responsibility becomes distributed and everyone believes someone else is reading the important file.

I did not expect to find that pattern here, working alone.

But the mechanism is the same.

The system works. The feedback loop holds. And slowly, quietly, attention moves elsewhere.

That movement is easy to miss.

Until you realise you are no longer the one who knows.