@ckelsoe/prompt-architect 3.2.2 → 3.4.0

package/skills/prompt-architect/references/frameworks/chain-of-density.md

@@ -2,478 +2,172 @@
 
 ## Overview
 
-Chain of Density is an iterative refinement technique that progressively improves outputs through multiple passes. Each iteration increases information density, removes redundancy, and enhances quality without significantly increasing length. It's based on the insight that iteration often produces better results than trying to get everything perfect in one shot.
+Chain of Density is a summarization technique that produces a series of increasingly **entity-dense** summaries of a source document while holding the **length fixed**. It begins with a deliberately sparse, verbose summary, then repeatedly identifies salient entities missing from the previous version and fuses them in — making room by compressing and rewriting existing text rather than by adding words or dropping content.
 
-## Core Concept
+**Research basis:** "From Sparse to Dense: GPT-4 Summarization with Chain of Density Prompting" (Adams, Fabbri, Ladhak, Lehman & Elhadad; arXiv 2309.04269; NewSum workshop at EMNLP 2023, ACL Anthology 2023.newsum-1.7). Entity density rose from 0.089 to 0.167 entities per token over five steps, against 0.151 for human-written summaries and 0.122 for a vanilla GPT-4 summary. In human evaluation, annotators preferred step 2 (30.8% of first-place votes) and step 3 (23.0%) over the sparse step 1 (8.3%) — density helps, but only up to a point.
 
-Instead of requesting the perfect output immediately, CoD:
-1. Starts with a basic/verbose version
-2. Iteratively refines through multiple passes
-3. Increases information density each time
-4. Removes fluff and redundancy
-5. Enhances clarity and precision
-6. Converges on optimal output
+## The Defining Constraint: Length Stays Fixed
 
-Think of it as "progressive enhancement" for prompts.
+This is the entire mechanism, and it is what separates CoD from ordinary iterative editing:
 
-## When to Use Chain of Density
-
-**Ideal for:**
-- Summarization tasks
-- Content compression
-- Iterative improvement of writing
-- Optimizing explanations
-- Refining complex outputs
-- Tasks where quality improves with iteration
-
-**Not needed for:**
-- Simple one-shot tasks
-- When first draft is sufficient
-- Time-critical quick tasks
-- Tasks with fixed formats that can't improve
-
-## Implementation Approaches
-
-### Approach 1: Explicit Multi-Pass
-Request multiple iterations upfront.
-
-**Example:**
-```
-Create a summary of this article using Chain of Density:
-
-ITERATION 1:
-Write a verbose summary hitting all main points (150-200 words)
-
-ITERATION 2:
-Refine the summary: increase information density, remove redundancy, keep it under 150 words
-
-ITERATION 3:
-Further refine: make every word count, increase precision, keep it under 120 words
-
-ITERATION 4:
-Final pass: maximize information density while maintaining clarity (100 words max)
-
-ITERATION 5:
-Ultimate compression: distill to absolute essentials (50 words max)
-
-After all iterations, explain what improved in each pass.
-```
-
-### Approach 2: Recursive Refinement
-Use output from one iteration as input to the next.
-
-**Example:**
-```
-PASS 1: Write a first draft explanation of quantum entanglement for a general audience.
-
-PASS 2: Review your explanation. What's unclear? What's redundant? Rewrite it, addressing these issues.
-
-PASS 3: Review again. Where can you be more precise? Where can you use better examples? Rewrite.
-
-PASS 4: Final review. Every sentence should earn its place. Remove or improve anything that doesn't. Final version.
-
-Show all passes so we can see the evolution.
-```
-
-### Approach 3: Targeted Improvement
-Focus each iteration on specific aspect.
-
-**Example:**
-```
-Write a product description, then improve it iteratively:
-
-DRAFT:
-[Initial version]
-
-ITERATION 1 - CLARITY:
-Rewrite focusing on making it clearer and easier to understand.
-
-ITERATION 2 - IMPACT:
-Rewrite focusing on making it more compelling and persuasive.
+> "GPT-4 generates an initial entity-sparse summary before iteratively incorporating missing salient entities **without increasing the length**." — abstract
 
-ITERATION 3 - CONCISION:
-Rewrite focusing on removing every unnecessary word.
+> "To maintain the same length while increasing the number of entities covered, abstraction, fusion, and compression is explicitly encouraged, rather than dropping meaningful content from previous summaries." — §2
 
-ITERATION 4 - PRECISION:
-Rewrite focusing on being more specific and accurate.
+Density rises because the *same word budget* is made to carry more information. If you shorten the text on each pass, you are not doing Chain of Density — you are doing generic compression. For that, use **Iterative Compression** (`iterative-compression.md`).
 
-FINAL:
-Combine the best elements from all iterations.
-```
+The paper controls length deliberately, because length is "a strong confounder when evaluating summaries." In practice the budget holds approximately: measured token counts across the five steps were 72, 67, 67, 69, 72.
 
