Knowledge That Survives the Session
Session knowledge evaporates when no one curates it – why teams should treat their AI working knowledge like code, and why it’s not the model that gets smarter but the organization that learns.
Tuesday morning, the third session this week. I’m typing the same explanation for the third time. Our error model distinguishes between expected and unexpected errors; expected errors come back as values, and there should be no try/catch cascades around service calls. The session before knew that. It had understood it, applied it and even cleanly solved an edge case I wouldn’t have thought of myself. Now I’m sitting in a new session again without that explanation and writing it once more, in different words, a bit more impatiently than last time.
Part 9 of the series “From Session to System” – the opening post is here.
This is session amnesia as an everyday experience. Not as a theoretical problem of context windows and token budgets, but as the quiet annoyance of working with a tool that hears from me for the first time every morning. The vendors are working on it. As of August 2026, there are different storage mechanisms for this: Anthropic’s Memory Tool lets agents store information outside the immediate context window in files and load it again later; Claude Code provides project instructions through hierarchical CLAUDE.md files and personal notes through Auto Memory, both across sessions. Personal Auto Memory starts with the individual person; shared, jointly maintained CLAUDE.md files are a different matter. None of these features solves the variant of the problem that really occupies me on its own.
Because the team variant is worse. On Wednesday, a colleague tells me he explained our error model to “his” session. I ask how. He explained it differently than I did. Not wrong – differently. Different terms, different examples, one nuance I would leave out, one I’m missing. A third colleague didn’t explain it at all, because he didn’t know there was anything to explain; his session built try/catch cascades, and the pull request looked like it. Four people, four private explanations of the same convention, four slightly different results. This is exactly the variance problem I described in “My Success Cannot Be Copied” – except that here it’s not about ways of working but about knowledge. Each of us feeds our sessions with our own oral tradition of what the team should actually know together. Personal Auto Memory doesn’t change that: it remembers my version of the explanation, not ours. Versioned, jointly maintained CLAUDE.md files would be the place for a shared version – but only if the team curates them deliberately.
So the core question of this episode is: how does session knowledge become team knowledge – and eventually company knowledge? How does what comes out of a good session get into the next session of another person?
Two kinds of knowledge#
To talk about this sensibly, a distinction helps me that I carried around only implicitly for a long time: curated knowledge and emergent knowledge.
Curated knowledge is deliberately distilled. Someone sat down and put an experience or a decision into words, someone else proofread it, and the result sits in a place where it gets found. Architecture decisions in ADRs, conventions in a CLAUDE.md or AGENTS.md, a runbook for the deployment edge case that strikes every six months. Curated knowledge is expensive – it costs the time of one person who writes it down and of a second who reviews it. In return, it is addressable: I can point to it, link to it, hand it to a session.
Emergent knowledge comes about on the side. In Tuesday’s session, half a dozen small insights came up: that our test setup has a quirk when mocking the message broker, that a certain library in version 4 has a different default behavior than our docs say, that my prompt framing for refactorings works better when I put the target picture before the constraints. I wrote none of it down. The session ended, and with it everything evaporated that didn’t solidify into code or a commit message. Emergent knowledge is cheap to create – and not reliably available to later sessions unless it was saved.
The gap between the two is the real problem. Teams today produce more emergent knowledge in AI sessions than ever before – every session is a small lab where someone tries things out, phrases things, fails, readjusts. And almost none of it survives. What survives is the code. But the code contains only the result, not the reasoning, not the discarded wrong turn, not the phrasing that untied the knot.
Treating knowledge like code#
A team’s distilled working knowledge deserves the same treatment as its code. Versioned. Reviewed. With ownership. And with a lifecycle that includes dying. That is where this episode is headed.
At first that sounds trivial – Docs as Code means treating documentation with the same versioned ways of working as source code, including review and automated checks. But in the AI context, each of these four properties gets a new edge:
- Versioned, because the knowledge is now consumed by machines. When an instruction file changes, the behavior of the sessions that load it can change. Such changes affect the behavior of the system – and behavior changes belong in the history, with a diff and a date and the option to go back.
- Reviewed, because a wrong convention now misleads not only human readers but also several sessions. A person reading a bad wiki article often notices that something is off. A session can’t recognize the error and will apply the wrong convention, as I described in “Clean Grounding II: Grounding Answers”: whatever is in the context becomes the session’s reality, whether it’s true or not.
- With ownership, because no one maintains knowledge that belongs to no one. Every convention file, every runbook needs a person who feels responsible. That’s not bureaucracy – it’s the simple answer to the question “Whom do I ask whether this still applies?”
- With a lifecycle, because outdated knowledge is worse than none. This is the point I see underestimated most often. A session without a matching source can guess or ask; a session with outdated grounding guesses with a citation. It quotes the convention from 2024 that we dropped in the fall, and sounds so well-supported that no one checks.
The last point deserves its own paragraph because it is counterintuitive. We are trained to see documentation as “better than nothing.” In the AI context, that’s no longer true. Wrong, old, half-baked knowledge in a session’s grounding is actively harmful, because it turns the model’s uncertainty into false confidence. An empty directory forces me to think about what the session needs to know. A full directory that has never been cleaned out fools me into thinking that’s been taken care of. That is why the lifecycle also includes regular checks against the sources: does the convention still apply? Does the runbook still describe the system that is running?
The cycle#
If you take this distinction seriously – emergent knowledge is created all the time, curated knowledge has an effect – a cycle follows almost inevitably. From these observations I derive four stations.
First: learn from real runs. Not from opinions, not from blog posts, but from what actually happened in your own sessions. Which explanation worked? Where does the same follow-up question come up repeatedly? Which error shows up independently in several pull requests? The raw material is lying around – you just have to recognize it as raw material.
Second: a human curates and approves. This is the decisive station, and it is deliberately not automated. Distilling means selecting, condensing, throwing away. Ten observations become one paragraph; one paragraph may become one line in the convention file; eight of the ten observations are discarded because they were one-offs. The team has to make this decision, because only the team can define what is binding from now on: what is a rule here, what was an exception and what should apply starting tomorrow. And the approval – a second pair of eyes, a real review – turns a private note into a shared commitment.
Third: the distillate flows into the grounding of the next session. It sits in the file every session reads, or in the knowledge source that is pulled in during work. From that moment on, not every colleague has to explain the error model to “his” session orally and differently – the explanation is the same, for everyone, reviewed.
Fourth: the next piece of work can get better. Not dramatically, not all at once. Whether the cycle works can be checked with concrete questions: does the follow-up question that kept repeating come up less often? Does the recurring error still show up in new pull requests? And the next runs produce new raw material – ideally at a slightly higher level.
flowchart LR
A["Real runs<br/>and experiences"] --> B["Observe and<br/>collect raw material"]
B --> C["Human curates,<br/>review approves"]
C --> D["Distillate in the grounding<br/>of the next session"]
D --> AThis is not a framework and not a ceremony. To get started, a regular, short pass is enough, in which the team discusses what stuck, plus the discipline to treat changes to the knowledge files like code changes: branch, review, merge. How much effort is appropriate depends on the team, the scope and the risk.
It’s not the model that gets smarter#
The point of this cycle only became clear to me over time, and it changed how I see the whole model debate: in this cycle, the model doesn’t get smarter. The organization learns: people select insights, justify them and make them reusable for others. The selected insights show up as versioned changes to the curated knowledge – not in a model retaining more context.
At the end of the quarter, the model hasn’t automatically retained anything from our sessions as team knowledge. The version on offer may well have changed during that time – that doesn’t mean it knows our error model. What has improved is the layer around it: our curated knowledge, our explanations, the quality of what we give each session. And – this is the decisive difference – this layer belongs to us. We can read it, check it, correct it, roll it back. We can steer it. Which model version a vendor ships and how it behaves is something we can influence far less.
If you locate the learning ability of your AI work in the model, you have a steering problem: you’re waiting for progress you can’t influence. If you locate it in curation, you have a work problem – more strenuous, but solvable. I consider that the most sober answer to the question of where a team should invest: in the part it owns.
The anti-patterns#
Most of the attempts I’ve seen to capture session knowledge have failed. And in three recognizable ways.
The prompt collection in the wiki. Someone creates a page: “Our best prompts.” For three weeks people contribute, then never again. After half a year, the page contains outdated prompts without context of use: for models no one uses anymore, for problems no one has anymore, without saying when they work and when they don’t. No one dares to delete, no one wants to maintain. The mistake is already in the form: a prompt without the situation it was distilled for is not knowledge but a souvenir.
The instruction file dump. I already looked at this from a different angle in “Futile Attempts: Skills, AGENTS.md and the Limits of Recommendation”: convention files that everyone writes something into now and then and from which nothing ever drops out. After a year, there are two thousand lines in which rules contradict each other because the one from March doesn’t know the one from October. The sessions read everything and weight it somehow – the result is a lottery. A knowledge file without deletion discipline is not a knowledge file but a sediment basin.
The written-down-once. The third variant is the quietest: in a good week, a motivated colleague writes everything down – thoroughly, structured, really useful. Then it’s never touched again. No ownership, no review rhythm, no occasion to update it. Twelve months later, parts of it may be outdated, and because no one knows which ones, no one trusts the rest anymore. The one-time heroic effort is the natural enemy of the cycle: it feels like a solution and prevents exactly the routine that would be one.
All three patterns lack the same thing: the way back from the real work into the knowledge. They treat writing things down as an event instead of a cycle.
The opportunity that costs work#
And still – or precisely because of this – I consider this moment an unusual opportunity. Organizations have been talking for decades about making implicit knowledge explicit. Knowledge management initiatives, wikis, communities of practice: my thesis is that the lack of an immediate consumer contributed to many of these initiatives petering out. Whoever wrote down their knowledge wrote for an abstract “later” and a hypothetical “someone.” The feedback was missing; writing things down remained a sacrifice without visible return.
That is changing right now. AI sessions form an additional immediate consumer for explicit knowledge. If you distill a convention cleanly today, you can check it in the next session: does the AI behave differently? Does the pull request follow the convention? Does the familiar follow-up question stay away? The feedback loop that was missing in these cases can become much shorter in such workflows. AI thus creates an immediate incentive to make implicit knowledge explicit – and the next session gives early hints about whether what was written down holds up.
I don’t want to hide the criticism of this. Curating costs the time of exactly the people who have the least of it. There is a real risk that the cycle gets out of hand and every line of convention has to pass through its own approval committee. And not all knowledge wants to be frozen – some of it is deliberately in flux, and if you distill it too early, you cement an interim state. The answer to that is moderation, not abstinence: start small, distill only what has repeated itself, and take deleting as seriously as writing.
What keeps me busy at the end of this episode is a question one level deeper. Suppose the cycle is in place: the team curates, the knowledge survives the session, the organization learns. Then there is a growing body of distilled conventions, domain terms, decisions – and session after session, I hand it to a generic assistant that knows nothing about my domain and reconstructs everything from the context every time. At some point the question arises of whom I’m actually entrusting this knowledge to: is the generic agent with good grounding enough – or does the domain need a counterpart built for it? Where exactly the generic agent ends is the question of the next episode.
Further reading#
Revised and translated from German with the help of AI.