Synthesis Project Management: Keeping AI Work Moving Across Sessions

Synthesis project management grew out of a recurring frustration: I could make progress with an AI assistant, then spend the next session reconstructing what we had already decided. Conversation summaries lost details. Lessons existed but were hard to find. Keeping everything in one project file made that file increasingly difficult to use.

The method gives current work, maintained reference and dated history different homes. A registry locates the project; each assistant's entry instructions tell it how to reach those records. The aim is to make starting again feel like continuing the work.

Five design principles

Make knowledge discoverable. Agents can search; people need quick orientation. Consistent project names, dated lessons and one authoritative registry give both a way in. Another manually maintained list creates another place to forget a change.

Prefer convention to repeated configuration. When projects follow a familiar structure, a contributor can concentrate on the work rather than relearning where decisions live.

Maintain one authoritative version of a fact. Reference the current requirement instead of copying it into every summary. Preserve the history of a changed requirement without leaving the old one looking current.

Make files describe themselves. A lesson's date and topic belong in its name. A project's status belongs in the registry. Its context should say what exists and what happens next.

Have agents maintain the system. I want the assistant to update project records as part of doing the work, without waiting for me to remind it. For a new record, I prefer adapting a good existing example to maintaining a separate folder of templates. The examples below show the structure; the operating instructions make record maintenance part of the job.

Give each record a job

Update — guide reviewed October 1, 2026: The working guide below includes current procedures for maintaining project records, handing work between clients, and configuring instruction and memory loading.

projects/
  index.yaml
  build-dry-run-renamer/
    CONTEXT.md
    REFERENCE.md
    sessions/
      2026-09.md
    resources/
lessons/
  YYYY-MM-DD-topic.md
daily-plans/
  YYYY-MM-DD.md

Projects stay in a flat directory; changing a status does not require moving the project and breaking its paths. resources/ holds project artifacts. lessons/ and person-scoped daily-plans/ are peers of projects/ because they cross project boundaries. This is the layout described in the April 22, 2026 update; the earlier underscore-prefixed lessons folder lived inside projects/.

index.yaml is the registry: where the project lives, what it is trying to accomplish and whether work is active, paused or complete. Descriptive names help people and agents find candidates; the registry carries the status that changes. Keep one authoritative registry instead of separate lists that have to agree.

CONTEXT.md holds the state needed to continue: the current objective, controlling decisions, work completed, unresolved conditions and next action. My working rule is a hard budget of 150 lines. A completed project gets a summary of at most 80 lines. These are the maintenance rules I use to keep the entry file useful.

# {Project Name} — Working Context

**Phase:** [Current phase]
**Last session:** YYYY-MM-DD

For stable reference facts: see [REFERENCE.md](REFERENCE.md)
For session history: see [sessions/](sessions/)

---

## Current State