-### Approach 4: Constraint-Based Refinement
-Add tighter constraints with each iteration.
+## What Counts as a "Missing Entity"
 
-**Example:**
-```
-Explain this technical concept through progressive refinement:
+The paper is deliberately non-prescriptive about entity *types*. An entity qualifies if it is:
 
-VERSION 1: Explain in 500 words or less
-VERSION 2: Reduce to 300 words without losing key information
-VERSION 3: Reduce to 150 words, keeping only essentials
-VERSION 4: Create a 50-word version capturing the core idea
-VERSION 5: One sentence (25 words max)
+- **Relevant** — to the main story
+- **Specific** — descriptive yet concise (5 words or fewer)
+- **Novel** — not in the previous summary
+- **Faithful** — present in the source article
+- **Anywhere** — located anywhere in the article, not just the opening
 
-Each version should be complete and self-contained.
-```
+"Anywhere" is load-bearing: it is the explicit countermeasure to lead bias, and it is why later iterations start pulling content from the middle and end of the source.
 
-## Best Practices
+Entity identification is done by the model itself inside the loop — there is no external extraction step.
 
-### 1. Define What to Optimize
-```
-Good:
-"Iterate to improve:
-- Information density
-- Clarity
-- Conciseness
-- Precision"
-
-Poor:
-"Make it better"
-```
+## The Method
 
-### 2. Specify Number of Iterations
-```
-Good:
-"Refine through 4 iterations, showing each version"
+`[N]` iterations, issued as a **single prompt** that returns all `[N]` summaries at once (not `[N]` separate turns). The paper uses five, and that is the template's default when the user gives no number:
 
-Poor:
-"Keep improving until it's good"
-```
+1. **Write a deliberately sparse first summary.** Long (4-5 sentences, ~`[TARGET]` words) but highly non-specific, padded with filler like "this article discusses." The padding is intentional — it creates the slack that later steps convert into entities.
+2. **Identify 1-3 missing entities** from the article that are absent from the current summary.
+3. **Rewrite at identical length**, covering everything from the previous summary *plus* the new entities. Make room through fusion, compression, and removal of uninformative phrases.
+4. **Repeat steps 2-3** until `[N]` summaries exist.
+5. **Choose the step you want.** Later is not automatically better — human raters preferred steps 2-3.
 
-### 3. Show Evolution
-```
-Good:
-"Show each iteration and explain what changed and why"
-
-Poor:
-"Just give me the final version"
-```
-
-### 4. Set Clear Constraints
-```
-Good:
-"Each iteration should be 20% shorter while maintaining completeness"
-
-Poor:
-"Make it shorter"
-```
+**Never drop entities from the previous summary.** If space cannot be made, add fewer new entities. Under pressure, density yields — length and prior content do not.
 
