Summarize a Document With AI Without Distorting It
AI summaries read clean but quietly distort — an exception dropped, a "may" turned to "will," a target read as a guarantee. Here's how to summarize a document faithfully: scope it, name what must be preserved, keep the caveats, and check it back against the text.
Build a Faithful Summary PromptWhen the summary is shorter and quietly wrong
You hand the AI a policy page, a report, or a long transcript and say "summarize this." What comes back is shorter and reads cleanly — which is exactly the problem, because a clean summary is trusted, and this one has changed the meaning. The exception got dropped. "Customers may cancel monthly plans" became "customers can cancel anytime." "Support response times are targets" became "guaranteed." A tentative "this could suggest" hardened into "this shows." None of it looks wrong on the page; you only find out when someone acts on the summary and hits the exception it left out. Compression didn't just shorten the source — it edited it.
That's what this guide is about. A faithful summary isn't just a shorter version; it stays inside the source — keeping the hedges, the exceptions, the scope limits, and the things the source pointedly does not say. You get there by how you ask: scope the summary, name what must survive the compression, and keep the model from inventing connections or certainty the text never had. NewPrompt builds that summary prompt for you, with the fidelity rules baked in — and it's honest about the boundary: it doesn't upload, read, parse, or analyze your document, and it can't verify that the source itself is correct. You paste the source into your own AI tool, the model produces a candidate summary, and you check it back against the text. Faithfulness rules lower the odds of distortion; they don't guarantee the summary is right.
Why shorter isn't automatically faithful
Summarizing is compression, and compression forces choices about what to drop and how to phrase what's left — choices a model makes to sound fluent and confident, not to stay true to the source. Left to its defaults, it distorts in predictable ways:
- It turns possibility into certainty. "May," "could," "subject to," "in some cases" are the first words compression eats, and "the policy may allow X" becomes "the policy allows X."
- It drops the exception. A rule with a carve-out gets summarized as the rule alone, because the exception is the wordy part — and the exception is usually the part that matters.
- It promotes a minor point. A passing detail that's easy to state can end up looking like a main conclusion, while the actual thesis gets one flattened line.
- It invents a connection. Two facts sitting near each other in the source become cause and effect in the summary, an inference the text never made.
- It changes who did what. In the interest of brevity, an actor or a responsibility gets blurred — "the vendor must" becomes "the team should" — and a commitment quietly moves.
- It reads as trustworthy anyway. A well-written summary of a source you didn't read looks identical whether it kept the caveats or sanded them off — which is why the distortion goes unnoticed.
Step 1: Decide what kind of summary, and how long
"Summarize this" doesn't say what the summary is for, so the model guesses — usually a bland executive gist. Decide the purpose first: an executive overview, a risk summary, a section-by-section digest, an action list, or a summary aimed at a specific reader. Each pulls out different content from the same source, and naming it stops the model from defaulting to the vaguest option. Set a concrete length too — a sentence or bullet count per section, not "be concise," because models follow countable budgets and ignore adjectives.
The Structured Summary Prompt builds this shape for you: you pick the source type (a transcript reads differently from a contract), the structure, a per-section length budget, and — the part that matters most here — a fidelity level, up to a strict no-invention setting whose sections say "Not covered in the source" instead of getting filled with a plausible guess. Be clear on what it does: it generates the summary prompt, it doesn't summarize your text or check the result. The consistency is the value — the same skeleton and the same rules every time you run it in your own assistant, instead of whatever shape the model feels like producing today.
Step 2: Fence the summary to the source
The most dangerous ingredient in a summary is the model's own knowledge, because it blends in without a seam: a fact the source never stated, a definition from training, a "typically this means" that the document never said. Tell the summary to use only the source and to mark what the source doesn't cover rather than fill it — a gap named "the source does not say" is safe; a gap filled with plausible context is a distortion.
Keeping the model's instructions separate from the material it's working on is its own small discipline, and the Long Input Formatter handles it: it wraps the source in explicit delimiters, labels its sections, and adds a grounding rule — up to a strict mode where anything the source doesn't contain gets answered "the source does not say" and a claim that can't be traced to the text isn't made. It packages the source and keeps it fenced off from your instructions; it doesn't read or verify the content, and the summarizing happens when you run the result in your own AI tool. That fence is what turns "summarize this" into "summarize only this, and don't reach outside it."
Step 3: Name what must survive the compression
A faithful summary keeps the parts a careless one drops, so list them before you summarize: the caveats and exceptions, the scope limits, the uncertainty and hedged wording, the exact numbers and dates, the obligations and conditions, who is responsible for what, and the difference between "may," "should," and "must." Naming them turns preservation into an instruction instead of a hope — and where exact wording carries weight, like a commitment or a legal qualifier, ask for it kept verbatim, because a paraphrased commitment is a changed commitment.
The counterpart to the preserve list is a set of fidelity rules that name the distortions to avoid. The Stop AI Summaries from Making Things Up resource is the fidelity contract in full: do not invent, do not infer unsupported conclusions, do not add missing context, only summarize what appears, preserve numbers and names exactly, and write "Not covered in the source" for anything with nothing behind it. One honest limit travels with it and is worth stating in your own summaries: fidelity keeps the summary inside the source, not the source inside reality — if the document has a wrong number, a faithful summary copies it wrong, because checking the source's own accuracy is a separate job you own.
Step 4: For a long document, summarize by section before you synthesize
A long document distorts in a particular way: as the model works through it, later sections crowd out earlier ones, and a caveat stated on page two is gone by the time it's summarizing page twenty. Work section by section first — a faithful summary of each part on its own terms — and only then synthesize the parts into one overview. That way an early exception is captured while the model is still looking at it, instead of being averaged away by everything that came after.
The Summarize a Long Document resource is a ready-made version of the faithful-compression prompt for a long article or report: ordered key points, no outside knowledge, and the rule that never pads a thin section into a full-looking one. When you synthesize, keep the fidelity rules on the synthesis too — combining section summaries is another chance to invent a connection between them, so the overview needs the same "only what the sections actually said" discipline as each piece. A shorter summary of summaries is still a summary that can drift.
Step 5: Check the summary back against the source
A faithful-summary prompt lowers the odds of distortion; it doesn't remove the check. Read the summary against the source, and spend the attention where distortion hides: the modal verbs (did a "may" become a "will"?), the exceptions (is every carve-out still there?), the numbers and dates (copied exactly, or rounded?), and the actors (is it still the vendor's obligation, not the team's?). A useful move is to ask the model itself, in a separate pass, "where could this summary mislead a reader who hasn't seen the source?" — its answer is a list of places to look, not a verdict you can trust on its own.
The depth of the check scales with the stakes. For an internal roundup, a quick read against the source is enough; for a contract, a compliance policy, or anything medical or financial, a faithful summary is a starting point for a person who knows the domain, not a substitute for reading the document. The fidelity rules got the summary closer to the source than a bare "summarize this" ever would — but whether it's close enough to rely on is a judgment that stays with the reader, against the text, every time.
Common mistakes
The habits that turn a summary into a subtly different document:
- Asking for "a summary" and nothing else. No purpose, no length, no fidelity rule — you get the model's blandest guess, distortions included.
- Letting hedges harden. "May," "could," and "subject to" carry the source's uncertainty; a summary that drops them states things the document never did.
- Dropping the exception to save words. The carve-out is usually the part that changes the rule — a rule summarized without its exception is a different rule.
- Filling gaps with plausible context. If the source doesn't say it, the faithful move is "not covered," not a reasonable-sounding guess that reads like fact.
- Trusting a clean summary you haven't checked. A well-written summary of a source you didn't read looks the same whether it's faithful or not — read it back.
- Treating a faithful summary as verified. Fidelity keeps it inside the source; it doesn't confirm the source is right, and it isn't clearance for a high-stakes document.
A worked example: a cancellation policy
Take a short policy excerpt where every distortion is one dropped word away.
A careless summary that drops the exception and reverses "targets, not guarantees" vs. a faithful-summary prompt that preserves the caveatsSOURCE (an excerpt):
"Customers may cancel monthly plans at any time. Annual plans are
non-refundable after the first 14 days, except where required by law.
Enterprise contracts may include custom termination terms. Support
response times are targets, not guarantees."
A CARELESS SUMMARY (shorter, and wrong):
"Customers can cancel anytime, annual plans are non-refundable, and
support response times are guaranteed."
what it distorted:
- "may cancel monthly plans" -> "cancel anytime" (dropped the plan scope)
- the first-14-days window and the legal exception -> gone
- enterprise custom terms -> gone
- "targets, not guarantees" -> "guaranteed" (reversed the meaning)
A FAITHFUL-SUMMARY PROMPT (cut the distortion up front):
"Summarize the source faithfully. Use only the source; add nothing.
Do not generalize a rule beyond its stated scope.
Preserve exceptions, legal qualifiers, and target-vs-guarantee wording.
If the source says 'may', do not rewrite it as 'must' or 'will'.
Add a 'Caveats preserved' section and a
'What this summary must not imply' section.
For anything the source doesn't cover, write 'Not covered in the source'."
THE SHAPE YOU WANT BACK:
Summary:
Monthly plans may be canceled at any time. Annual plans are non-
refundable after the first 14 days, unless the law requires otherwise.
Enterprise contracts may have custom termination terms. Support
response times are targets, not guarantees.
Caveats preserved:
- "cancel anytime" applies to monthly plans, not all plans
- annual plans have a 14-day window and a possible legal exception
- enterprise contracts may override the general terms
What this summary must not imply:
- that all customers can cancel anytime
- that support response times are guaranteed
- that annual plans have no exceptions
CHECK IT: read each line back against the source -- the modals ("may"),
the exceptions, and the numbers most of all -- before you rely on it.Where this fits in NewPrompt
Building a faithful summary is one move in a small family of source-handling jobs, and it's worth knowing which you need. The Structured Summary Prompt builds the summary with its fidelity level and structure; the Stop AI Summaries from Making Things Up resource is the fidelity contract you drop into any summary prompt; the Long Input Formatter fences the source so the model can't reach outside it; and the Summarize a Long Document resource applies the same discipline to a long report. Each builds a prompt or packages a source in your browser — none reads, uploads, parses, or verifies your document; that happens when you run the prompt on the text you paste into your own AI tool.
The neighbors do related but different jobs. Checking a finished AI answer against its source line by line — after it's written — is a separate review pass, not this; this reduces distortion up front, in how you ask. Pulling discrete values into named fields is extraction, not a narrative summary. Splitting an oversized document so it fits the model's window is about the input, not the fidelity of the output. This guide sits at the output-fidelity spot: given a source that fits, how do you compress it without changing what it says?
The reframe worth keeping is that a summary is a stand-in — the reader trusts it in place of the source they didn't read. What makes that trust earned isn't brevity; it's the caveats, the hedges, and the honest "not covered" that a careless summary sands off to look cleaner. Keeping them is most of the work, and the fidelity rules are how you make keeping them the model's default instead of your lucky break. Even then, the summary starts closer to the source, not verified against it — the reader who relies on it is the one who confirms it still says what the document did.