Your Session Logs Are a Client Audit Log

A long-time operator client sent me a message last week. The gist: “Can you remind me what you’ve actually said you’d ship for us?”

Fair question. We’ve been working together for months. I’d made promises in Slack, in calls, in text messages, and — this is the one that bit me — inside Claude Code sessions, when I’d be fixing a bug and type something like “while I’m in here I’ll also add a hold button on the blackout dates.” That line never made it to a ticket. It made it to the code, usually, but not always. And whether it did or didn’t, it absolutely did not make it to a document the client or I could point at six weeks later.

My memory for that kind of thing is worse than I used to pretend. I know this now because I finally went looking for the answer in a place I’d never thought to look: my Claude session logs.

491 JSONL files, 1.3 GB

Claude Code writes a .jsonl file for every session you run. One line per message, user and assistant both, with the full text of what was said, every tool call, every tool result. They pile up in ~/.claude/projects/<slugified-cwd>/, named by UUID, and the harness never cleans them up.

That’s one project directory. Across all my work, it’s more. I had been treating these files as exhaust — something the agent writes while it runs and that I vaguely know I could delete if the disk ever got tight.

They aren’t exhaust. They are the single most faithful record of what I actually said I would do, because every working conversation about this client’s product passed through them. Slack has emoji and vibes. Calendar has titles. Todoist has one-line stubs. The JSONLs have whole paragraphs of me saying “yes, I’ll do that,” followed by me actually doing some of it and quietly dropping the rest.

The prompt that mined them

Here is the whole move, which is embarrassingly simple:

# Scope the mine to this project's sessions.
cd ~/.claude/projects/-home-brettr-Documents-FreeboDecember

# Ask a fresh Claude session to read them and summarize.
claude -p "Read every .jsonl in this directory. For each one,
extract every explicit commitment I made to the client — things I
said I would build, fix, send, follow up on, or decide. Group by
feature area. For each item give me: (1) the exact quote, (2) the
session file and timestamp, (3) whether it looks like it ever
shipped based on later sessions. Output a markdown checklist."

That’s it. No wrapper, no agent protocol, no vector database. The transcripts are already plaintext (JSON Lines, one message per line) and Claude can grep and read them without any help. You point it at the folder, you tell it what shape of commitment you’re looking for, and it comes back with a checklist that is both too long and uncomfortably accurate.

What came back

Grouped roughly:

• Explicit feature promises — “I’ll add a hold button to blackout dates,” “I’ll pull the fee breakdown out of the admin screen,” “I’ll make the checkout page respect the operator’s own cancellation copy.” Most had shipped. Two had not. One of the two I had completely forgotten.
• Bug acknowledgments — “yes that is a bug, I’ll get to it this week.” A few of these were from weeks I had definitely not fixed anything.
• Deferred questions — “let me think about pricing on that,” “I’ll come back to the refund flow after launch.” Perfectly reasonable things to defer. Also perfectly reasonable to never come back to, which is what had happened.
• Numbers I had quoted — “a day or two,” “under fifty bucks,” “by Friday.” Reading these back as a block was the most sobering part. I quote confidently and track loosely.
• Decisions, implicit — the one I didn’t expect. The model picked out moments where I’d made a product call in a sentence (“we’re not going to support split payments on this type of booking”) that had never been written down anywhere else. Those are the ones that bite you later, because the next session won’t remember them.

The whole audit took maybe five minutes of wall-clock time and cost well under a dollar. It produced a checklist I could hand straight to the client, in his language, with timestamps and quotes, so he could tell me what still mattered to him and what didn’t.

Why this works

A JSONL session isn’t notes. Notes are curated. Notes are what you decided mattered at the moment you wrote them.

A session is the opposite — it’s what you actually said while trying to do the thing. The off-hand yes, the “sure, let me just,” the “while I’m here I’ll also.” The commitments you didn’t realize were commitments until a client reads them back to you three months later. For a solo operator with no account manager, no project manager, and no CRM, that is a surprisingly complete record of your working relationship, and it’s sitting on your laptop in plaintext, already indexed by project, waiting to be read.

The uncomfortable implication is that I probably should not have waited for a client question to go looking. The audit is useful every month, not just the one month a client asks for it. The transcripts are already being written. The only thing between me and a usable institutional memory is the prompt, which fits in a tweet.

The takeaway

Your Claude sessions are not disposable. They are a transcript of your working self, more honest than your notes and more detailed than your tickets, and they will remember things you have genuinely forgotten.

Point a fresh session at the folder and ask it for the shape of fact you care about. Promises. Numbers. Decisions. Bugs you accepted. The ones you didn’t ship.

The log was never silent. I just hadn’t asked it anything.