Open a new session with an AI coding assistant and it knows nothing about yesterday. Not the feature you were halfway through, not the constraint you discovered late in the afternoon, not the approach you agreed to try next. The context window emptied when the session closed, and the working memory went with it.
The common response is re-explanation. Every session opens with the same ritual: paste the goal, describe the architecture, summarize what has been tried, hope you remembered the parts that matter. It works, badly. Re-explanation is lossy, it consumes the first stretch of every session, and the quality of the assistant’s output tracks the quality of whatever you happened to retype that morning.
Oliver Felix, an engineer I work with, stopped paying that tax, and his method carried a single feature across eight working sessions without losing the thread. I am telling his story with his permission, reconstructed from my own working records rather than from a transcript. Some details are changed or left out to keep the client and the product out of it, and I would rather say so than let you assume otherwise. The working method is the part I have kept faithful, and it is the only part I would defend as reportage. The pattern is the point, and the pattern transfers.
The feature was a redesign of an editor interface: work too large for one session and too interconnected to hand off casually. His verdict on the old way was blunt. My record of it has him calling refinement without a context file tedious, slow, and very unfocused in its results. Anyone who has pushed an assistant through a multi-session feature knows that texture. Each session starts over, warms up slowly, and wanders, because the assistant is optimizing against whatever partial context that day’s re-explanation happened to include.
One file, two owners
What he built is one markdown file per feature, a CONTEXT.md that lives with the code and outlives every session. The structure is small enough to hold in your head. Three sections belong to the human: Problem, Goal, and Next Steps. Two belong to the AI: Changes Made, appended every session, and Suggestions. Each session opens the same way, with one instruction pointing the assistant at the file for its next piece of work.
The ownership split is the design decision that makes this more than a notes file. The human-maintained sections carry direction: what problem we are solving, what done looks like, what to do next. The AI-maintained sections carry the record: what actually changed, file by file, session by session, and what the assistant thinks should happen but has not been told to do. Direction flows down from the person. The record accumulates up from the machine that did the work. Neither writes in the other’s sections.
Note what the file is not. It is not a transcript of past sessions, which would grow without bound and bury the signal. It is not an auto-generated summary that nobody audits. Every line is either direction a human wrote or a record the assistant appended under a structure a human designed. The file stays useful because it holds decisions and changes, not conversation.
Across the editor redesign, that one file accumulated the record of eight sessions of iterative refinement. Each new session opened with the assistant reading what the previous sessions had done and where, then picked up where the last one left off, not because the model remembers (it does not) but because the handoff was written down at every close and read at every open.
The section doing double duty
The workhorse of the structure is Changes Made: one line per change with the file it touched, appended by the assistant each session. Read by a human, it is a changelog. Read by the assistant at the start of the next session, it is a context refresh. The assistant immediately knows what was done and where, without a person retyping any of it. One section, maintained as a by-product of the work, serving as both the record and the reload. That is powerful, and it is not obvious until you watch it work.
Suggestions earns its keep too. Assistants volunteer ideas constantly, and an idea that lands mid-session either derails the work or evaporates. Routing ideas into a section the AI owns keeps them from being lost, and keeps them out of the direction sections until a person deliberately promotes one into Next Steps. Advice never silently becomes a decision.
Where this sits in a larger architecture
Readers of my earlier writing will recognize the shape. The tiered context architecture manages AI working memory at project scale: budgeted context files, session logs, reference tiers, archival. Oliver applied the idea at feature scale and added something my version had not standardized: the explicit split between human-maintained and AI-maintained sections. I now treat that split as his contribution to the practice, a pattern worth standardizing, because it encodes the collaboration itself into the file. The person decides and directs. The AI does the heavy lifting and keeps the books. That division, written into a file’s section headers, is synthesis coding (sustained, structured human-AI collaboration) at its most concrete.
Run it on your next feature
The pattern transfers without any tooling. On your next feature that will outlive one session:
- Create the context file before the first session, with the problem, the goal, and the first round of next steps in your own words.
- Declare ownership in the file itself: which sections you maintain, which sections the assistant maintains.
- Open every session by pointing the assistant at the file before anything else.
- Close every session by having the assistant append what changed and where, one line per change.
- Keep the assistant’s proposals in its own section, and move one into next steps only when you have decided to do it.
- When the feature ships, fold what mattered into your project-level records and retire the file.
The habit costs a few minutes per session. The eight-session case above shows what it buys: work that had been tedious, slow, and unfocused without the file ran across eight sessions on a single thread, with the full history of the feature one file-read away.
None of this requires a platform feature or a bigger context window, and none of it waits on a vendor roadmap. Continuity between sessions is a designed artifact. The eight-session feature stayed coherent because Oliver decided that memory would be a file, wrote down who owns which parts of it, and made reading it the first act of every session. Multi-session AI work is not blocked on better memory. It is blocked on someone writing it down.