-## Complete Examples
-
-### Example 1: Summarization
-
-**Without CoD:**
-```
-Summarize this research paper.
-```
-
-**With CoD:**
-```
-Summarize this research paper using Chain of Density:
-
-[Paper content]
-
-ITERATION 1 (200 words):
-Create a comprehensive summary covering all major points. Prioritize completeness over brevity.
+## When to Use Chain of Density
 
-ITERATION 2 (150 words):
-Refine the summary:
-- Remove redundant information
-- Combine related points
-- Increase information density
+**Ideal for:**
+- Summarizing an article, paper, or report where information density matters
+- Producing a summary that must fit a fixed length but carry maximum substance
+- Generating several density options to pick from
+- Abstract, executive-summary, and TL;DR writing
 
-ITERATION 3 (100 words):
-Further compression:
-- Keep only essential information
-- Make every sentence count
-- Maintain accuracy
+**Not for:**
+- General content rewriting or quality improvement → use **Self-Refine**
+- Progressive shortening to a target word count → use **Iterative Compression**
+- Non-summarization tasks. CoD is summarization-specific; the paper evaluates it only on news articles (CNN/DailyMail).
 
-ITERATION 4 (75 words):
-Maximum density:
-- Distill to core findings
-- Remove all fluff
-- Preserve critical details
+## Template Structure
 
-For each iteration, highlight what you removed and why.
-```
+The block below is the template's prompt region as authored — what you fill in, not what you send. (Its divider rules are omitted; they mark the guidance/prompt boundary inside the template file and never ship.) Section headers are stripped at emission, so every slot's meaning is carried by the prose around and inside it rather than by the header above it. `SOURCE MATERIAL:` is such a header — it goes, and the unbracketed sentence below it is what tells the model the pasted text is the article to summarize. `Step 1.`, `Step 2.` and `Guidelines:` are the exception: they are literal labels inside the paper's protocol, not document structure, and they ship verbatim.
 
-### Example 2: Code Documentation
-
-**Without CoD:**
-```
-Document this function.
-```
+`[TARGET]` is the fixed word budget and `[N]` the number of summaries, both as bare numerals. Substitute the same numeral at every occurrence of each — in the prompt body below, `[TARGET]` appears three times and `[N]` three times. (The template file names each twice more in its guidance region; those are descriptions of the fields, not slots, and never ship.) The paper's settings are `[TARGET]` = 80 and `[N]` = 5; use those if the user gave no numbers of their own.
 
-**With CoD:**
 ```
-Document this function through iterative refinement:
+SOURCE MATERIAL:
+[Paste the full document to be summarized here.]
+Use the material above as the article to be summarized for the work described below.
 
-[Code]
+You will generate increasingly concise, entity-dense summaries of the article above.
+Produce [N] summaries in total, each denser than the last, all in a single response.
+Every summary must be exactly [TARGET] words long.
 
-DRAFT DOCUMENTATION:
-Write complete documentation with examples, edge cases, everything.
+Repeat the following 2 steps [N] times.
 
-ITERATION 1 - CLARITY:
-Review and rewrite confusing sections. Add examples where helpful.
+Step 1. Identify 1-3 informative entities (";" delimited) from the article which
+are missing from the previously generated summary.
+Step 2. Write a new, denser summary of identical length which covers every entity
+and detail from the previous summary plus the missing entities.
 
-ITERATION 2 - CONCISION:
-Remove redundancy. Combine related points. Make it tighter.
+A missing entity is:
+- Relevant: to the main story.
+- Specific: descriptive yet concise (5 words or fewer).
+- Novel: not in the previous summary.
+- Faithful: present in the article.
+- Anywhere: located anywhere in the article.
 
-ITERATION 3 - PRECISION:
-Be more specific about types, behaviors, edge cases.
+Guidelines:
+- The first summary should be long (4-5 sentences, ~[TARGET] words) yet highly
+  non-specific, containing little information beyond the entities marked as missing.
+  Use overly verbose language and fillers (e.g., "this article discusses") to reach
+  ~[TARGET] words.
+- Make every word count: re-write the previous summary to improve flow and make
+  space for additional entities.
+- Make space with fusion, compression, and removal of uninformative phrases like
+  "the article discusses".
+- The summaries should become highly dense and concise yet self-contained, e.g.,
+  easily understood without the article.
+- Missing entities can appear anywhere in the new summary.
+- Never drop entities from the previous summary. If space cannot be made, add
+  fewer new entities.
 
-ITERATION 4 - USABILITY:
-Optimize for developer experience. What do they need to know most?
+Remember, use the exact same number of words for each summary.
 
-Show each version and explain key changes.
-```
-
-### Example 3: Email Refinement
+Answer in JSON. The JSON should be a list (length [N]) of dictionaries whose keys are
+"Missing_Entities" and "Denser_Summary".
 
