You hand me a 30-page technical document and ask me to turn it into a 2000-word beginner-friendly introduction — readers are general people with no technical background. Plain style, lots of examples, no dense jargon.
Your first instinct is usually: write one complete prompt, stuff "rewrite + plain language + examples + length + topic count" all into it, hit send, wait for the result.
That's the surest way to make me drift.
What this chapter teaches isn't "write a longer prompt." It's break the task into two passes — in the first pass I only organize, in the second pass I actually write. In between, you take a look at the organized result, fix a few spots, and hand the corrected version to the second pass.
This approach is called the two-stage method.
11.1 Why two stages are more stable than doing it all at once
Doing it all at once is unstable, with three reasons stacking on top of each other.
1. Cognitive load comes down
Chapter 10 mentioned this: in long tasks I get squeezed — understanding the material, executing the output, following the rules, self-checking, four things crammed into the same head. Doing it all at once, I have to handle organizing (digesting the topic structure of the entire 30-page document) and writing (language / length / paragraphing / style) simultaneously — the squeeze is at its worst.
After splitting into two stages: in Stage 1 I only organize, cognitive load is just "digest + list points"; in Stage 2 I only write, cognitive load is just "take the organized material and write it out in your format." Each stage is simple on its own.
2. Human review is easier
The output of one stage is the finished product: a 2000-word beginner introduction. Did the organizing fall short? Did facts drift? Did the style go off? You can't easily slice them apart — three problems mixed into the same article, you have to read while catching "is this sentence not in the source? is this subhead something I split off myself? is this tone what I wanted?"
The output of two stages is in two layers: Stage 1's organized result (lists / outlines / structure), Stage 2 is the finished product. You can check them separately — at the organizing stage you check "is anything in the material missing, did I write in content that wasn't there"; at the writing stage you check "did the style and length stay on track."
3. Errors don't snowball
In a one-stage run, if the organizing is wrong, the writing takes the wrong thing as fact and amplifies it — factual errors, style drift, structural drift all come out together. You see the finished product is off, you don't know where to start patching.
In a two-stage run, if the organizing stage misses a section or invents an extra number, you fix it at the organizing stage. By the writing stage, factual risk has already converged, and I'm only handling language and structure — even if I get something wrong, it won't reach the factual layer.
11.2 Stage 1: organize (the goal is completeness, not polish)
Stage 1 has only one goal: organize the material until it's complete. Not write it nicely.
A typical Stage 1 output looks like this:
- Core concepts: the ones non-technical readers absolutely have to grasp (5–7 items, each with a one-sentence plain-language explanation)
- Secondary concepts: skippable, mention-in-passing (list however many there are)
- A list of terms that need plain-language renderings
- Context gaps: things the original assumes the reader already knows but ordinary people don't
No style requirements. No word-count requirements. No genre requirements.
The Stage 1 prompt should be written deliberately plain.
Why deliberately plain? Because style instructions pull cognitive load right back in. If you write "plain style, short sentences, lots of examples" in Stage 1, while I'm organizing I'm also thinking "how do I phrase this section to sound plain" — the load of organizing itself gets diluted.
A Stage 1 prompt looks roughly like this:
Note: this prompt has no "write in plain language," no "lots of examples," no "2000 words" — those are all left for Stage 2.
11.3 Stage 2: writing (this is when you talk about style, length, and structure)
Stage 1's output, after you've reviewed and corrected it, goes to Stage 2.
What does the Stage 2 prompt look like?
Two key points:
1. This is the stage where you specify style / length / structure
Everything Stage 1 didn't ask for (plain language, examples, word count, paragraphing) is given here in one shot. All I have on my plate is "writing"; cognitive load is focused on this one layer.
2. End-restate the core constraints
Notice that toward the end of the output requirements I wrote "use only the core concepts from the organized result" and "keep the 'needs further verification' markers" — this is Chapter 10 Principle One's end-restatement: opening rules fade in the mid-to-late part of long output, so write them again at the end to re-anchor.
Stage 2 only writes, it doesn't go back and do analysis. If you spot in Stage 2 "hmm, this concept doesn't seem fully explained" — go back and fix the Stage 1 organizing, then rerun Stage 2. Do not let Stage 2 "patch in some analysis" on its own — once it patches, factual risk comes back.
11.4 Side by side: one stage vs. two stages
Same 30-page technical document, two approaches.
One-stage prompt:
Hit send, wait for the result.
Typical result:
- The first two paragraphs are plain; by the third paragraph jargon starts creeping in (style drift)
- I felt one concept needed a relatable everyday example — I made one up, and got it wrong (factual drift)
- It was supposed to be 4–5 topics, by the end it became 7 (format drift)
- You see the finished product is off, and you have to dig the 30-page document back out and check it section by section
Two-stage prompt:
Stage 1: organized result → you take a look and find:
- One core concept's plain-language explanation drifted off-direction — you correct one sentence
- I rendered one term in a way that sounds reasonable but veers from the original meaning — you change it to a version closer to the source
- A concept I put in "secondary," you judge readers absolutely have to grasp — you promote it to "core"
(These three corrections take you two or three minutes.)
Stage 2: write based on the version you corrected.
Result: the factual layer (whether concepts are right, whether terms are rendered accurately) is already what you reviewed; the writing layer only handles language and structure — style might still drift slightly, but it won't drift to facts at the same time. When you look at the finished product, you only have to watch style and structure; you don't have to go back and check 30 pages of source material sentence by sentence.
11.5 Three stages, four stages: how to decide how many
Two stages is the starting point. Longer, more complex tasks can be split into more.
- Three stages: organize → outline → write
- Four stages: organize → outline → write → proofread
The criterion isn't complicated: each stage does one thing, cognitive load stays simple.
If within one stage, you find yourself giving me instructions like "organize the key points first, then decide topic order, then write" — three things, then split it into three stages.
Are more stages always better? No. Each extra stage is one more pass of human cost — you have to look once more, correct once more. In practice two to three stages cover the vast majority of scenarios; four or more is only worth it for genuinely complex tasks (across multiple long documents, requiring multi-round comparison and analysis).
11.6 The mid-process human hand-off is the value of the entire flow
This section is about the most misunderstood part of all this.
A common practice is to turn two stages into "have the AI auto-run two rounds with no one looking in between":
- First prompt: organize
- Second prompt: write based on the organized result
- The two prompts run automatically chained together, no one steps in mid-process
Done this way, the value of two stages drops to nearly zero.
Why? Because the organized result Stage 2 receives — is something I produced myself. If I missed material in Stage 1, padded in an extra section, or wrote speculation as fact — what Stage 2 gets is that flawed organized version. Stage 2 writes from it, and the result still drifts.
This is exactly the Pseudo Self-Check I described in Chapter 1 — me looking back at myself, unable to see the problem.
The key to two stages catching factual risk is not "splitting it into two prompts" — it's "having a person take a look in between and correct a few spots."
That person is you.
Without your one glance in the middle, two stages degenerates into "a longer one-stage" — cognitive load does come down, but factual errors get no chance to be caught.
The line humans say most often is "I don't have much time, doing it all at once is faster." In practice it usually goes like this:
- Spend 10 minutes writing a one-stage prompt, the output isn't satisfactory, spend 20 minutes revising the prompt and rerunning, then spend an hour fixing it by hand
- Spend 5 extra minutes upfront splitting into two stages, 3 minutes stepping in mid-process, save 30 minutes downstream overall
"Doing it all in one pass" is what I'm asked for most often — and what I screw up most often.
A note on timing: this advice was written in 2026. AI is improving every year on long-task handling, every platform is stretching the length they can stably process — so the task scale that requires "two stages to be stable" will gradually rise. But two underlying principles won't be overturned in the short term: split until cognitive load is simple, and mid-process human hand-off; the latter solves Pseudo Self-Check, which has nothing to do with how the model's capabilities evolve.