Playbook · Part three of three

Running a Studio Session

Sometimes the enormous window is the entire point. Here's how to spend that money deliberately instead of leaking it, and where the cheap-session advice becomes actively wrong.

Part one measured three months of my sessions and found 86% of the cost was context. Part two built the cheap default. This part is about the sessions where you want the expensive shape on purpose, and how to keep them from turning into marathons.

The work that justifies it

Some jobs genuinely need everything in the room at once. Editing chapter nine so it doesn't repeat a callback from chapter four means the model has to know chapter four. Deciding where a new service belongs means holding the architecture in mind, not a grep result from it. Doing a consistency pass across forty pages of copy means all forty pages, together.

For that work, a lean window produces confidently wrong answers. The model will happily tell you chapter nine reads fine, because it never saw chapter four. That's a worse outcome than a bigger bill.

The distinction that matters is between context you loaded on purpose and context that accumulated while you weren't looking. Same token count, completely different value. A studio session is the first kind, kept honest by a few rules.

Paying for a big window is fine. Paying for one you didn't choose is the leak.

The three-question test

Before committing to the expensive shape, three quick checks. Any "no" and this is assembly line work wearing a costume.

Question one

Does the answer change based on material outside the file I'm editing?

Voice consistency, repeated arguments, architectural fit: yes, obviously. Fixing a date parser: no, that's one file and its tests.

Question two

Would a summary of that material be good enough?

If a two-paragraph digest of chapter four would do, send an agent and stay lean. If you need the actual prose, because rhythm and phrasing are the thing you're judging, that's a real studio session.

Question three

Is this one continuous job, or several jobs I'm bundling?

The killer. My worst session was legitimate studio work with five unrelated errands stuffed inside it. The errands paid the studio's rent on every call, for nothing.

Rule 1: declare it, and write down the corpus

A studio session starts by saying what it is out loud and listing exactly what belongs in the window. Writing the list down does something subtle: it makes additions later feel like a decision rather than a reflex, which is precisely the discipline that keeps the plateau flat.

CORPUS.md, sitting in the project folder
# Corpus: Book 3 voice and consistency pass

## Load at session start, in this order
1. STYLE-BIBLE.md            voice rules, banned constructions, cadence
2. CHARACTERS.md             who's who, what each one has already said
3. chapters/ch01-ch08.md     the established material we must not contradict
4. chapters/ch09.md          the chapter under the knife

## Deliberately NOT loaded
- research/  (agent fetches specific facts on request)
- The other two books. Different voice, different problem.
- Anything about the website, deploy, or admin. Different session.

## Budget
Expect ~400K after load. Ceiling for this session: 700K. At 700K: finish
the current chapter, checkpoint, close.
Load order isn't cosmetic. Caching works on a prefix, so whatever sits earliest and changes least gets cached most effectively across turns. Stable reference material first, the thing you're actively editing last. Load it the other way round and you re-pay more of the window every time the working file changes.

Rule 2: the plateau, and holding it

The shape you want looks like a hill followed by a long flat table. One climb during loading, then dead flat for the rest of the session. What turns a studio into a marathon is the drift: one more file, one more log, one more screenshot, each individually reasonable, together fatal.

Phase 1 · Load

Read the corpus in the declared order. This is the only part of the session where the window is allowed to grow.

Phase 2 · Work

The window holds flat. Facts come in via agents as short answers. Output goes out to disk. Nothing new gets read in.

Phase 3 · Close

Checkpoint at the declared ceiling. End the session. Don't extend it because you're on a roll.

The prompt that sets the plateau
This is a studio session for the chapter 9 voice pass.

Load, in this order: STYLE-BIBLE.md, CHARACTERS.md, chapters/ch01-ch08.md,
then chapters/ch09.md. Tell me the context size once loaded.

For the rest of this session: don't read any new files into our conversation.
If you need a fact from research/ or anywhere else, use an agent and bring
back the answer only. Write all drafts to files. Keep replies here short,
since every turn re-pays this whole window.

That final sentence changes the model's behaviour more than you'd expect. Told that each turn is expensive, it consolidates: fewer, denser replies instead of a stream of chatty ones.

Rule 3: batch your questions

In a 400K window every message you send re-pays 400K. Four questions asked separately cost four times what the same four cost bundled. This is the single biggest behavioural difference between a studio session and normal chatting, and it's the one that feels most unnatural.

