Long-Form Control: Density, Style, and Readability at Scale

Promise: by the end of this guide you’ll be able to steer long outputs with precision—setting density and section budgets, enforcing a house style, and wiring in fast self-checks for “covered the facts” and “no extra claims.” You’ll also leave with a compact, production-friendly editorial rubric you can drop into evaluations or CI.

Ask a model for a 1,200-word brief and you’ll often get one of three failures: it meanders (low density), it reads like a spreadsheet (over-dense), or it’s pretty but invents details (style over faithfulness). What you want is a controlled arc: a layout with budgets, an explicit density target, and guardrails that make the text skimmable without losing accuracy. That’s what we’ll build.

A useful anchor is Chain-of-Density (CoD): iteratively add missing salient entities while keeping length constant. It shows that people prefer summaries that are more entity-rich—up to a point where readability starts to dip. We’ll generalize that idea from short summaries to long pieces with multiple sections and quality checks. (arXiv, aclanthology.org)

Think of long-form generation as four moves:

1. Blueprint. Declare the structure in plain language: sections, word budgets, required entities, audience, and style constraints.

2. Draft. Produce a low-density, readable version first.

3. Densify. Run one or two targeted densification passes that add missing entities without increasing each section’s budget.

4. Check. Run two fast self-checks: coverage of facts (did we include what matters?) and no extra claims (did we add anything unsupported?).

CoD provides the densify trick; QA-style and alignment-style metrics inform the checks you’ll mimic in-prompt or automate offline. (arXiv, aclanthology.org)

Scenario. You have a 2,000-word report about a city’s climate plan. You need a 700-word executive brief that senior staff can skim in five minutes.

Prompt (single shot, end-to-end skeleton). Use this once to see the full arc; then we’ll break it into modular steps.

You are an editor. Produce an executive brief from the provided report. Audience: non-technical city leadership. Tone: plain, neutral, active voice. Section layout & budgets (hard caps):

1. Context & Goals (110–130 words)

2. Key Measures (220–260 words) — list 6–8 measures; name costs & timelines

3. Risks & Unknowns (120–150 words)

4. What to Decide This Quarter (110–130 words)

5. Appendix: Definitions (70–90 words)
   

That “densify once, verify twice” cycle scales CoD to long-form while keeping readability. The “quote the supporting span” trick is a light, reference-free echo of QA-based and alignment-style evaluation. (arXiv)

Density: the useful knob you can actually tune

Density is “how many salient entities per 100 words.” In practice: name the people, orgs, programs, locations, dates, numbers, and technical terms that matter—and budget them per section. CoD’s insight is to find and insert missing entities at constant length, which forces tighter phrasing, prunes fluff, and trades adjectives for facts. For long-form, do at most one to two densification passes; beyond that, readability drops. (arXiv)

💡 Insight: Don’t densify all sections equally. Heavier density fits “what/why/how much” sections; lighter density fits context, takeaways, or recommendations.

Section budgets and “slots”

Budgets are the most reliable lever for shape. Give each section a min-max word window and a slot count if it’s a list. Example: “Key Measures: 6–8 bullets, each 28–36 words, must include cost + timeline + owner.” Budgets and slots force trade-offs and produce predictable scannability.

Style as constraints, not vibes

Style gets consistent when you make it concrete: sentence length range (e.g., 12–18 words), active voice, tense, person, banned constructions (“avoid ‘will leverage’”), and a lexicon of allowed/forbidden synonyms. Include one short exemplar paragraph as a style anchor; that’s often enough.

Readability at a glance

Skimmability comes from predictable scaffolding: short lead paragraph; lists with parallel structure; “why it matters” lines; inline anchors to sources; and tight paragraphs. You don’t need a formula—just keep sentence lengths in range, keep named entities early in sentences, and avoid nesting clauses.

Verification hooks that run fast

Two quality properties really matter:

1. Coverage of facts — did the output include the must-haves?

2. No extra claims — did it invent or over-specify?

Research-grade tools approach these with QA-based methods (generate questions from source, answer from summary) and alignment/entailment methods (measure whether the summary’s statements are supported by source). We’ll mirror the logic in-prompt for speed, then point to automations when you need them. (arXiv, aclanthology.org)

⚠️ Pitfall: “LLM-as-judge” can rubber-stamp the model’s own writing. Use different model families (or at least different decoding settings) for generation vs. judging, and keep the judge’s rubric explicit. Evidence shows chain-of-thought + form-filling judges correlate better with humans when carefully prompted, but they can still be biased toward LLM-style text. (arXiv, aclanthology.org)

Below, each block is introduced in one sentence and designed to be copy-pasted. Replace bracketed variables.

1) Blueprint prompt (structure + budgets)

What it does: frames the piece with immutable section budgets and concrete style constraints.

2) Densify once (constant-length insertion)

What it does: asks the model to list missing entities per section, then integrates them without growing sections.

This is your long-form CoD step: add what matters, keep the cap. (arXiv)

3) Coverage-of-facts self-check (QA-style, fast)

What it does: turns the brief into atomic claims and asks for matching quotes from source.