-**Without CoD:**
-```
-Write an email announcing this feature.
+After the JSON, and outside it, add one short paragraph naming which summary you
+recommend and why. Do not default to the last one: in the paper's human evaluation,
+summary 2 (30.8% of first-place votes) and summary 3 (23.0%) were preferred over the
+sparse summary 1 (8.3%), because past a point density costs readability.
 ```
 
-**With CoD:**
-```
-Draft an announcement email, then refine it:
+### Relationship to the paper's original prompt
 
-DRAFT:
-Write a first draft covering all important information.
+The body above is the paper's prompt, reproduced closely on purpose — the specific wording, especially the fixed-length instruction and the entity criteria, is what makes the technique work. Three deliberate departures:
 
-ITERATION 1 - STRUCTURE:
-Reorganize for better flow. Most important information first.
+- **`SOURCE MATERIAL:` replaces the paper's `Article: {{ARTICLE}}` field.** Same job, house convention, and the trailing sentence survives header-stripping where a bare `Article:` label would not.
+- **`[TARGET]` and `[N]` are parameterized** where the paper hardcodes 80 and 5, so the template serves a user-supplied budget and pass count.
+- **The closing recommendation paragraph is an addition, not from the paper.** The paper reports the preference numbers; it does not instruct the model to act on them. This template does, so the user gets a pick rather than a default-to-last.
 
-ITERATION 2 - CLARITY:
-Simplify language. Remove jargon. Make it scannable.
+Sentence-case "missing entity" and "article" replace the paper's mid-sentence capitals. That is formatting only — no wording changed.
 
-ITERATION 3 - ENGAGEMENT:
-Strengthen the call-to-action. Make it more compelling.
+## Worked Example
 
-ITERATION 4 - POLISH:
-Final edits for tone, concision, impact.
+**Source:** a 1,200-word news article about a municipal transit funding decision.
 
-Show the evolution and explain major changes.
-```
+**Step 1 (sparse, ~80 words):**
+> This article discusses a recent decision made by local government officials regarding transportation. It covers the various considerations that were taken into account during the deliberation process, as well as some of the reactions from different groups. The piece also touches on the broader context surrounding the issue and what it might mean going forward for the region and the people who live there.
 
-### Example 4: Technical Explanation
+Entities: 0 meaningful. Pure filler — by design.
 
-**Without CoD:**
-```
-Explain how this algorithm works.
-```
+**Step 2 (same length, entities fused in):**
+> Portland's city council voted 4-1 on Tuesday to redirect $47 million from the Southwest Corridor light-rail project to bus rapid transit, citing a 30% cost overrun. Commissioner Dana Reyes cast the dissenting vote. TriMet, which operates the region's transit, had lobbied for the shift. Riders' advocacy group OPAL called the decision a setback for east-side commuters, while the Portland Business Alliance welcomed it.
 
