The Six-Layer Framework (The Internal Structure of a Prompt)

You hand me a transcript of last week's customer interview and ask me to organize it into a one-page list of product improvement suggestions — clear priorities, ready to hand directly to the engineering team.

You write a prompt and send it. What comes back is wrong. You revise — add a word count, add style instructions. Still wrong. You revise again — attach an example format you like.

By the third or fourth revision, you should have a familiar feeling: it's not that one particular line was wrong, it's that something is missing.

This chapter is about that feeling.

When I read a prompt, what I see isn't actually a flat block of text — I automatically split it into several internal slots: what you want me to do (task), with what material (background), what the output should look like (format), what counts as well done (judgment criteria), is there an example (demonstration), and should I verify the work after I'm done (verification).

Six slots. Each layer you fill in, I follow that layer. Each layer you skip, I fall back on my defaults — and my defaults usually don't match what's in your head.

This structure is called the six-layer framework.

In Chapter 5 I taught you the three-line template: [Task] / [Input] / [Output requirements]. Three lines. Send.

So why is this chapter about six layers? Wasn't three lines enough?

Two things up front.

First, the three-line template has not been deprecated. For simple tasks (summarizing an article, polishing a paragraph, writing a short email), three lines is enough — and writing a fourth, fifth, and sixth line will only cost you more time without improving the result.

Second, the six-layer framework is an upgrade to, not a replacement of, the three-line template. [Task] in the three-line template = Layer 1 of the six layers; [Input] = Layer 2; [Output requirements] = Layer 3. The last three layers (judgment criteria, examples and anti-examples, verification flow) are extensions only complex tasks need.

So the path is:

• Simple task (writing an email): three lines is enough
• Complex task (rewriting a report, producing a comparison analysis, organizing long material into a beginner-friendly introduction): six layers
• Not sure how complex it is: start with three lines, look at the result; if there's drift, inconsistent judgment, or structural breakdown — upgrade to six layers and find which layer was missing

Take the customer interview task at the top of this chapter. The transcript needs digesting (complex material), the suggestions need prioritizing (judgment criteria), and the result has to go to engineering (clear reader, but suggestions need filtering) — two of three signals is already enough to warrant the upgrade.

A lot of users get stuck at three lines, dissatisfied with the result, but what they actually need isn't "write the three lines in more detail" — it's to upgrade to six layers by adding the last three.

Especially Layer 4 Judgment Criteria and Layer 6 Verification — these are also the two layers I'll write in the most detail later in this chapter.

This layer answers one question: what do you want me to do?

Two principles:

Use specific verbs. Summarize, rewrite, compare, organize, classify, translate, comment — these are specific. "Handle this for me," "take a look," "give me suggestions" — these are vague. With vague verbs, I pick an action on my own, and I often pick wrong.

One task at a time. Break this and I will almost certainly drift. "Please summarize this article and also comment on the author's argument" — that's two things; I'll either do only one of them, or I'll do both but neither thoroughly.

