November 15, 2026•11 min

Claude Project Decision Log: Carry Context Between Chats

A common surprise with Claude Projects goes like this. You spend an afternoon in one chat inside a Project, settle several decisions, rule out two approaches, and close the tab. The next morning you open a new chat in the same Project and it proposes one of the approaches you rejected. The files are attached and the instructions are in place, but yesterday's reasoning did not come with them.

That behaviour is by design: a Project shares materials, not conversations. Why that is, and how to test what your own account carries across chats, is covered in Does Claude Remember Other Chats in the Same Project?. This post is the practical follow-up. If previous chats do not leave anything behind, the reliable fix is to leave something behind yourself, and the most useful form that takes is a decision log: one short document, attached to the Project, that every new chat can draw on. Below is what goes in it, a template you can copy, and the routine that keeps it current without becoming a chore.

Why a Decision Log and Not Something Else

There are several places you could try to keep continuity in a Project, and they are not equally good.

Leaving it in the chat transcripts. This is the default and the reason for the problem. Transcripts are a record for you. They are not supplied to the model in a new conversation, so anything that lives only in a transcript is invisible to the next chat.

Putting everything in the project instructions. Instructions are supplied at the start of every chat in the Project, which makes them dependable. But they are meant for standing rules — tone, format, constraints that always apply — and they become unwieldy if you append every decision to them. A long, ever-growing instruction block is harder for you to maintain and buries the rules that matter most.

Attaching full transcripts as files. Tempting, and usually counterproductive. Attached material is drawn on selectively rather than held in full, so a pile of long transcripts makes it harder for the right passage to be picked up. You end up with more stored and less used.

A short, structured decision log attached as project knowledge. This sits in the middle. It is compact, so the relevant entry is easy to retrieve. It is written in the vocabulary you will use when asking questions, which helps retrieval. And because it holds conclusions rather than conversations, it stays readable to you as well.

The split that works best in practice is simple: standing rules go in the instructions, and the evolving state of the work goes in the log.

What Belongs in the Log

The test for whether something belongs is whether a new chat would make a worse suggestion without it. That usually means four kinds of entry.

  1. Decisions. What was chosen, in one line. "Use the existing customer table rather than a new one." "Weekly cadence, not daily."
  2. Rejections and the reason. What was considered and ruled out, with half a line of why. This is the most valuable category and the one most often skipped. Without the reason, a new chat has no way of knowing that a reasonable-looking option was already tried.
  3. Constraints discovered. Facts that emerged during the work and must now hold. "The client cannot accept attachments over a certain size." "The API only returns the last ninety days."
  4. Open questions. What is still undecided, so a new chat does not treat it as settled — and does not quietly settle it for you.

What does not belong: the story of how you got somewhere, the assistant's explanations, intermediate drafts, and anything that is true of every project you work on. History makes the log longer without making the next chat better. General preferences belong in the instructions or in your account settings.

A Template You Can Copy

Keep it reverse-chronological, so the newest state is at the top where it is easiest for you to read and update. A plain text or markdown document is ideal.

Project: one sentence on what this Project is for.

Current state: two or three sentences on where the work stands today. Rewrite this, do not append to it.

Open questions

  • Question one — who or what it is waiting on
  • Question two

Log

Session — date

  • Decided: …
  • Ruled out: … — because …
  • Constraint: …

Session — earlier date

  • Decided: …
  • Ruled out: … — because …

Two details make a large difference. The current state paragraph is rewritten each time rather than accumulated, so it always reflects today rather than a sediment of past states. And each ruled out line carries its reason on the same line, so it cannot become separated from the thing it explains.

If you already use a handover template for restarting long chats, the decision log is its natural home: the handover is a snapshot, the log is the running record that produces it. A general template that works in any assistant is in A Context Brief Template That Re-Briefs Any AI.

The End-of-Session Routine

A log only works if it is updated, and it will only be updated if doing so is fast. The routine below takes about five minutes.

  1. Ask for a draft. Near the end of a working session, ask Claude in that chat for a short list of what was decided, what was ruled out and why, any new constraints, and what remains open, in the format of your log. The assistant is good at this and has the whole session in front of it.
  2. Read it critically. Check every line against what you actually agreed. Summaries are lossy in a predictable direction: they keep the narrative and drop specifics, and they are especially prone to dropping rejected options. Add anything missing and delete anything that was speculation rather than decision.
  3. Update the document. Add the session entry at the top of the log, rewrite the current state paragraph, and adjust the open questions.
  4. Replace the attached file. Upload the updated document to the Project's knowledge so the next chat draws on the current version rather than a stale one. Remove the old version if your workflow leaves both attached; two copies that disagree are worse than one.
  5. Promote anything permanent. If a decision has hardened into a standing rule, move it to the project instructions where it is supplied unconditionally, and note in the log that it was promoted.

Do this at the end of any session that settled something. Sessions that settled nothing do not need an entry, which keeps the log short.

Using the Log at the Start of a Chat

Attaching the log makes it available. It does not guarantee it is used for every question, because project knowledge is drawn on selectively. Two small habits close that gap.

Point at it in your first message. Open a new chat with a line such as "Read the decision log first and summarise the current state and open questions before we start." This does two things: it pulls the log into the conversation explicitly, and the summary shows you immediately whether the chat has the right picture.

Check one rejection. Ask, in passing, whether a specific ruled-out option is still on the table. If the answer correctly says it was rejected and why, the log is being read. If not, paste the relevant section into the conversation directly; for a long or high-stakes session, pasting the current state and open questions at the top is cheap insurance anyway.

