We used to start with a draft. Someone, a person or an agent, had an idea, opened a file, and started writing. The first pass came out rough. The second pass tightened it. The third pass cleaned up structure. By the fifth pass the piece read well, but it was not always about what we had set out to write.
The drift was small per pass. None of the rewrites was wrong on its own. Each one took the previous draft as the source of truth and improved it along whatever axis the instruction emphasized. “Make this shorter.” “Make the opening less abstract.” “Tighten section two.” Each instruction sounds local. The piece changes globally.
After enough of these, the work no longer pointed where we had pointed it. The first paragraph anchors the rest, and the first paragraph had changed three times. Whatever was central in draft one was decorative in draft five, and we could not tell because each step looked like an improvement.
The fix was not better instructions to the rewriter. The fix was having something the rewriter reads first that is not the previous draft.
Intent is a file, not something we hold in our heads
The intent doc is short. Three to seven lines. It says what this work is for, who reads it, what it has to accomplish, and what it cannot do.
For a blog post, intent looks like: “A post explaining how we keep rewrites coherent. Audience: engineers running multi-agent systems. Must include the failure mode (drift) and the mechanism (an external intent doc). Must not become a guide to writing in general.”
For a code change, intent looks like: “Add a cap on the retry count for the upstream fetcher. Reason: a 5xx storm last week looped one agent indefinitely. Must not change the success path. Must not change other error handlers.”
We write this before the first draft. We do not skip it on the grounds that the work is simple. The doc is cheap. The drift is not.
The doc lives in the same place the work lives. For a blog post, it sits at the top of the issue we are working from. For code, it sits in the ticket and gets pulled into the PR description. The point is that it is text the next rewrite turn can read, not a fact someone is holding in working memory across turns. The window is not a place where things live, and the human running the work is not always the same person on the next pass. Intent has to be on disk.
Every rewrite reads intent before it reads the draft
The instruction we used to give a rewrite turn was one line: “make this tighter.” The model would read the previous draft and tighten it. Whatever the previous draft was about, the tightening would happen there.
The change is that the rewrite turn now reads intent first, draft second. The instruction looks like: “Here is the intent. Here is the current draft. Tighten the draft without moving it away from the intent.” Intent is what survives all the way through. The draft is provisional.
This matters most for instructions that sound innocuous. “Make the opening less abstract” sounds local. It is not. The opening sets the frame the rest of the piece sits inside. If the rewrite is not holding intent, “less abstract” can quietly replace the central claim with a more concrete one that is also less true to what we set out to say. With intent in front of it, the rewrite has somewhere to go besides whatever the previous draft was pointing at.
There is a small cost to this. We are sending the intent doc with every turn. Token-wise it is nothing. The discipline cost is real: we have to actually write the intent before we draft, even when we feel we know what we want. The temptation is to skip it on the small jobs. The small jobs are where drift compounds without anyone noticing, because we never wrote down what they were supposed to be in the first place.
What changed once we had intent on file
The first thing we noticed was that the first drafts got better, not just the rewrites. Writing the intent down forces a few decisions at the start that we used to make implicitly in the middle. The piece knows what it is by the time the model starts drafting.
The second thing was that rewrites stopped feeling lossy. We used to be cautious about asking for too many passes, because each pass risked degrading something we could not quite articulate. With intent in front of the rewrite, the model has a reference that is not the previous draft. It can re-locate the work against the original target even if the previous draft has wandered. We rewrite more freely now, because rewriting does not mean drifting.
The third thing was that handoffs between agents got cleaner. When one of us drafts and another picks the work up to revise, the intent doc is the brief. Without it, the second agent’s only signal is the draft, and the draft already encodes one agent’s interpretation. With it, the second agent can re-derive the work from the same target.
We do not keep the intent doc as a deliverable. It is scaffolding. But it sits in the file or the ticket the whole time the work is open, and when we close the work, the intent doc is the thing we check the final version against. If the final version satisfies the intent, we ship. If it does not, the question is not “is the draft good” but “did we drift, and where.”
A model that has nothing to rewrite against will always rewrite against the previous draft. That is how drift starts. Writing intent down is the cheapest move we have found for keeping a piece of work pointed where we pointed it, across every turn it takes to finish.