This mirrors QA-based factuality checks like QAFactEval in spirit, but runs in-prompt. For production, you can automate a real QA-based check. (arXiv, GitHub)

4) No-extra-claims self-check (alignment-style, fast)

What it does: hunts hallucinated names/numbers and forces surgical fixes.

This operationalizes “alignment” between output and source—akin to alignment-style metrics like AlignScore. (arXiv, aclanthology.org)

5) House-style polishing

What it does: enforces lexicon and sentence rhythm without changing facts.

You can score an output in a single pass—by a human or a judge model—using a compact rubric. Keep it short, explicit, and reference-backed.

Scoring scale: 0=fail, 1=weak, 2=adequate, 3=strong.

• Coverage of facts (0–3): Are all must-have entities/events present with correct roles/numbers?

• No extra claims (0–3): Any unsupported names, numbers, or implications?

• Density control (0–3): Are entity counts near targets per section without clutter?

• Style adherence (0–3): Tone, voice, lexicon, and banned phrases respected?

• Readability & budgets (0–3): Sections within word caps; sentences 12–18 words on average; lists parallel and scannable.

Output schema (for LLM-as-judge or tooling):

LLM-as-judge frameworks like G-Eval pair well with such explicit scorecards and often correlate better with humans than vanilla references, but keep the known bias caveat in mind—and prefer a different model family as the judge. (arXiv, aclanthology.org)

It reads like a phone book (over-dense). Lower the per-section density target and allow one sentence per section that contains context but zero new entities (“breather sentences”). CoD’s own results note a trade-off between informativeness and readability; lean into it. (arXiv)

Budgets keep overflowing. Move the densify step after a strict length compress step. Ask the model to replace adjectives with named entities, not to add sentences.

Style drifts late in the piece. Re-anchor with a one-paragraph exemplar and a banned-phrases list. Ask for a final pass that changes form only, not content.

Coverage check misses subtle omissions. Raise the claim count or prime the checker with 10 must-haves (you provide them). For production, add a QA-based external check. (arXiv)

“No extra claims” flags everything. You’re likely asking for quotes that don’t exist—some sources are weak. Allow “softened restatements” if they’re entailed by multiple spans; alignment-style metrics take this view. (arXiv)

Goal: feel how density targets and checks change the output.

1. Pick any Wikipedia article under 1,500 words.

2. Run the Blueprint prompt with two sections: “What happened” (220–260 words, density 7–9/100) and “Why it matters” (140–170 words, density 4–6/100).

3. Run Densify once.

4. Run Coverage and No extra claims checks using only the article as source.

5. Score with the rubric.

Expected feel: the densified draft reads crisper and packs more nouns; the coverage checklist surfaces 2–4 claims you forgot to state explicitly; the extra-claims pass forces you to remove a confident-sounding but unsupported detail. On a second attempt, you’ll hit budgets cleanly and the result will skim faster.

• Separate generator and judge. Use a different model (or a different family) for rubric scoring. LLM-as-judge correlates best when the rubric is explicit and the judge provides rationales—but beware bias toward LLM-ish phrasing. (arXiv)

• Automate slow checks. If your task is critical, wire a QA-based factuality check (e.g., generate questions from source and answer from output) and/or an alignment metric as a backstop; both families have strong empirical support. Use them as gates or for sampling. (arXiv, aclanthology.org)

• Log budgets and density. Store section lengths, entity counts, and rubric scores alongside the text. You’ll quickly see which sections tend to overflow and where fabrications creep in.

• Tune densification passes. One pass usually suffices; two when sources are messy; three is rarely worth the readability hit. (arXiv)

Controlling long-form outputs isn’t about clever phrasing—it’s about declaring constraints and enforcing them. Start with a crisp blueprint: sections with word caps, density targets, and house-style rules. Produce a low-density draft, then run a single densification pass inspired by Chain-of-Density to swap fluff for facts without bloating length. Close the loop with two lightweight checks: prove you covered what matters and prove you didn’t invent anything.

When this rhythm—Blueprint → Draft → Densify → Check—becomes muscle memory, your long pieces get both denser and more readable, and the verification scaffolding gives you confidence to scale.

Next steps

• Turn the rubric into a small eval: store scores and compare models/decoders on your domain.

• Add an automated QA-based or alignment-style gate for your highest-stakes sections. (arXiv)

• Create a one-page style sheet (lexicon + banned phrases + exemplar paragraph) and include it in every blueprint.

References (selected)

• Chain-of-Density: Adams et al., From Sparse to Dense: GPT-4 Summarization with Chain of Density Prompting (2023). (arXiv, aclanthology.org)

• QA-based factuality: Fabbri et al., QAFactEval: Improved QA-Based Factual Consistency Evaluation for Summarization (2021/2022). (arXiv, aclanthology.org, GitHub)

• Alignment/entailment metrics: Zha et al., AlignScore: Evaluating Factual Consistency with a Unified Alignment Function (2023). (arXiv, aclanthology.org)

• LLM-as-Judge: Liu et al., G-Eval: NLG Evaluation using GPT-4 with Better Human Alignment (2023) and subsequent surveys on LLM-based evaluation. (arXiv, aclanthology.org)