Months of agent session logs are a queryable record of every decision I actually made, not the tidied-up version I’d write after the fact. Finding out why is usually a search away, not a guess.
Every session I run with a coding agent leaves a transcript behind. Most of the time I never look at it again after the session ends, the same way most people never reread an old chat log. What changed my relationship to those transcripts was running into a question I could not answer any other way: why did I decide, three weeks earlier, to structure a particular system the way it currently is. The code told me what the decision was. It told me nothing about what I had rejected first, or what had gone wrong before I settled on the version that shipped. That reasoning existed, in full, in a transcript sitting unread in a folder.
Once I started actually treating the transcript archive as a resource rather than exhaust, the volume of it became the interesting part. Months of sessions, across more than one coding engine and more than one account, add up to a genuinely large record of a very specific kind of thing: a decision, the alternatives that were considered and discarded, and the reasoning at the moment the decision was made — not the reasoning reconstructed afterwards to justify it. That distinction matters more than it sounds. A commit message or a design doc written after the fact tends to describe the decision as if it were obvious in hindsight. A transcript captures the actual back-and-forth, including the wrong turns, before anyone had smoothed the story out.
The practical obstacle is that the transcripts do not live in one place or one shape. Different coding tools store session history differently — some as line-delimited JSON per session, some behind a local database, some scattered across per-account directories that multiply if you run more than one account for the same tool. Before any of it is searchable, it has to be enumerated properly: every install directory, every account, every engine, because assuming there is one canonical location is exactly the assumption that leaves half the record invisible. I found this out by grepping what I thought was the whole archive and getting a suspiciously thin result, before realising a second account’s sessions lived in a directory I had never pointed the search at.
Once the paths are actually enumerated, the useful move is treating the whole archive as a corpus you can query rather than a pile of logs you scroll through. Full-text search across every transcript turns "why did I do this" into an answerable question instead of a guess, because the answer is sitting in a session from however long ago, in my own words, at the moment I was actually working the problem out. It surfaces things a changelog never records: a workaround tried and abandoned because it had a side effect nobody wrote down elsewhere, a constraint someone mentioned once in passing that shaped everything downstream, a tool I evaluated and rejected for a reason I would otherwise have to rediscover from scratch.
What makes this a discipline rather than a one-off recovery trick is doing it before you need it — indexing the archive as a standing habit, so the record is queryable the next time a decision needs explaining, rather than starting from zero the day you finally need the answer. The value compounds the same way any archive’s value compounds: the further back it reaches and the more consistently it has been kept, the more likely the specific thing you need is actually in it. I did not set out to build an institutional memory. I ended up with one anyway, made entirely of sessions I almost never looked at twice.