Restate hard constraints that matter today. Anything you would be annoyed to see violated in this session belongs in your first message, even if it is also in the log. Redundancy here costs a few lines and saves an argument.

Keeping the Log Healthy

Decision logs fail in a small number of predictable ways.

It becomes a transcript. Entries grow into paragraphs of reasoning, and after a few weeks the log is long enough that retrieval suffers and nobody wants to read it. Keep each line to one sentence. If a decision needs explanation, the explanation probably belongs in a separate reference document.

The current state goes stale. Sessions get logged but the summary at the top is not rewritten, so it describes the project as it was a month ago. A new chat reading it will confidently work from the old picture. Rewriting that paragraph is the most important step in the routine.

It contradicts the instructions. You changed direction, updated the log, and left an old rule in the instructions. Now the answer you get depends on which one is picked up. When you change course, check both.

It never gets pruned. Once a phase of work is finished, its detailed entries can move to an archive document that is not attached, leaving a single line in the log noting what that phase concluded. The log is a working set, not a history book.

A useful monthly check: read the log from top to bottom and ask whether a capable colleague who had never seen the project could pick up the work from it. If they could, so can a new chat.

When One Project Is Not Enough

A decision log solves continuity within one Project. Two situations go beyond it.

Work that spans Projects. If the same decisions matter in more than one Project, keeping separate logs leads to drift. Keep one master document for the shared decisions and attach it to each Project that needs it, updating it in one place. Approaches for sharing material across Projects are covered in How to Share Context Between Claude Projects.

Work that spans assistants. If you draft in Claude and review elsewhere, no Project feature will carry context across, because a Project is a container inside one product. The decision log, however, is just a document. Paste its current state and open questions into the first message of a chat in any other assistant and it does the same job. The pattern for splitting work between two assistants is in Using ChatGPT and Claude Together.

That portability is the strongest argument for keeping the log as your own document rather than relying on any built-in memory feature. Memory features vary by plan, get renamed and change scope. A plain document you wrote behaves the same everywhere and does not depend on anyone's roadmap.

What About Claude's Own Memory Features?

Claude's account-level capabilities for drawing on past conversations, and what they cover, depend on your plan and settings, and they have changed more than once. This post does not describe them, deliberately, because any specific description would date quickly. The way to know what your account does today is to test it: establish something distinctive in one chat, start a genuinely new chat inside the Project, and ask about it. The full method is in the Projects post linked at the top, and what Claude retains by design is in What Claude AI Actually Remembers.

Even where such a feature is available, a decision log still earns its place. A built-in feature decides for you what to carry forward and how to phrase it. The log is a record you wrote, checked and can correct, and it includes the rejected options and reasons that automatic recall tends to lose. The two are complementary: let any built-in recall do what it does, and keep the log as the source of truth.

A Short Worked Example

Imagine a Project for planning a small product launch. Over one session you decide to launch on a weekday rather than a weekend, rule out a paid announcement because the budget does not cover it, discover that the email platform limits sends per hour, and leave the pricing page copy unresolved.

At the end you ask Claude for a log entry. The draft lists the weekday decision and the open pricing copy, mentions the sending limit, and omits the paid announcement entirely. You add it back with its reason — "Ruled out: paid announcement — over budget" — rewrite the current state as "Launch date set for a weekday; email schedule must respect the hourly send limit; pricing copy outstanding," and upload the updated file.

The next day you open a new chat in the Project and ask for a launch-week plan, starting with a request to summarise the log. The summary mentions the hourly limit and the rejected paid announcement. The plan that follows staggers the email sends and does not suggest paying for an announcement. Without the log, both of those would have been things you had to catch and correct by hand.

Where MindLock Fits

A decision log is a document you maintain yourself, and for many people that is enough. MindLock is for when you want the same continuity across many conversations and several assistants without writing every entry by hand.

You save the conversations that mattered with Ctrl or Cmd plus S in Claude, ChatGPT, Gemini or Perplexity, or with the "Save to Memory" button from the Chrome extension, which is loaded unpacked in developer mode rather than installed from a store. You upload the saved pages, and distillation turns them into memory documents — a profile memory plus topic memories — that you can read and edit. Generating a context block packages the relevant memories into something you paste as the first message of a new chat, in a Claude Project or anywhere else. How that block is assembled is described in Generating Context, and what memory documents contain is in Memory Documents.

Two limits, stated plainly. Nothing is automatic: saving is a keystroke you press, and memory documents update when you re-run distillation rather than continuously. And MindLock does not connect to your Claude account or change how Projects behave; it gives you context you own and paste in yourself. Local distillation runs on your GPU through WebGPU on the free tier; hardware without WebGPU support needs the cloud option on the paid tier, set out on the pricing page.

The Short Version

A Claude Project shares its instructions and attached files with every chat, but not the conversations themselves. Anything a previous chat settled is gone from the next one unless you write it somewhere the next chat can see.

Keep a short decision log as project knowledge: a rewritten current-state paragraph, open questions, and one-line entries for decisions, rejections with reasons, and constraints. At the end of any session that settled something, have Claude draft the entry, correct it, and upload the new version. Open new chats by asking for a summary of the log, and move permanent rules into the instructions.

It takes five minutes a session, it works the same whatever memory features your plan has, and because it is just a document, it travels to any assistant you use next.