[What's deployed, what's in progress, what's blocked]

## What's Next — Prioritized

1. [ ] [Highest priority task]
2. [ ] [Next task]

## Recent Session: YYYY-MM-DD

[Summary of last session: work done, decisions made]

---

*This file follows the Tiered Context Architecture. Budget: ≤150 lines.*

REFERENCE.md holds maintained requirements, decisions and technical facts that would crowd the entry file. Update a changed URL or roster entry in place. Keep evidence and identify superseded decisions. For a bounded project, 300 lines is a soft budget: reaching it is a reason to examine the scope and separate detail. A standing responsibility can accumulate much more reference knowledge; the current method lets it split that knowledge into topic files under reference/, with REFERENCE.md as their index.

The dated sessions/ archive records what changed, why and where the work can be inspected. Monthly files can retain the history without loading all of it into each session. Older logs and completed task detail leave current context after they have been saved and checked in the archive. In my original routine, session logs older than a week moved into the monthly archive.

A short project may need only CONTEXT.md. In my original routine, approaching 120 lines was the prompt to create reference and history files, before reaching the 150-line limit. Start with the information you need; add the other tiers as it accumulates.

I arrived here through three stages. First I separated active and completed folders and maintained templates and pattern files; that was too much machinery for this work. A flat project directory and one context file simplified the system, but files eventually grew to 500–1,000 or more lines. Running that approach across more than 60 projects over several months exposed the growth problem. Separating current work, reference and history gave old information somewhere to go while keeping it recoverable.

Follow a changed requirement

Consider a project to build a dry-run file renamer. Its job is to report proposed name changes without renaming any files.

The first design, labeled R1, would omit conflicting mappings from its report. The revised decision, R2, requires the report to include them and mark the whole plan invalid. That difference needs to survive the handoff.

An entry in projects/index.yaml gives the work a stable location:

projects:
  - id: build-dry-run-renamer
    path: projects/build-dry-run-renamer
    status: active
    objective: Report proposed rename mappings and collisions without changing files.

The maintained decision in REFERENCE.md carries the rule and its reason:

## R2: Report conflicting mappings

Status: current. Supersedes R1.

The dry run reports every proposed source-to-target mapping.
If multiple sources map to the same target, mark the whole plan invalid
and identify the conflicting mappings. Rename no files.

Reason: omitting conflicts hides part of the requested batch from review.

Illustrative input:
- alpha.txt -> report.txt
- beta.txt -> report.txt

Expected interpretation: retain both mappings in the report, identify
their shared target as a collision, and mark the plan invalid.

Unresolved: requirements for targets that already exist, case sensitivity
and filename normalization still need to be decided.

A session-history entry preserves the change:

## Illustrative decision change: R1 to R2

R1 omitted conflicting mappings from the dry-run report.
R2 retains them and marks the whole plan invalid.
The maintained R2 decision and its reason are in REFERENCE.md.

This entry records a design change. No implementation or test result
is recorded.

The current-state file can stay short:

# Build dry-run renamer

Objective: report proposed mappings and collisions without changing files.
Current decision: R2 in REFERENCE.md.
Saved work: requirements and decision history only.
Implementation and tests: not completed.

Next action: decide existing-target behavior before implementing it;
then turn the agreed requirements into test cases.

Open: case sensitivity and filename normalization.
History: sessions/2026-09.md.

A receiving assistant can now be checked against something precise. If it proposes omitting the two conflicting mappings, it has recovered R1's behavior even if it mentions the current project name and accurately summarizes other details. If it invents a rule for case sensitivity, it has closed a decision the records leave open.

Adapt the headings and fields to the work while keeping each record's job clear. A production project may need a separate design document, issue tracker or test report; reference that maintained source instead of copying its full contents into every record.

Save a checkpoint that can be inspected

At a checkpoint, reconcile the current-state file with the work that actually exists. Link completed work to its artifact, code revision or test result. Keep a proposed change distinguishable from an implemented one, and an implemented change distinguishable from a checked result.

When a decision changes, update the maintained reference and record the change in history, including a pointer to its reason. Preserve the prior decision with its superseded status. For the renamer, changing only the session archive would leave the next assistant reading an obsolete R1 requirement; changing only the reference would leave the session history out of date.

Before shortening current context, save the detail elsewhere and verify that it is present and readable. Then replace the detail with a pointer. This order matters when a conversation is approaching its context limit: a summary cannot supply evidence that was never saved.

Make the routine part of the work

Update the current record after a significant task or phase, while the decisions and results are still available. Waiting until the end of a long session risks losing the details during compaction. The current operating sequence is: complete the task, update the records, verify local continuity, then take the next task. A switch between clients on the same machine does not by itself require a commit; a transfer to another machine needs the appropriate saved and transferred version.

At session start, locate the project in the registry, read its current context, check whether it needs archiving, load the relevant reference, search cross-project lessons and inspect related projects. Resolve an ambiguous project match before editing. At the end, update current state and history, archive and verify older detail, and bring the registry's session information up to date. For shared work, respect the active owners and record the actual handoff state.

These habits address five recurring failures: stale context loses the next step; an oversized entry file buries it; stable facts crowd it; waiting until the end loses details; and ignoring lessons repeats avoidable mistakes.

Project status and naming

The registry distinguishes active work, deliberately paused work, ongoing responsibilities, completed bounded projects and archived records. A bounded project becomes complete when its defined outcome has been checked. Its shorter context preserves the result; archiving retains the history. An ongoing responsibility has no such finish line, but still needs a current state and next action.

Status is a field in index.yaml, not a folder location:

projects:
  - id: migrate-blog-to-astro    # bounded → verb-first outcome name
    name: Migrate Blog to Astro
    status: active
    description: Brief description
    tags: [tag1, tag2]
    last_session: 2025-12-24
StatusCONTEXT.mdREFERENCE.mdsessions/Budget
activeRequiredWhen neededWhen needed≤150 lines
pausedRequiredWhen neededWhen needed≤150 lines
ongoingRequiredWhen neededWhen needed≤150 lines
completedSummaryOptionalOptional≤80 lines
archivedFrozenFrozenFrozenN/A

The naming convention added in July 2026 makes that distinction visible. Bounded projects get a specific verb and outcome: migrate-blog-to-astro, accept-vendor-contract-2026-03, release-kb-company-wide or build-dry-run-renamer. The name states the finish line and makes a bounded project that lingers as active easier to question. It applies the outcome-defined project idea familiar from GTD and OKR phrasing to the slug our tools show us every day. Ongoing responsibilities keep noun names, such as payments-platform or workspace-operations. A time-boxed role can put the period in its name, as in platform-2026-q3.

Generic verbs such as do, handle or work-on add nothing. Nobody names a department “do-operations-work.” If I cannot name a specific outcome, I check whether I am describing an ongoing responsibility or several projects that need separating. Existing projects keep their names; renaming them just to satisfy the convention would churn paths and references. Status remains the maintained lifecycle field. Software teams already use the same distinction: a bounded branch can be fix-login-timeout, while the repository names the ongoing thing.

Turn experience into reusable lessons

Cross-project lessons live in lessons/YYYY-MM-DD-topic-slug.md. For an incident, record what happened, its cause where established, its impact, the lesson and the prevention. For a reusable pattern, record the context, problem, solution and examples. Save the lesson when you learn it, while the evidence and conditions are available.

For incidents/mistakes:

---
type: incident
title: Brief Title
severity: minor | moderate | serious | critical
---

# {Topic}: {Brief Title}

## What Happened
## Root Cause
## Impact
## Lesson
## Prevention

For patterns (generalized insights):

---
type: pattern
title: Pattern Name
---

# {Pattern Name}

## Context
{When this pattern applies}

## Problem
{What problem it solves}

## Solution
{The pattern itself}

## Examples
{Where it's been applied}

A proposed test is not an observed lesson. Link the actual result and the project it came from, so a later reader can judge whether the practice fits a new case. Date prefixes make recent lessons easy to discover without maintaining a second index. Searching them at the start of a project is what turns an archive of mistakes into useful working knowledge.

Establish how each client reaches the records

A conversation's context is the information available to that conversation. Generated memory is a client's saved material from earlier work. Entry instructions direct the client to project records. The records themselves hold the maintained requirements and evidence. These can interact without sharing the same loading rules.

For a client that can read the project files, an entry instruction can be as concrete as:

Find the named project in projects/index.yaml. Read its CONTEXT.md, then the reference and history needed for the current task. Identify the controlling requirement and unresolved conditions before changing files. If the name matches more than one project, resolve that ambiguity before choosing.

Make continuing maintenance part of the same instructions:

After each significant task or phase:

1. Update CONTEXT.md with the current state and next action; keep it within 150 lines.
2. Maintain stable facts in REFERENCE.md.
3. Archive older session detail in sessions/YYYY-MM.md; verify the destination before removing it from current context.
4. Update the project registry’s last-session information.
5. Capture reusable lessons with their source and conditions.
6. Verify local continuity. For a transfer to another machine, save and transfer the intended version and check it at the receiving end.

Maintain these records as part of the work, without waiting for a reminder.

Placing those words in a file is only part of setup. Codex's documented instruction discovery combines global guidance with files along the path from the project root to the working directory. Override names, precedence and a size limit affect that chain. It does not make every project document an automatically loaded instruction.

Claude Code documents different conditions. On supported versions and configurations, it can read AGENTS.md directly. By default, a project's CLAUDE.md, .claude/CLAUDE.md or CLAUDE.local.md along the working-directory path makes it use Claude-specific project instructions instead; user-level and managed guidance do not trigger that choice. Settings can change the selection. Check the documented rule for the client and version you use. These files guide behavior; they do not enforce every requirement as a software control.

Keep shared project facts in their maintained records. Give each client an entry path it supports, and verify that the path reaches the intended files. A reference to a directory does not grant access to it. A colleague or assistant also needs authorization and the tools required to read the records, especially when the project information lives outside the code repository.

Keep project memory in the shared system

I want durable project knowledge in a shared, inspectable system that works across AI tools and computers. I do not want useful decisions scattered through client-specific memory stores, with each assistant maintaining a different account of the work.

Current Claude Code documentation describes auto memory that persists across sessions, with machine-local files shared by worktrees and subdirectories of the same repository. Its memory index loads within stated limits, and detailed topic files are read when needed.

OpenAI's memory documentation distinguishes local Codex memory from ChatGPT web memory. ChatGPT Work uses account and workspace memory settings. It recommends keeping required team guidance in project instructions or checked-in documentation. Their storage and discovery rules differ.

Update — October 5, 2026: On October 1 I changed the native-memory policy described in this section. Memory stays enabled in Claude Code, Codex and Muse Code. The synthesis project records remain primary and win any conflict.

For the renamer, R2 belongs in the maintained project record. A native-memory note saying “omit collisions” carries the superseded rule and needs reconciliation. Native memory can still capture useful new material. I treat it as a capture buffer whose entries need review before they become part of the durable record.

During routine checkpoints and end-of-day reviews, inspect new entries inside each client, using that client's own tools. Check their sources, separate duplicates from new material, and route useful entries to the appropriate project, reference or lesson record under the right access controls. Verify the destination while retaining the source. Raw memory files are never deleted, and disabling memory is not the remedy for conflicting notes. If a client's review or export path has not been verified, record that work as pending.

The July audit found useful notes scattered across project scopes, with no version history in that setup. My recommendation then was to move the knowledge into maintained project records and disable the competing client-local mechanism. The revised policy keeps automatic capture while giving the durable record authority. It preserves the original goal: decisions I can inspect, version, sync and share with the appropriate audience. The companion article on memory handoffs follows one decision through a change of environment.

Check what arrives at the handoff

Version control can record changes and help exchange them. Git's tutorial distinguishes committing a snapshot from transferring and integrating changes. A local commit does not establish that another computer has it; a remote update does not establish that the receiving checkout uses the intended branch or version.

At the receiving end, check the actual route:

  1. Confirm that the expected records and version are present and readable with appropriate access.
  2. Ask the session, through its normal project entry instructions, to locate the governing decision and unresolved conditions. Do not put the answer in the request.
  3. Compare the response with the maintained record, including conditions that would change the next action.
  4. Record a mismatch and repair its cause: missing transfer, inaccessible files, undiscovered instructions, stale version or changed interpretation.

For this example, the comparison includes R2's treatment of both conflicting mappings, the no-renaming requirement and the still-open filename rules. The history explains R1; it should not silently become the current requirement.

Results and team use

In my use, context recovery that had taken more than 15 minutes came down to seconds. Lessons began surfacing when relevant, and patterns became easier to recognize across projects. I stopped writing starter prompts that reconstructed the whole project. Naming the project could take the assistant to its current records. Those were practical improvements in my work with Claude Code and Codex, with private Git carrying the project knowledge between computers. At that stage, I had applied the tiered approach to more than 60 projects in production, and none exceeded the context budget.

The discipline behind that result is straightforward: the record must be current, the assistant must find it, and the receiving environment must actually have it. The handoff checks above make those conditions inspectable.

For a team, imagine Alice's assistant working on authentication on Monday and Bob's assistant continuing on Tuesday. Their shared context, reference, lessons and session history can carry the decisions across the change of contributor. Bob still needs the right version and permission to read it. The project manager's job expands from tracking status to ensuring that useful knowledge reaches the shared system and can guide the next decision.

A parallel in OpenAI's Sora work

The Sora Android case study reinforced my view of how to organize this work. OpenAI described humans establishing the architecture and end-to-end examples, planning tasks before execution, saving plans for later agent instances, and running work in parallel. Human attention became a constraint on the amount of parallel work the team could manage.

The same management principles recur: establish the foundation, give each piece of work a clear plan, preserve the plan between sessions, coordinate agents as a conductor coordinates an orchestra, and treat review capacity as a real limit. That independent convergence reinforces my conviction that durable context and deliberate human leadership are fundamental principles of AI work. Sora became unavailable on April 26, 2026; the December 2025 engineering case remains instructive.

Getting started

Choose one active project. Give it a registry entry and a concise current-state file. Add the lifecycle procedure to the instruction surface your assistant actually reads. Use it for a week, looking for decisions you had to reconstruct or lessons you failed to find. As context approaches its budget, separate maintained reference from dated history and verify the moved material before removing it from the entry file.

The public synthesis-project-management and synthesis-context-lifecycle skills provide the corresponding workflow and record-maintenance instructions to inspect and adapt for your own setup.

Keep the receiving session's answer alongside the version it was checked against, so a later change of client or configuration can repeat the same comparison. Expand the method to other projects as the routine becomes part of how you work.

Earlier revisions: April 27, 2026 added cross-agent use; July 21 added naming conventions; July 22 revised the memory comparison.

Synthesis project management is part of synthesis engineering, an open methodology released to the public domain (CC0).