Stop re-explaining your project to AI

You open a new AI session to keep working on a project. Before you can do anything useful, you are explaining the stack again. Then the design decisions. Then why the obvious approach is the one you already ruled out yesterday.

That is the restart loop. The work continues, but the explanation starts over.

A simple project memory system gives the next session somewhere to begin. Keep a short note with four things: the goal, the decisions, the constraints and the next step. Update it as the work changes, and explicitly have your AI read it when you resume. You can start with a plain text file today.

Get the free template · Learn the save and reload workflow · See where Lattice fits

Why a long conversation is not enough

Conversation history and durable project notes serve different purposes. The conversation contains the route you took: abandoned approaches, error output, drafts and corrections. Your memory note should capture the current decisions that still matter.

In its guide to effective context engineering, Anthropic describes how long conversations can be compacted and how structured notes can persist outside the context window and be read back later. Compression can lose useful details; a saved note gives those details another place to live.

The practical habit I recommend is straightforward: write down the outcome while it is fresh. Save what the next session needs to act correctly.

The four things worth saving

1. The goal. What are we building, for whom, and what will count as done? “Finish the booking flow” is easier to act on when it includes “a customer can choose a slot and receive confirmation.”
2. The decisions. Record what you chose and why. “Use the existing database because this feature needs the current customer records” helps the next session avoid reopening a settled choice. Add a link to the relevant file when possible.
3. The constraints. What must stay true? Examples include preserving existing URLs, using the established design system, or keeping a change within an agreed scope.
4. The next step. Describe the current state, the next concrete action and how to check it. “Confirmation is implemented; verify the empty-slot case next” is a usable handoff.

Keep these sections short enough to review before working. When the answer changes, replace the old answer. A note that still describes last week’s plan can send the next session in the wrong direction.

Copy the project memory template

Create a file named PROJECT_MEMORY.md in your project folder and fill in the sections below. The filename is a convention for this workflow; it does not make every AI tool load the file automatically.

Download PROJECT_MEMORY.md or copy this template. No email required.

# Project memory
Last reviewed: YYYY-MM-DD

## The goal
- We are building:
- This is done when:

## The decisions
- Decision:
  Why:
  Source or relevant file:

## The constraints
- Must keep:
- Must avoid:

## The next step
- Current state:
- Next action:
- How to check it worked:
- Open question or blocker:

Keep credentials and personal information out of the note. Link to the appropriate secure location or source file when that is what the next session needs.

Save at milestones and reload when you resume

Save when something meaningful changes: you choose an approach, finish a feature, discover a constraint, or stop for the day. Ask your AI to propose an update, then review it against the work that actually happened.

Review what changed in this session. Propose an update to PROJECT_MEMORY.md covering the goal, decisions and reasons, constraints, and next step. Separate completed work from plans and unresolved questions. Keep it concise and show me the changes for review.

Review matters. A planned test is not a passing test, and an idea discussed in chat is not an implemented feature. Correct the note before treating it as the handoff.

Reload at the start of the next session: explicitly ask the agent to read the file. If your tool cannot access project files, paste the relevant sections into the conversation.

Read PROJECT_MEMORY.md before changing anything. Summarize the goal, decisions, constraints and next step. Check the relevant source files for the current state, flag any conflicts with the note, then propose how to continue.

Use the note to orient the session, then inspect the actual project. If a decision depends on a deployment setting or a function in the code, the agent should check that source before acting.

A small example of a useful handoff

Suppose you are adding appointment booking to an existing site. Your note might say:

• Goal: customers can book an available appointment and get confirmation.
• Decision: reuse the current booking service so availability comes from one place.
• Constraint: preserve existing appointment URLs and the site’s design system.
• Next step: the confirmation screen is built; check what happens when the selected slot becomes unavailable before submission.

That is enough to explain where the project stands without replaying the whole conversation. A fresh session can identify the unresolved case and begin by checking the relevant code.

When you want project memory built into the workflow

A single file is a useful place to start. As you move between projects and coding agents, keeping the right notes current and bringing them into each session becomes its own recurring job.

That is the problem I am building Lattice around. It brings projects, coding-agent terminals and shared project memory into a Mac app, so saved decisions and constraints can carry into supported, configured agent sessions.

Memory support depends on your agent and setup: full for Claude Code, brief and capture support for Codex after project synchronization and a one-time hook approval, partial for Gemini and limited for Cursor. See the Lattice page for the setup that applies to your agent.

You can use the template on its own. If you want to see how project memory fits into a workspace for your coding agents, start with the Lattice walkthrough.

See how Lattice works →

Before your next session, save one decision and its reason. When you resume, ask the agent to read it back and check it against the project. That is the first useful test of your memory system.