Colearning

I ran a long project across Claude and Claude Code a while back, the kind that spans days and a dozen sessions. At the end, instead of just shipping and closing the tabs, the assistant and I did something small that turned out to matter more than the project itself: we wrote down what we had learned. What worked. What broke. The thing we figured out on attempt four that we would have killed to know on attempt one. A single page of hard-won notes. Next session, that page went in first, and the fresh session started smart, standing on everything the last one had bled for.

Here is the strange part. The model did not remember any of it. Not one word. The work remembered.

Everyone is chasing self-learning right now, the dream of an AI that remembers you, adapts to you, gets better at being yours over time. It is real, it is partly here, and more is coming. But look at what actually happened in that loop, because it is not the thing everyone is waiting for. The model’s weights never changed. In the machine-learning sense it learned nothing at all. What learned was the system: me, the assistant, and a document that got sharper every pass. And I have come to think that is not the consolation prize. It might be the main event.

If you have seen Memento, you already understand the shape of this. The guy can’t form new memories, so he writes everything down, on photographs, on receipts, tattooed on his own skin, and every morning he rebuilds himself from his notes. The model is him. Every session it wakes up brilliant and blank, no memory of you or the last six hours, and the only continuity that survives is whatever got written down outside it. The difference, and it’s the whole difference, is that you get to write the notes, you get to read them, and you can cross out the ones that turned out wrong.

Because if you are actually doing this human-in-the-loop thing, there are not one or two things learning in the room. There are three. The AI can learn, weights and memory, which is the vendor’s department and a black box to you. You can learn, you get better at the tool and the craft. And then there is the third one, the one almost nobody is tending: the pairing itself, the specific way you and the machine do this specific kind of work. Now notice which of the three you actually control. The AI’s learning you can’t see and don’t own. Your own learning is real but slow, and it walks out the door when you do. The system’s learning is the only one that is legible, portable, and yours. We pour our attention into the two we control least, and leave the one we own completely to chance.

That third one deserves a name, so here it is: colearning. Not the AI learning you, not you mastering the AI, but the two of you building a shared memory on purpose. And the reason it beats waiting for the model to remember you is that you can hold it in your hand. The weights shifting inside the model are invisible and locked to that one model. The doc on your drive you can read, so you know exactly what it thinks it learned. You can correct it, so a wrong lesson gets a line struck through it. You can carry it, so it works in the next model, the next tool, the next vendor who hasn’t shipped yet. When the model changes next quarter, and it will, the black box resets to zero and starts over without you. Your system’s memory walks across intact.

The coding project was just the clearest case. The move works on anything you do more than once. The weekly report, the client onboarding, the hiring loop, the monthly close. Any recurring thing can be wired for it: do the work, notice what you learned, write it where the next run will see it. It does not have to be real machine learning to compound. It only has to be written down and picked back up.

One caution, because a loop is worth exactly what you feed it. Garbage notes compound into confident garbage. The retro has to say what actually broke, the real version and not the flattering one, or the doc just launders last time’s mistakes into next time’s instructions with a straight face and more authority. The third learner only learns if the feedback you give it is true, which means a carry-forward doc is really a place to be honest with yourself in writing. That is harder than it sounds and worth more than it looks.

The whole practice fits in a sentence. Do the work, then before you close it out, spend ten minutes asking what this run taught that the next run should start already knowing, and write it somewhere the next session will find it. That is the entire machine. Every project ends by making the next one smarter. I keep a prompt for exactly this, the Distillation, that runs at the end of a session and drafts the carry-forward doc from what actually happened, and it lives on the other site. But the habit is the thing. The prompt just lowers the friction on it.

The first doc is thin, almost embarrassing, three bullet points and a shrug. The fifth is an operating manual for how you and the tool do this one particular thing, and no vendor could have written it, because it is yours, specific, earned in your exact conditions with your exact constraints. You stop reintroducing yourself every session and start each one already briefed. The gap between the person who does this and the person re-explaining their whole setup from scratch every single time is not talent, and it is not better access. It is a doc.

Right now, keeping a notes file for how you work with AI looks like over-organization, the move of someone with too much time on their hands. That is the fringe stage talking, and it does not last. The window is open and it is wide, because while everyone else waits for the model to finally learn them, you can build the thing that learns today, and it compounds every week they keep waiting. There is a question coming, as ordinary as “did you save it” became: what does your carry-forward doc say? And the quiet reward is already sitting there on the far side of the first one. You open a fresh session, drop in the page, and watch it start exactly where the last one got smart. You did not get a better model. You built a better system, and you can read every line of how.

The New Typing continues. The series lives at drjeffwurfel.com/writing.