Summarization & Extraction Patterns
Four patterns for compressing unstructured text into something usable — layered summaries, null-disciplined field extraction, meeting-to-actions tables, and executive distillation — plus the specific way each one silently fails.
You get handed a 40-minute meeting transcript, a 12-page vendor contract, or a Slack thread that spiraled into 80 messages, and you need something usable out of it in the next ten minutes. "Summarize this" gets you a paragraph that might be right. It might also quietly drop the one clause that mattered, or confidently state a number that was never actually in the source.
The four patterns in this lesson are about compressing and extracting with discipline — producing output you can trust because the pattern itself makes fabrication harder, not just output that reads confidently.
Pattern 1: The Layered Summary
Instead of picking one summary length and hoping it's the right one for whoever reads it, generate the same content at three depths in one pass: a TL;DR (1-2 sentences, for someone skimming), a Detailed version (1-2 paragraphs, for someone who needs the key numbers and context), and a Deep version (full analysis, methodology, and caveats, for you six months from now when you need to remember exactly what you found).
The prompt shape:
Summarize the following at three depths:
1. TL;DR — 1-2 sentences, no jargon, for someone skimming
2. Detailed — 1-2 paragraphs with the key numbers and context
3. Deep — full analysis including methodology and caveats
All three must state the SAME facts. If the TL;DR claims something, the Deep
layer must be able to support it.
[content]
When it works: any time the same source material serves multiple audiences — you don't know in advance whether the reader wants the headline or the full derivation, so you generate both and let them choose.
When it fails: when the layers drift apart. If nobody checks that the TL;DR is actually backed by the Deep layer, you end up with a short version that oversimplifies into something false, and a long version that hedges so much it's unusable. The check is cheap: does every claim in the TL;DR appear, supported, somewhere in the Deep layer? If not, the summary is broken.
Pattern 2: Field Extraction with Null Discipline
When you're pulling structured fields out of unstructured text — a contract, a resume, a support ticket — the single most important instruction is the one that's easiest to forget: if the field isn't explicitly present, return null. Never infer it.
The prompt shape:
Extract the following fields from the contract text below. For each field:
if the exact value is stated in the text, extract it verbatim. If it is NOT
explicitly stated, set the field to null. Do not infer, estimate, or assume
a value under any circumstances — a missing field must be reported as missing.
Fields: renewal_date, auto_renewal (boolean), termination_notice_days
[contract text]
When it works: any structured extraction task where a wrong value is worse than a missing one — legal documents, financial data, anything that feeds downstream automation. A null is a visible, honest gap. A fabricated value is an invisible, dangerous one.
When it fails: silently, and only in one specific way — you forget to state the "do not infer" instruction explicitly. Models are trained to be helpful, and "helpful" defaults to filling gaps with the most plausible value rather than admitting the information isn't there. Without the explicit null rule, a missing renewal date doesn't come back as null — it comes back as a confident, wrong date that looks exactly like a real extraction until someone checks it against the source.
Pattern 3: Meeting-to-Actions
A transcript is not a deliverable. Nobody re-reads 40 minutes of meeting audio to find out what they're supposed to do. The pattern: extract every commitment made in the meeting into an owner / action / deadline table, and nothing else.
The prompt shape:
From this meeting transcript, extract every action item as a table with columns:
Owner | Action | Deadline (if stated, else "not specified")
Only include items where someone explicitly committed to doing something.
Do not include general discussion points or ideas that were raised but not
assigned to anyone.
[transcript]
When it works: any recurring meeting where action items get lost between the call ending and the follow-up. It's also the pattern behind a lighter variant, Doc-to-Table: instead of a meeting, you feed in an unstructured document — a pile of vendor emails, a batch of support tickets — and extract the same row-per-item shape so the results become comparable.
When it fails: when the transcript mixes committed actions with hypothetical discussion ("we could maybe look into X") and the extraction can't tell the difference. Without an explicit rule to only capture things someone committed to, you get a table padded with half-formed ideas next to real deadlines, and the reader can't tell which rows actually need chasing.
Pattern 4: Executive Distillation
The layered summary gives you three depths. Executive Distillation is the extreme end of that spectrum, purpose-built for one reader: a decision-maker with 20 seconds and one question — "what do I need to know to make a call?"
The prompt shape:
Compress this into exactly 3 sentences for a VP who has not read the source
material and will not read it. Sentence 1: the situation. Sentence 2: the
decision or number that matters most. Sentence 3: what you need from them,
if anything. No hedging, no jargon, no "it depends."
[content]
When it works: status updates, escalations, anything going to someone several levels removed from the work who needs to act on it, not study it.
When it fails: when the 3-sentence constraint forces you to drop the one caveat that actually changes the decision. Executive Distillation trades nuance for speed on purpose — the discipline is knowing when a decision genuinely needs the nuance back, and routing that one back to the Detailed or Deep layer instead of forcing it into three sentences that quietly mislead.
If you want the deeper mechanics of why explicit constraints ("never infer," "verbatim only") change model behavior more reliably than implicit ones, that's Prompt Engineering Mastery's territory — specifically the sections on instruction specificity and failure-mode-aware prompting. This lesson assumes you can write the prompt; it's handing you the four shapes worth having ready before the next transcript lands in your inbox.
Bottom Line
Four patterns, one discipline: never let compression or extraction blur into fabrication. Layered Summary keeps three depths honest by requiring them to agree. Field Extraction with Null Discipline makes "missing" a visible, explicit state instead of a silently-filled gap. Meeting-to-Actions turns a transcript into a table of real commitments, not hypotheticals. Executive Distillation trades nuance for speed on purpose, and knows when to hand a decision back to a deeper layer. Together they turn "summarize this" from a coin flip into a repeatable, checkable process.