Synthesis project management is a lightweight system for human-AI collaboration. It solves one problem: when working with AI assistants on multi-session projects, context gets lost.

TL;DR: AI conversation context compacts (gets summarized due to length). Detailed progress disappears. Sessions end and start fresh. Lessons learned sit in folders nobody checks. This system creates persistent state that survives context loss. Your AI assistant starts every task knowing what went wrong last time.

The Problem

When working with AI assistants on projects that span multiple sessions:

• Context compaction: conversation summaries lose nuanced instructions
• Session boundaries: each session starts fresh, no persistent memory
• Multiple projects: confusion about current state across projects
• Lessons learned: valuable insights get written but never surfaced

Traditional project documentation doesn’t solve this. Work logs get written but rarely read. Lesson files sit in folders until someone remembers to check. The documentation exists, but it doesn’t work.

Design Principles

Five principles guide the system.

1. Discoverability over documentation. Agents can search and grep. Humans need quick orientation. Prefer consistent naming conventions over maintained indexes.

2. Convention over configuration. Consistent structure means less cognitive load. When everything follows the same pattern, both humans and agents know where to look.

3. Single source of truth. No duplicate indexes to maintain. Files should be self-describing through front matter and naming conventions.

4. Self-describing files. Date prefixes, status in index.yaml, front matter metadata. No separate documentation that can get stale.

5. Agents do the work. Templates are a pre-AI pattern. To create something new, examine an existing example and adapt it. Agents excel at this.

System Architecture

Everything lives in one location within your workspace:

projects/
├── index.yaml               # Single index for ALL projects (status field, not folders)
│
├── {project-id}/            # Project folders (flat structure)
│   ├── CONTEXT.md           # Living state for active projects
│   ├── README.md            # Static documentation (sufficient for completed)
│   ├── work-logs/           # Session logs for this project
│   │   └── YYYY-MM-DD-*.md
│   └── resources/           # Project data and artifacts (optional)
│
└── _lessons/                # Cross-project lessons and patterns
    └── YYYY-MM-DD-*.md      # Date-prefixed for discoverability

Key Decisions

The Critical Artifact: CONTEXT.md

Every active project needs a CONTEXT.md file. This is the most important component.

# Project: {Project Name}

## Overview

{1-2 sentence description of the project goal}

**Started:** YYYY-MM-DD
**Status:** {In Progress | Blocked | Complete}

## Current State

{What has been accomplished. Be specific about artifacts created.}

**Key artifacts:**
- `path/to/file1` - Description
- `path/to/file2` - Description

## Next Steps

1. [ ] First thing to do
2. [ ] Second thing to do
3. [ ] Third thing to do

## Blockers

{Any blockers preventing progress. Remove section if none.}

## Key Decisions

| Decision | Rationale | Date |
|----------|-----------|------|
| Chose approach A over B | Reason for choice | YYYY-MM-DD |

## Session History

| Date | Summary |
|------|---------|
| YYYY-MM-DD | What was accomplished in this session |

Update when: After EVERY significant task or phase completion. Not at session end. Immediately. This is non-negotiable.

The Protocol

During Work

Complete task → Update CONTEXT.md → Commit → Next task

NOT:

Complete task → Complete task → Complete task → (context compaction) → Lost details

Context compaction can happen at any time during long sessions. If CONTEXT.md is stale, all detailed progress is lost.

Session Start

1. Read CONTEXT.md. Understand current state before touching code.
2. Search _lessons/. Run grep for relevant past experiences.
3. Check related projects. Look at related: tags in index.yaml.

Session End

1. Final CONTEXT.md update. Ensure all sections are current.
2. Update index.yaml. Set last_session date.
3. Create work log. If significant session, add to {project-id}/work-logs/.
4. Commit all changes. Don’t leave uncommitted work.

Project Status Model

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

projects:
  - id: my-project
    name: My Project Name
    status: active
    description: Brief description
    tags: [tag1, tag2]
    last_session: 2025-12-24

Active projects need living state tracking. Completed projects are static documentation.

Lessons: Cross-Project Learning

The _lessons/ folder captures mistakes, insights, and patterns that apply across projects.

File naming: YYYY-MM-DD-topic-slug.md

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}

Update when: Immediately when you learn something reusable. Don’t defer.

AI Assistant Integration

Add to your CLAUDE.md:

## Synthesis Project Management

After completing ANY significant task:

1. **Update CONTEXT.md immediately.** Don't wait until session end.
2. **Update index.yaml.** Set last_session date at session end.
3. **Add to _lessons/.** If you made a mistake or learned something.
4. **Create work-logs/ entry.** For significant sessions (in project folder).
5. **Commit to git.** At logical checkpoints.

**Location:** `{workspace}/projects/`

The user should NEVER have to remind you to do this.

Project Discovery

When a user mentions a project:

1. Read projects/index.yaml
2. Match against project name, description, id, tags
3. If match found, read the project’s CONTEXT.md
4. Summarize current state and next steps
5. Begin work from where it left off

This eliminates starter prompts. Say “working on the API project” and the AI loads context automatically.

Results in Practice

This system is operational.

Context recovery dropped from 15+ minutes to seconds. Lessons get surfaced proactively instead of sitting forgotten in folders. Pattern detection works across projects. Session handoffs are seamless because the state lives in files, not conversation memory. Starter prompts are gone; semantic project discovery replaced them.

Common Mistakes

Teams: Multiple Humans, Multiple AI Assistants

The system scales. When Alice’s AI works on auth Monday, Bob’s AI knows about it Tuesday.

Shared knowledge artifacts:

• CONTEXT.md files in shared repos
• Lessons learned in central location
• Semantic indexes spanning the team

The project manager’s role evolves. It shifts from tracking status to ensuring knowledge flows into the shared system.

Parallel Discoveries: OpenAI’s Codex

After publishing this article, I read OpenAI’s case study on shipping Sora with Codex . Several patterns emerged independently:

• Planning before coding. Extensive planning before implementation.
• Foundation-first. Humans design structure, AI executes.
• Conductor model. Coordinating AI agents like an orchestra.
• Review as bottleneck. Human time shifts from writing to deciding.

The convergence validates that these aren’t arbitrary choices. They’re fundamental principles.

Getting Started

1. Add CONTEXT.md to one active project.
2. Create index.yaml in projects/ with your project entries.
3. Add session protocols to your CLAUDE.md.
4. Use it for a week. The benefits compound quickly.
5. Expand to other projects.

The complete system is available as an open-source runbook: synthesis-project-management.md .

Evolution Notes

This system evolved from a more complex structure.

We removed active/ and completed/ folders because status belongs in index.yaml. We removed templates/ because agents examine existing examples and adapt. We removed meta/patterns.md because patterns are lessons with type: pattern. We removed lessons-learned/index.md because date prefixes enable discovery without indexes. We moved work-logs/ inside each project folder. We renamed lessons-learned/ to _lessons/ so the underscore distinguishes it from projects.

The simplification came from asking: what do humans need vs what do agents need?

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

Rajiv Pant is President of Flatiron Software and Snapshot AI , where he leads organizational growth and AI innovation. He is former Chief Product & Technology Officer at The Wall Street Journal, The New York Times, and Hearst Magazines. Earlier in his career, he headed technology for Condé Nast’s brands including Reddit. Rajiv coined the terms “ synthesis engineering ” and “ synthesis coding ” to describe the systematic integration of human expertise with AI capabilities in professional software development. Connect with him on LinkedIn or read more at rajiv.com .