Why I Stopped Letting Claude Write Design Files in the Same Session as the Prose
One session holding both jobs doesn’t save tokens — it produces prose that reads like a design caption and a design brief that reads like a paragraph.
A few months ago, I had one Claude session draft a blog post AND build the cover image for it. Single session, single context, fewer dispatches. It felt clean.
The prose came out sterile. The cover came out wordy. The session ran about 60,000 tokens longer than it should have. Looking at the two artifacts side by side, they were doing the same thing twice: both leaning on the same metaphor, both pacing for the same beat, both compromised because the session couldn’t tell whether it was a writer’s session or a designer’s session.
Article 1 was about the orchestrator/worker boundary. The top of the role tree. This article is one layer below: worker vs worker. Same class of leak.
Why I thought one session was fine
The argument felt obvious. Same context, less switching, fewer dispatches. If I’m writing a piece about a diagram, surely the session that holds the diagram concept can write the piece. The brain doesn’t separate “the words” from “the visual,” so why should the session?
It also seemed cheaper. One context window costs less than two, unless the context fills with two different kinds of files and helps neither of them.
That’s where the math broke.
What actually broke
Three things went wrong in the same session.
Outputs converged in tone. The prose started picking up the visual vocabulary I’d loaded for the design step (“stacked,” “bordered,” “rule of thirds”), and the design brief started picking up the prose’s rhythm cues. Both outputs landed in the middle. The piece read like it was describing a slideshow. The slideshow read like it was illustrating a paragraph.
Context filled with cross-domain files that didn’t help either output. The session had a brand voice doc open for the prose. It also had a color palette spec open for the design. Plus a tone reference for the writing. Plus a headline-example file for the cover. By the time it was generating, the context was a hybrid that neither role would have loaded on its own. None of it was wrong. All of it was noise.
Voice slipped because design vocabulary leaked into the prose. I caught a paragraph that read like a design caption: short, declarative, list-flavored, the way an image annotation reads. Fine for the cover. Wrong for the article. The session couldn’t tell the difference because it was holding both jobs at once.
The artifacts shipped. Then I rewrote both. The savings from one session got spent twice over on cleanup.
The boundary rule
One sandbox per session. Cross-sandbox work is a dispatch, not a continuation.
The content worker writes prose. The design worker builds visuals. The animation worker renders motion. Each runs in its own context with its own configs, its own reference files, its own voice. A piece that needs both prose and design is two dispatches, not one session that wears two hats.
The boundary holds for the same reason the orchestrator/worker boundary holds. Mixing roles inside one context costs more, drifts more, and produces work that reads like a compromise between two jobs neither of which got done well.
If the content worker needs the design output as input, the brief carries it across. The handoff is the dispatch. That’s the seam. (Article 8 unpacks the brief-as-contract pattern that makes this clean.) Two clean sandboxes connect through a clean brief. One messy session connected to itself is the problem.
Markers that you’ve crossed the boundary
If any of these show up in a single session, you’ve stopped doing one job and started doing two badly.
The session has a brand voice file AND a design system file open. Each belongs to a different worker. If both are loaded, neither output is going to be sharp.
A single output references both color and sentence structure. “Make the headline shorter and use the warm-orange accent” is a brief, not an artifact. If a single piece of work needs that sentence to describe it, the work itself has crossed roles.
The session’s loaded files come from two different worker folders. Same signal as the first marker, one level more concrete. Two folders open in one context means two sandboxes in one session.
Outputs need cleanup specifically because they sound like the other job. Prose that reads like a caption. A design brief that reads like a paragraph. The session couldn’t separate them; you have to.
You start a session “to just check something” in a worker folder you’re not currently working in. The “just check” is the moment the boundary breaks. The check belongs in its own session.
The fix when a marker hits isn’t to clean up the output. The output isn’t the bug. The bug is the session held both jobs.
What I’m giving you, and what I’m not
You have everything you need to apply this: the boundary rule (one sandbox per session).
The five markers.
The brief-not-continuation seam between sandboxes.
The reason the leak costs more than it saves.
What I’m not giving you: my specific worker folder structure, my brief schema, the names I use for the sandboxes. Those are shaped to my work the same way Article 1’s brief templates are. The roles you need will look different. The principle is what travels.
The principle is small enough to say in one line. The first time you catch a session reaching across, you’ll see the cost. After that, dispatching feels cheaper than holding both jobs in your head.