-**With CoD:**
-```
-Explain this algorithm through progressive refinement:
+Same word budget. The filler is gone; ten specific entities took its place.
 
-PASS 1 - COMPREHENSIVE:
-Explain thoroughly, assuming no prior knowledge. Include:
-- What it does
-- How it works
-- Why it's designed this way
-- Example walkthrough
+**Steps 3-5** continue fusing — ridership figures, the revised completion date, the federal grant condition — each time compressing existing phrasing to make room.
 
-PASS 2 - REFINED:
-Review Pass 1. What's unclear? What's redundant? Rewrite addressing these.
-
-PASS 3 - OPTIMIZED:
-Make it maximally clear and concise. Every paragraph must earn its place.
-
-PASS 4 - POLISHED:
-Final pass. Perfect clarity, zero fluff, optimal examples.
+## Best Practices
 
-Show all passes and note significant improvements.
-```
+1. **Enforce the length constraint explicitly.** Models drift toward expanding. "Use the exact same number of words for each summary" is not optional boilerplate.
+2. **Let the first summary be bad.** The instinct is to start strong; resist it. A dense first summary leaves no slack, and the chain stalls immediately.
+3. **Ask for all iterations in one response.** The paper uses a single prompt returning a JSON list of five. Splitting it across turns loses the model's view of the prior chain.
+4. **Pick the step, don't assume the last.** Step 5 is the densest but not the most readable. Steps 2-3 won the human evaluation.
+5. **Watch for the readability tradeoff.** Past a point, dense summaries read as lists of facts. The paper found this explicitly.
 
 ## Combining CoD with Other Frameworks
 
 ### CoD + CO-STAR
-```
-CONTEXT: [Background]
-OBJECTIVE: [Goal]
-STYLE: [Writing style]
-TONE: [Tone]
-AUDIENCE: [Readers]
-
-RESPONSE PROCESS (Chain of Density):
-Draft 1: [Comprehensive version]
-Draft 2: [Refined for clarity]
-Draft 3: [Optimized for audience]
-Draft 4: [Final polished version]
-```
-
-### CoD + RISEN
-```
-ROLE: [Expertise]
-INSTRUCTIONS: Use iterative refinement
-STEPS:
-1. Create initial version
-2. Review and identify weaknesses
-3. Refine addressing weaknesses
-4. Repeat until optimal
-END GOAL: [Final quality criteria]
-NARROWING: [Constraints on iterations]
-```
+Use CO-STAR to fix audience, tone, and format for the summary; use CoD to maximize what fits in that format. Useful when the summary has a specific reader.
 
 ### CoD + Chain of Thought
