The Activity Log System

Here's how I work with Claude Code and Codex. I open a project folder, start a session, do some work, then move on to something else. Sometimes I close the session. Sometimes I compact or clear it to save tokens.

Then I come back, open a new session, and ask where we left off. Claude checks its memory and suggests something unrelated. Our last conversation had not seemed significant enough to keep. Or I open the same folder in a different agent, and it has no idea what progress was made or what was next.

I first ran into this with OpenClaw. It had a sort of memory, so I assumed, wrongly, that it would remember everything we talked about.

AI sessions are short-lived. The projects they work on are not.

One of the great things about using a tool like Claude Code or Codex is that if something is not working the way you want, you can just build a custom solution. So I built one.

Where built-in memory stops

Claude Code and Codex can carry stable context forward: preferences, project conventions, recurring workflows, and things I would otherwise repeat. But that is not the same as a project history. Claude decides what is worth saving, Codex memories have to be enabled, and both systems summarize useful context rather than maintain an inspectable timeline of decisions. I wanted the thing memory does not guarantee: what changed, why it changed, and where to pick up next.

Part of the gap was mine, from not understanding how memory worked. The other part was the design. It did not fit the way I work as a non-developer, evolving documents over time rather than writing code.

A folder is a project, and a project has a history

I work in one folder per project. A new feature, a strategy brief, any piece of work. I launch each session from that folder, so it is scoped to that one project. Over time a folder grows. It might begin as a few notes about an idea, become a one-pager, then turn into user stories once the work moves into development. By then I have had many sessions in that folder, and every new one started with Claude forgetting where we had got to.

So I borrowed an approach from the OpenClaw community. I call it the activity log system. My workspace has a plain-markdown ACTIVITY_LOG.md, and project folders can opt into their own log when they need a tighter history. CLAUDE.md and AGENTS.md point Claude Code and Codex at the same files. Because it is just Markdown on disk, the history does not depend on one model's memory.

The full log can grow without limit, so at session end a hook refreshes a short snapshot, CONTEXT.md, usually under twenty lines: current status, the last decision, the next step, and which files to open. The next session gets the snapshot instead of the whole history, which keeps the cost low even when a mature log runs to tens of thousands of tokens.

A file trail is not a story

The hooks keep the floor current so I do not have to. One loads the current snapshot when a session starts. One records supported file edits as they happen. One refreshes CONTEXT.md when the session ends. That gives me a reliable trail of what changed, but not the whole story.

The story still needs a narrative milestone: what was decided, why it mattered, and what should happen next. For a high-stakes session I still write that part by hand. The hook is the floor, not the ceiling.

Clearing the session without losing progress

A long session fills up. The context gets compacted, and detail from early in the conversation starts to drop out. Because the parts that matter already live in the log, that stopped costing me much. I can run /clear or /compact, or just start a fresh session, and the next one reads the snapshot and picks up where I left off.

It also changed how freely I reset. I used to keep a session alive longer than I should, letting it bloat, because starting over meant re-explaining the project. Now continuity lives in the log, not in the session, so I clear early and keep my token usage down.

The bonus

The reason I built this was continuity between sessions and agents. What surprised me was that it became a record of how I actually work. The first time I do a new task with Claude, it is a manual back-and-forth, no skills involved. After the first time, I can point Claude at the activity log and have it build a reusable skill, so the next run starts from a recipe instead of a blank chat.

The reusable version lives in the toolkit:

I would not call any of it finished. But I no longer open a session with "okay, where were we?"