I keep a scratch file open and let questions accumulate until I've got three or four, then send them as one turn.

Batched, not drip-fed
Four things on chapter 9, answer all of them then stop:

1. Does the Dmitri callback on page 3 land, or does it just repeat ch4?
2. The pricing anecdote runs long. Cut it, or is the detail earning its space?
3. Any voice-bible violations, quoted with line references?
4. Better title for the middle section than "Getting Started"?
The interruption tax is real. One quick unrelated question in a 400K studio session costs about as much as twenty questions in a lean one. If something unrelated occurs to you mid-session, write it on a note and open a separate session for it later. That's the whole discipline in one sentence.

Rule 4: rules live in files, not in the chat

If you find yourself re-explaining your voice rules, your naming conventions or your architectural constraints every session, those belong in a file the corpus loads. Stated once at the top of a session, they're part of the cached prefix. Re-explained in message twelve, they're a permanent addition to a window that's already expensive.

STYLE-BIBLE.md, abbreviated
# Voice rules

## Never
- Em-dashes. Use commas, colons, or a full stop.
- "It's not X, it's Y" constructions. Say the thing you mean.
- Staccato fragments for emphasis. Write full sentences.

## Always
- Contractions. This is a person talking, not a manual.
- Lead with the outcome, then the supporting detail.
- Concrete numbers over adjectives. "36M tokens", not "much cheaper".

## Cadence
Vary sentence length. A long one that carries the argument, then a short one
that lands it. Never three short ones in a row.

The bonus is that the same file works for the agents you spawn. Hand a subagent the style bible path and its output comes back in voice, instead of you rewriting it afterwards.

Rule 5: raise the purge line on purpose

My default forces a purge at 250K, which is right for ordinary work and wrong here, because a studio session's whole value is the material staying loaded. So the ceiling gets raised deliberately for these sessions and only these.

Project settings for the writing folder
{
  "autoCompactWindow": 700000,
  "precomputeCompactionEnabled": true
}

Two things to keep straight. This is a per-project override, so it applies where the book lives and nowhere else. And 700K is a ceiling you intend never to reach, since the plan is to checkpoint and close before it fires. If auto-compaction is firing in a studio session, the corpus was too big for the job, or errands crept in.

Rule 6: close it properly

Studio sessions are the ones you're most tempted to keep alive, because reloading the corpus tomorrow costs real money and it's right there, already warm. That temptation is exactly how my 3.5 billion token session happened. The corpus reload is a fixed one-time cost. Extending a full session is a cost you pay on every single call for the rest of its life.

Exit ritual
We're closing this session. Before we do:

1. Write the chapter 9 edits to disk if anything is still unsaved.
2. Append to STATUS.md: what changed in ch9, what's still open, and anything
   we noticed about other chapters that needs its own pass later.
3. Add any new voice rules we discovered to STYLE-BIBLE.md.

Then stop. Next session reloads the corpus fresh.

Where part two's advice is wrong here

Assembly line ruleIn a studio session
Grep, then read a sectionWrong for the corpus. Judging rhythm and consistency needs whole chapters. Right for everything outside the corpus.
Delegate reading to agentsHalf right. Delegate fact-fetching, never the material you're judging. An agent's summary of your prose isn't your prose.
Purge at boundariesNo. Purging mid-session destroys the thing you paid to build. Purge by ending the session.
One task, one sessionStill true, and matters more here. This is the shape that punishes bundling hardest.

What good looks like

SignalHealthy studioMarathon in disguise
Context shapeOne climb, then flatSawtooth, repeated compactions
Files read after loadingZeroSteady trickle all session
Task varietyOne kind of workEdits, plus builds, plus admin
EndingCheckpoint, then closedStill open two days later

Done well, a studio session is one of the most valuable things you can run. The model holds the whole picture, catches the contradiction on page 200 that you'd forgotten about, and does work that a lean window genuinely cannot. It just has to be a decision you made, with a shape you're holding on purpose, and an ending you actually reach.

Part three of three. Part one has the data, part two has the cheap default. Settings shown are Claude Code's settings.json, though the discipline ports to any assistant that carries conversation context.

Liked this? The book goes deeper.

The Artificial Advantage: the frameworks behind everything here, written for professionals, not programmers.