Claude Code project management: keep progress outside the session

You have three projects going in Claude Code, and each one has been worked across a dozen sessions. On Monday you can't remember which session left the invoice export half done, and your colleague asks where the migration stands. The answer is inside a session somewhere, and nobody else can open it.

This post is about Claude Code project management when the work is bigger than one session: what Claude Code already remembers for you, what it doesn't, and how to keep a project's progress in a record your team and your next session can read.

Why Claude Code project management breaks down after a few sessions

Every Claude Code session starts with a fresh context window. Inside a session, the agent knows exactly how far it got: which tests pass, what it tried, what the next step is. When the session ends, that knowledge stays in the transcript.

For one person on one project, that's fine. You resume the session and carry on. It gets harder when:

• you run several projects at once and switch between them;
• you move between a laptop and a desktop, or between a work and a personal account;
• you use Codex for some of the work and Claude Code for the rest;
• a teammate needs to know where things stand, or pick the work up.

In each case someone ends up finding the right session again, or explaining the project from scratch.

What Claude Code remembers on its own, and what it doesn't

Claude Code already carries a lot across sessions, and it's worth using all of it.

• CLAUDE.md holds the instructions you write: build commands, conventions, "never do X" rules. It loads at the start of every session.
• Auto memory holds notes Claude writes itself from your corrections and preferences. It is kept per repository and shared across worktrees. Both are described in the docs page How Claude remembers your project (checked 29 October 2026).
• Cross-session messaging lets one of your Claude Code sessions send a message to another, on the same machine, another machine or in the cloud. A message is a piece of text, never the conversation or its files. See Message your other Claude Code sessions (checked 29 October 2026).

So, does Claude Code remember across sessions? It remembers how you work in a repository. Can sessions talk to each other? Yes, your own sessions can pass messages mid-task.

What none of these gives you is a project record: one place that says where the work stands, what the next step is and who did what, which a teammate can open, a Codex session can read and you can edit by hand. That's project memory, and it's a different thing from session memory.

Project memory: a record outside any session

A useful project record is small. It holds:

• where the project stands: what was achieved most recently and the one next step;
• a status that means something: active, waiting, blocked, paused, done;
• a handoff: the backlog, the decisions made and how to check the work, written so a fresh session can start from it;
• how to recognise the project: its repository, branch, folders and key files, so an agent files progress on the right one;
• a history of every update and who made it.

You can keep this in a Markdown file in the repository, and for one person that works well (more on that below). Agent Projects is a Keeper app that keeps the same record outside the repository, where people and agents can both reach it.

A walkthrough: push a checkpoint, then pick up somewhere else

Here's what the loop looks like with Agent Projects and the MechaBee plugins installed in Claude Code.

1. Push a checkpoint. At the end of a stretch of work, you ask:

Push this session's progress to my projects.

The agent recognises the project from the repository and branch it's working in. If it can't find a match, it asks before starting a new project.

2. Check it and approve. Before anything is saved, the agent shows you the checkpoint, for example:

• Achieved: Tests for the CSV totals, all passing.
• Next step: Add the totals row to the CSV.
• Status: Active, unchanged.

You say yes, or tell it what to change. Nothing is recorded until you approve it.

3. The newest push sets the project. The project page now shows the new next step. History keeps every push with who made it, next to any edit you made by hand. If you change the next step yourself in the app, the next session sees that too.

4. Pick up anywhere. Tomorrow, on another machine, you open the project and use the button that copies a pick-up prompt with the workspace, app and project filled in. You paste it into a fresh Claude Code session, or into Codex. The session reads the project and its handoff first, then compares its repository and branch with the project's, and tells you before it changes anything if they don't match.

The agent never reads your sessions or your code to do this. It writes a short checkpoint, and you approve it.

Running several projects at once

Once a few projects report to the same place, you can see them together instead of reopening sessions:

• Domains group projects by product, client or business, and you can share a domain with colleagues. Members see only the domains they're given.
• A timeline lines projects up by due date, with arrows where one project needs or blocks another.
• A priorities review: an agent reads every running project and writes a dated review that ranks them, with a one-line reason each.

When one project turns into a queue of separate pieces of work, such as bugs and requests, that's a job for an issue tracker. Your agent can work those too: see Issue Tracker.

Other ways to do it, and when they're enough

You don't need an app for every project. Three common approaches, and where each fits:

• A ROADMAP.md in the repository. Claude Code reads and updates a plan file as it works. It's simple and stays with the code, and it's a good fit for one person on one project. It gets harder once several people or several projects need one view, or a non-developer needs to see progress.
• GitHub issues as the plan. Skill systems such as ccpm turn a requirements document into GitHub issues and run agents against them in parallel. That's a strong fit for engineering teams already living in GitHub, and heavier than many small projects need.
• A /handoff skill. A skill that writes the current session up so the next agent can continue. It's quick and works well from one session to the next. There's no shared record, so a teammate still can't see where things stand.

A project record outside the session is worth it when you have several projects in flight, switch machines or tools, or share the work with other people.

What it doesn't do

Agent Projects keeps the state of the work, not the work itself:

• It doesn't read your sessions, your conversations or your code. What it holds is what you approved.
• It isn't a ticket tracker; one project has one next step, not a queue.
• The timeline is read-only for now, so you set dates on the project rather than by dragging, and priority reviews are for app admins.

Because it's a Keeper app, you can ask your agent to change it for what your team needs.

Summary

Claude Code remembers how you work in a repository, and your sessions can message each other. For Claude Code project management across many sessions, machines, tools and people, keep one more thing: a project record outside any session, updated by checkpoints you approve. Start with a ROADMAP.md if it's just you; move to a shared record when the work outgrows it.

To try it, install the MechaBee plugins in Claude Code or Codex, copy Agent Projects into your workspace, and push your first checkpoint. You can start free with included credits.