TL;DR
CCR is a technique where you copy the final text or code into a new chat and review it there. No history of the earlier conversation, no instructions about how it was made — just the finished artifact and a request for a review.
When you ask a model to check what it just wrote, in the same chat, it doesn't critique — it justifies. The context holds all your instructions, the intermediate iterations, the trade-offs. The model sees the text not as "what is actually there" but as "the result of doing the job right." This hits hardest with critical errors: logical contradictions and structural gaps that require looking at the text as a whole — exactly the ones the model misses inside its own context.
CCR strips the production context away completely. In a new session the model sees only the artifact — and is forced to judge what was actually written, not what was meant to be written. The review runs on five criteria: factual accuracy, internal consistency, applicability, readability, completeness.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
SESSION A (production):
Write the text / code / document as usual
→ Save the final result
EXPORT:
Copy only the artifact (no chat history)
SESSION B (review) — new chat, clean start:
Paste the artifact + a prompt with the 5 criteria
→ Get a list of problems found
INTEGRATION:
Go back to Session A (or open a third one)
→ Fix what was found
Two separate requests. Session B sees nothing from Session A.
Example
Task: You wrote a landing page for a new B2B SaaS product — reporting automation for small businesses. You spent an hour on it, went through several iterations with the model, and the copy is done. You want to check it before going live.
Prompt for Session A (regular work):
Write a landing page for the SaaS product "ReportPro" —
automated tax reporting for freelancers and small businesses.
USP: saves 4 hours a week, integrates with QuickBooks and IRS e-file.
Price: $29/month. Audience: bookkeepers and sole proprietors filing Schedule C.
→ You get the copy, edit it, polish it.
Prompt for Session B (new chat, paste in the artifact):
Below is the copy for a landing page. Check it against five criteria
and give me a list of specific problems, pointing to where they are in the text:
1. Factual accuracy — are all numbers, claims and promises
realistic and consistent with each other?
2. Internal consistency — are there contradictions
between different parts of the text?
3. Applicability — will this work for the stated audience
in real-world conditions?
4. Readability — could the target reader misunderstand something
or miss something important?
5. Completeness — what's missing for the reader to make a decision?
[LANDING PAGE COPY]
Result: The model returns a numbered list of issues for each criterion, pointing to the specific block or phrase. Not "looks great, you could improve this bit," but real inconsistencies — for example, that the "saves 4 hours" promise isn't backed by anything, or that the QuickBooks integration is mentioned in the header but there isn't a word on how it actually works.
Why It Works
The LLM weakness: anchoring. When the model sees your whole conversation, its context holds your instructions, the intermediate versions, your approvals ("yes, great, now add..."). That creates a strong anchor: the text is perceived as the correct output of the correct task. The model doesn't look at it with fresh eyes — it defends it.
Another mechanism: sycophancy. Models are trained to please the user. In a long conversation where you've approved the text many times, the model has little incentive to be a tough critic. Research shows that when a model doesn't know it's evaluating its own text, the sycophantic bias almost disappears. CCR gets you there automatically: in a new session the model simply doesn't know who wrote the text.
How CCR exploits a strength. Models are good at spotting errors in other people's texts. CCR makes your text "someone else's" for the reviewer: new session — zero memory, zero anchors. On top of that, a fresh session works with a short context (~5K tokens vs. 50K+ in the production chat), which by itself improves quality — the "lost in the middle" effect is much weaker.
Control knobs: - 5 criteria — drop the irrelevant ones or add your own (e.g., "meets SEO requirements") - Output instruction — add "for each problem, give the severity (critical/important/minor) and a concrete fix" - Role — "You are a skeptical investor / a seasoned copywriter / a target customer seeing this for the first time" - Format — ask for a table instead of a list for easier comparison
Prompt Template
Below is a {artifact type: text / code / document / script}.
Check it against five criteria.
For each problem you find, state: where it is in the text,
what the problem is, and how critical it is.
Review criteria:
1. Accuracy — are all facts, numbers and claims correct and consistent?
2. Consistency — are there any internal contradictions?
3. Applicability — will this work in real-world conditions
for {target audience}?
4. Readability — what could be misunderstood or missed?
5. Completeness — what's missing for {artifact goal: making a decision /
running the code / publishing}?
{ARTIFACT}
What to fill in:
- {artifact type} — landing page copy, investor pitch, a function's code, an employee guide
- {target audience} — a small-business bookkeeper, a startup CTO, a new manager
- {artifact goal} — the specific action the reader/user is supposed to take
🚀 Quick start — paste into a chat:
Here's a Cross-Context Review template for checking texts.
Adapt it to my task: {your task}.
Ask me questions to fill in the placeholders.
[paste the template above]
The LLM will ask what exactly needs checking and for whom — because the "applicability" and "completeness" criteria depend on context: reviewing a pitch and reviewing a safety manual are different jobs.
Limitations
⚠️ Contextual errors are still hard: CCR is best at catching factual errors and contradictions. Errors of the "this won't work in this particular environment" type (contextual fitness) are caught poorly by every condition — 16% at most. For technical nuances you need a human who knows the context.
⚠️ Subjective content — minimal effect: For scripts, creative writing and material with fuzzy quality criteria, the difference between sessions is minimal. CCR pays off most for code and technical documents.
⚠️ Repeat reviews in the same new session backfire: If you ask the model to "check again" in the same Session B, it starts producing more findings, but most of them turn out to be false. Opening a third fresh session beats doing a second pass in the same one.
⚠️ One model in the study: Everything was tested on Claude Opus 4.6. In theory the principles are universal (anchoring and sycophancy are documented in all major models), but there are no direct experiments with GPT-4 or Gemini.
How It Was Studied
The researchers asked a precise question: does context separation help, or does it just help to "look twice"? To find out, they added an SR2 condition — same chat, a second review pass. It's a smart control: if CCR wins simply because of "two looks," SR2 should give a similar result.
They prepared 30 artifacts of three types: Python functions, technical tutorials, and presentation scripts. Into each they deliberately planted exactly 5 errors of five types at three severity levels — 150 errors with known answers in total. They ran 360 reviews across four conditions and compared each against the answer key.
SR2 showed no improvement over a single pass (p=0.11) — but it did start producing more false findings. The model "tried harder," adding noise instead of signal. This shows directly that it's not about the number of attempts but about the context break itself. A curious detail: giving the model the original prompt ("here's what the user asked for") — the SA condition — didn't help and even made results slightly worse. It looks like any production context triggers anchoring, no matter how "useful" it is.
Original from the Paper
In the review phase, a new Session B starts from scratch.
The reviewer receives the artifact and a prompt asking it
to check five things:
factual accuracy (are the numbers and claims right?),
internal consistency (are there contradictions?),
contextual fitness (would this actually work in its intended environment?),
audience perspective (could a reader misinterpret something?),
and completeness (is anything important missing?).
Context: This is the exact wording of the review prompt from the study protocol. The researchers used it as the standardized request in Session B for all 30 artifacts.
Adaptations and Extrapolations
💡 Adaptation: a reviewer with a role
Instead of a neutral "check against 5 criteria," give Session B a specific role:
You are Mike Brennan, reading this for the first time as a potential franchisee. You have $100,000 to invest and a healthy skepticism of shiny promises. What would make you wary? What would make you close the tab? [ARTIFACT]A specific role sharpens the critique — the model simulates not an abstract reader but a person with a known stance and a dose of skepticism.
🔧 Technique: hierarchical review
For complex documents — several independent B sessions with different roles, then a Session C synthesizes the findings:
SESSION B1: checks facts and numbers SESSION B2: checks structure and logic SESSION B3: reads as the target audience SESSION C: "Here are three independent reviews of the same document. Merge the findings, remove duplicates, and rank them by priority."Each reviewer is specialized → fewer false findings, higher accuracy within its own domain.
Resources
Paper: Cross-Context Review: Improving LLM Output Quality by Separating Production and Review Sessions
Author: Song Tae-Eun, Daejeon Jungang Cheonggua Co., Ltd. ([email protected])
Key works the study builds on: - Huang et al. (2024) — LLMs cannot reliably correct their own reasoning without external feedback - Tsui (2025) — the "self-correction blind spot" phenomenon: an average of 64.5% across 14 models - Hong et al. (2025) — "context rot": quality degrades as context grows, documented across 18 models - Liu et al. (2024) — "lost in the middle": models make worse use of the middle of a long context - Choi et al. (2025) — anonymizing authorship nearly eliminates sycophantic bias