-```
-For each iteration of Chain of Density, use Chain of Thought:
-
-ITERATION 1:
-Think through: What should this initial version include?
-[Create version]
-
-ITERATION 2:
-Think through: What weaknesses exist? How to address them?
-[Refine version]
-
-ITERATION 3:
-Think through: What can be compressed or improved?
-[Further refine]
-```
-
-## Advanced Techniques
-
-### Aspect-Focused Iteration
-Each iteration improves a different dimension:
-
-```
-ITERATION 1 - ACCURACY: Get the facts right
-ITERATION 2 - CLARITY: Make it understandable
-ITERATION 3 - CONCISION: Remove waste
-ITERATION 4 - IMPACT: Make it compelling
-ITERATION 5 - STYLE: Polish the voice
-```
-
-### A/B Iteration Branches
-Create alternative versions and merge best parts:
-
-```
-DRAFT: [Initial version]
-
-BRANCH A - CONCISION:
-[Optimize for brevity]
-
-BRANCH B - COMPLETENESS:
-[Optimize for thoroughness]
-
-MERGE:
-Combine the best elements of both branches.
-```
-
-### Constrained Progressive Compression
-```
-VERSION 1: 1000 words - Complete explanation
-VERSION 2: 500 words - 50% compression
-VERSION 3: 250 words - 75% compression
-VERSION 4: 100 words - 90% compression
-VERSION 5: 25 words - 97.5% compression
-
-Each version must be self-contained and accurate.
-```
-
-### Quality Metric Iteration
-```
-ITERATION 1:
-[Create initial version]
-Self-assess (1-10): Clarity ___ Concision ___ Accuracy ___ Impact ___
-
-ITERATION 2:
-[Improve lowest scoring dimension]
-Self-assess: Clarity ___ Concision ___ Accuracy ___ Impact ___
-
-ITERATION 3:
-[Improve next lowest dimension]
-Self-assess: Clarity ___ Concision ___ Accuracy ___ Impact ___
-
-Continue until all metrics > 8
-```
-
-## Refinement Strategies
-
-### What to Remove
-- Redundant information
-- Obvious statements
-- Unnecessary qualifiers ("very", "really")
-- Passive voice (often)
-- Filler words
-- Overly general statements
-
-### What to Add
-- Specific examples
-- Precise numbers
-- Concrete details
-- Missing context (if essential)
-- Clarifying examples
-
-### What to Improve
-- Vague language → specific language
-- Long sentences → shorter, punchier
-- Complex words → simpler alternatives (if clearer)
-- Weak verbs → strong verbs
-- Passive voice → active voice
-
-## Quality Indicators
-
-**Good CoD iterations show:**
-- ✅ Measurable improvement each pass
-- ✅ Increased information density
-- ✅ Reduced redundancy
-- ✅ Maintained accuracy
-- ✅ Enhanced clarity
-- ✅ Clear evolution path
-
-**Poor CoD iterations show:**
-- ❌ No meaningful change
-- ❌ Loss of important information
-- ❌ Decreased clarity
-- ❌ Introduced errors
-- ❌ Just made it shorter without improvement
-
-## Use Cases
-
-### 1. Content Summarization
-Taking long documents and progressively distilling essence
-
-### 2. Message Refinement
-Iteratively improving emails, announcements, communications
-
-### 3. Documentation Optimization
-Making docs clearer and more concise through iteration
-
-### 4. Explanation Enhancement
-Progressively improving how concepts are explained
-
-### 5. Writing Polish
-Iterative editing of creative or professional writing
-
-### 6. Presentation Optimization
-Refining slides/talks through multiple passes
+Ask the model to reason about which entities are most salient before selecting them. Helps when the source is long and salience is contested.
 
 ## Assessment Checklist
 
-When using Chain of Density:
-- [ ] Task benefits from iteration
-- [ ] Number of iterations specified
-- [ ] Optimization goals are clear
-- [ ] Each iteration has purpose
-- [ ] Constraints defined for each pass
-- [ ] Evolution is tracked/shown
-- [ ] Quality criteria established
-- [ ] Stopping condition exists
-- [ ] Final version is actually better
-- [ ] Process improved understanding
+- [ ] Is the task actually summarization? (If not, CoD is the wrong framework.)
+- [ ] Is a fixed target length stated?
+- [ ] Is the first summary deliberately sparse and padded?
+- [ ] Are entity criteria included in the prompt?
+- [ ] Does each step preserve all prior entities?
+- [ ] Is the word count roughly constant across steps?
+- [ ] Was the chosen step selected on merit rather than defaulting to the last?
 
 ## Tips for Success
 
-1. **Start Verbose**: First iteration should be complete, even if wordy
-2. **One Focus Per Iteration**: Don't try to improve everything at once
-3. **Show Your Work**: Display each iteration to see progress
-4. **Set Constraints**: Give specific targets (word counts, focus areas)
-5. **Verify Improvement**: Check that each iteration actually improves quality
-6. **Don't Over-Iterate**: 3-5 iterations usually sufficient
-7. **Preserve Accuracy**: Never sacrifice correctness for brevity
-8. **Explain Changes**: Note what improved and why
+1. **Fixed length, rising density** — if length is falling, it is not CoD
+2. **Start verbose on purpose** — the filler is the raw material
+3. **1-3 entities per step** — more causes dropped content
+4. **Five steps is the paper's number** — fewer works; more yields diminishing returns
+5. **Compare steps before choosing** — the densest is rarely the most useful