If you really need two things, write two prompts (this is the spirit of the two-stage method from Chapter 11: what won't fit in space goes onto the time dimension).

This layer answers: what data am I using to do this?

Good practice in order:

1. Open with one or two sentences summarizing what this material is and why you're attaching it — let me grab the overall context first
2. Then paste the raw material — give me complete source material
3. Then constrain — which part is for this round only, or which part is reference and which part should be quoted directly

For long material (over 2000 words), put the organized version before the raw material — this is the two-stage method from Chapter 11 applied to this layer: the organized output from Stage 1 is the best "opening summary" for this layer in Stage 2.

The most common mistake at this layer is dump-and-pray. Paste 30 pages of documents in, say nothing, write "please handle." Now I have to guess: do you want me to use the whole document? Just chapter one? Only the conclusion? — odds of getting it wrong are very high.

This layer answers: what does the finished thing look like?

Nail down each item, don't make me guess:

• Language: Chinese / English / Traditional / Simplified
• Reader: who's it for (specialists / general public / middle schoolers)
• Length: a word-count range, not vague terms like "short" or "detailed"
• Structure: how many paragraphs, headers or not, bullets or not
• Style: tone, register, sentence length
• Citation: include the original text or not, mark sources or not
• Restrictions: what this task should not do (use positive phrasing where you can — "please use Traditional Chinese" is more reliable than "don't use Simplified" — see Chapter 7)

If you don't nail it down, I fall back on my defaults. My defaults aren't wrong, they just don't match what's in your head.

This layer answers: what counts as well done?

A lot of users skip this layer — they think the first three layers, written in enough detail, will cover it. They won't. The first three tell me "what to do"; this one tells me "in what direction is correct."

Example. You ask me to "compare three cloud providers," give me materials, ask for 800 words, bullet points, with a conclusion. First three layers all written. But what counts as a good comparison?

• Is it "fact-comprehensive" (list every spec)?
• Is it "decision-oriented" (list only the dimensions that affect the choice)?
• Is it "fair" (equal length for each provider)?
• Is it "practical" (prioritize what you'd actually use right now)?

I can produce all four, and the four will read very differently. If you don't tell me, I fall back on my defaults — usually "fact-comprehensive + fair" (this is a rule-layer bias) — but what you might actually want is "decision-oriented + practical."

Judgment criteria need to include at least three things:

One, priority order. When multiple goals conflict, who wins. Example: "factual accuracy > clear structure > prose quality" — that way, when prose and facts conflict, I keep the facts.

Two, how to handle uncertainty. When I hit something the materials don't say outright, what do I do?

• Flag it (write "needs further verification" / "not in materials")
• Fill in (use my general knowledge to add a sentence)
• Skip it (drop the whole part)

My default (when I pick) is usually fill-in — this is the root of Fluent Fill-In (Chapter 1). If you don't specify, I fill, and I fill so naturally you can't tell.

Three, how to choose between interpretations. When the material has multiple plausible readings:

• List all (lay out the different readings)
• Pick one (choose one, explain why)
• Ask you back (open the output with: "Which reading do you want?")

The third option is the most underestimated — most of the time I don't ask, because you haven't authorized me to ask; without authorization, all I can do is guess.

Write these three things into the judgment criteria, and when I hit a fork in the road I'll use your standard to choose, instead of mine.

The detail of how to write this layer was already covered in full in Chapter 9 — four kinds of examples (Standard / Variation / Boundary / Anti-example), last-position-strongest, flexible correctness, the four-column anti-example skeleton. Here I'll just emphasize where this layer sits within the six layers:

Examples and judgment criteria come as a pair. You write "judgment criteria" in Layer 4 and provide examples in Layer 5 — examples are the concrete form of the judgment criteria. When I read judgment criteria, they're abstract ("fact-comprehensive," "decision-oriented"); the examples are how I find out the specific shape in your head.

If you wrote "decision-oriented" in Layer 4, the example in Layer 5 has to be one that really is decision-oriented — not all-encompassing, not a fact list. If example and judgment criteria don't match, I'll use the concrete version of the example to overwrite the abstract version of the criteria (an extension of "last-position-strongest" from Chapter 9).

Simple tasks don't necessarily need an attached example. But as soon as it's a task you've assigned me before with unsatisfactory results — next time, attach an example. Compared to revising the prompt over and over, giving one example you're satisfied with usually nails it in one shot.

This layer answers: after I'm done, should I verify the work myself?

The deepest misunderstanding of this layer is writing it as "please double-check" — that doesn't work. When I "double-check," I just reread what I just wrote and think, "mm, looks reasonable." Chapter 1 covered this — it's called Pseudo Self-Check — me looking back at myself, I can't see the problem.

What Layer 6 should be is not "double-check" but a specific QC checklist — each item a question you can copy-paste verbatim:

• In this output, which sentences come directly from the materials? (List three.)
• Which are inferences? (List three, and mark which paragraph of the source they come from.)
• Which might be over-reaches? (Pick the three you have least confidence in.)
• Which claims have no support in the materials? (List them and recommend deletion or flagging.)
• If we want to be more conservative, which three sentences should be deleted?

These five questions are ready to copy-paste. The point is: each one demands a specific location — "list three sentences," "mark which paragraph" — forcing me out of the fuzzy "I think it's right" and back to specific correspondence. Once specific correspondence is required, Fluent Fill-In can't hide — I have to point to where that sentence's basis comes from; if I can't point, it was filled in.

This layer is usually executed in a separate round (circling back to the two-stage method from Chapter 11). Same-round self-check (verifying right after finishing) doesn't work well, because I just finished writing and self-justification is still strong. Skip a round, treat the output as fresh input, and I can review it more calmly.

In practice:

• Writing round: use the first five layers to write
• Verification round: take the writing output as input, use Layer 6's QC checklist

This is how the six-layer framework unfolds along the time axis — Layer 6 in space, in practice, is the second round in time.

The two-stage method from Chapter 11 is a split on the time axis: the organize stage and the write stage.

The six-layer framework in this chapter is completeness on the space axis: the structure each prompt should have internally.

How they combine: write each stage as a six-layer structure.

Stage 1 (organize) prompt = six layers

• Task: organize
• Materials: source document
• Format: bullet points
• Judgment criteria: completeness over polish
• Example: an organization example
• Verification: QC checklist (e.g., for each item in the organization, mark which paragraph of the source document it corresponds to)

Stage 2 (write) prompt = six layers

• Task: write a beginner-friendly introduction
• Materials: the proofread organization
• Format: style, length, structure
• Judgment criteria: stay tied to the materials, no expansion
• Example: a style example
• Verification: QC checklist (e.g., list the word count of each paragraph, find sentences with embedded jargon)

Two stages are about splitting time; six layers are about filling space — every cell on the time axis needs all six layers on the space axis filled in for a complete long-task collaboration flow.

A note on timing: this advice was written in 2026. Model self-check capability will improve, and within the six layers only Layer 6 verification will gradually become unnecessary — same-round self-check will be enough. The other five layers are about "what you want," decoupled from model capability, and will always need to be written.