Two-Pass Generation: How to Rescue Text Quality from Formatting Constraints

STEP 1 (separate request): Answer the question fully, with no constraints
         → You get a detailed answer with all the information

STEP 2 (separate request): Rewrite this text under the constraint,
         keeping every detail and the full scope
         → You get the same volume, but in the required format

Both steps happen in a regular chat. Nothing technical.

Task: You need to write an email to a potential partner — without stiff bureaucratic connectors ("nevertheless," "consequently," "in addition") that make the text dull and formal. This is a real-world request: editors, marketers, founders — everyone wants text like this.

Prompt (step 1):

Write an email to a potential partner — a venture fund.
We're a restaurant food delivery service for small US cities (100–300K residents),
we operate in 12 cities, with $500K in monthly gross sales.
We'd like to discuss a round to expand into 30 new cities.

Write it in full: cover the value, the metrics, the ask and the next step.

Prompt (step 2):

Here is the email text:

[paste the result of step 1]

Rewrite it so the text contains none of these words: "nevertheless," "consequently,"
"in addition," "thus," "moreover," "in this regard."

Important: keep every detail, argument and the structure — only replace those words
with natural transitions, or simply drop them and restructure the sentences.

Result: In the first step the model produces a full email with arguments, metrics and a call to action. In the second, it rewrites it without the listed words but keeps the full volume. Without the two-pass approach, a single request — "write an email without these words" — would give you text half as long and much thinner in substance.

The weakness: Instruction tuning (training a model to be an assistant) isn't just "teach it to answer." It's training on "request → ideal answer" pairs with a particular format. As a result, the model doesn't just know how to answer — it knows what an answer to a similar request usually looks like. Formatting constraints break that familiar template, and the model falls back to a backup mode: short, neutral, safe.

Why it's planning, not inability: The study showed that the decision is made before the first generated word — literally while the prompt is being processed. A simple mathematical probe (linear regression on the model's internal layers) predicted the length of the upcoming answer with R²=0.51–0.93 before generation started. In other words, the model "knew" it would write little before it even began. Untrained base models don't show this effect — so it's instruction tuning specifically that creates it.

How the two-pass approach gets around it: The first request, with no constraints, activates the full answer template. The second request is an editing task (rewrite existing text), not a generation task (create something under a constraint). Editing doesn't trigger the switch to minimal mode — the model works with concrete material and simply adapts it. So two separate requests give a better result than one that sets requirements for form and content at the same time.

Control levers: - An explicit "keep it complete" instruction in the second step is key. Without it, the model may shorten the text again while rewriting. Write: "keep every detail, argument and the structure." - The more radical the constraint (frequent words like "the" / "and" / commas), the more the second pass matters. For mild constraints ("write without numbered lists") the difference is smaller. - How detailed the second prompt is — you can add: "if a sentence sounds awkward without that word, restructure it without losing the meaning."

Step 1 — free generation:

{Question or task}

Answer fully and in detail. {Additional context, if needed}

Step 2 — rewrite under the constraint:

Here is the text:

[paste the answer from step 1]

Rewrite it to follow this constraint: {your constraint}.

Important: keep the full length, every detail and argument.
Change only what violates the constraint.

Placeholders: - {Question or task} — your main request - {Additional context} — tone, audience, goal - {your constraint} — the specific formatting requirement: "without the word X," "without bullet lists," "without commas," "short sentences only"

🚀 Quick start — paste into the chat:

Help me apply two-pass generation to my task.
The idea: first we generate a full answer with no constraints,
then we rewrite it under the constraint, keeping the volume.

Ask me questions to figure out what I need to write
and which constraint I want to apply to the text.
Then give me two prompts: one for step 1 and one for step 2.

[paste the template above]

The LLM will ask what to write and which constraint to apply — because without that it can't fill in {task} and {your constraint}. It will take the pattern from the template and adapt it to your task.

⚠️ Very frequent tokens: If you ban the most common elements of the language — say, the word "and" or all commas — the two-pass approach may not fully recover the text. In those cases rewriting is hard in itself.

⚠️ Not for constraint compliance: The two-pass approach eliminates content loss, but it doesn't guarantee 100% compliance with the constraint in the final text. If compliance is mandatory, you need a check.

⚠️ Standard "good/bad answer" rating is blind to this problem: If you ask a model to rate a text on a 1–10 scale, it barely notices the quality loss from constraints (it detects 3.5% degradation where pairwise comparison shows 23%). If you want to compare two versions of a text, give them both at once, not one at a time.

⚠️ The effect shows up even in GPT-4o-mini and its peers: This isn't a cheap-model bug. Commercial closed models lose 31% of completeness from a trivial "don't use commas." Commercial fine-tuning fixes other problems, but not this one.

The idea was brutally simple: take 40 ordinary questions ("explain gradient descent," "how to write a good research paper"), add one of eight trivial constraints to each — and see what happens. No exotic testing: ban the comma and measure how much worse the answer gets.

Results were compared in two ways: independent rating on a 1–10 scale (standard practice) and pairwise comparison (baseline answer vs. constrained answer side by side — which is better?). The gap turned out to be sevenfold: independent rating saw 3.5% degradation, pairwise saw 23%. That's an important methodological finding: if you evaluate text quality in isolation, you systematically miss the failures. Only when you put two versions side by side does the difference become obvious.

The most convincing experiment compared tuned models with base (untuned) models. Base models under the same constraints showed random, unsystematic effects — sometimes the constraint even improved the answer. Instruction-tuned models showed a systematic collapse almost everywhere. So the problem is created specifically by instruction tuning, not by the nature of language models. That moves the finding from "weird bug" to "structural property of all assistant models."

Two-pass recovery experiment:

For each of 10 prompts and 2 constraints (no comma, no "the"), we generate:

(1) a baseline response (no constraint),
(2) a single-pass response (constraint in prompt),
(3) a two-pass response:
    — generate baseline,
    — then rewrite it under the constraint with explicit instruction
      to maintain comprehensiveness.

We measure word-level length retention relative to the baseline.

Single-Pass vs Two-Pass Retention (word count vs baseline):

Context: The researchers tested whether the collapse is a capability problem or a planning problem. The two-pass approach showed that the model is physically capable of writing the full text under the constraint — it just doesn't plan to do so in "generate straight away with the constraint" mode.

💡 Adaptation for style editing: The same two-pass principle works for any stylistic edits — not just formatting constraints. If you want to make a text "more conversational," "remove the passive voice," or "cut it to 150 words," get the full version first, then adapt it.

Step 1: write a full draft of [topic/task]
Step 2: here is the text: [draft]
Rewrite it: [style requirement].
Keep all the key ideas and arguments.

🔧 Technique: pairwise comparison instead of isolated rating → an honest quality assessment

The study showed that if you ask a model to rate a single text on a scale, it doesn't see the degradation. If you give it two texts side by side, it does.

How to use it: when you need to choose the better of two versions of a text, don't rate them one at a time. Give both at once:

Here are two versions of a text. Rate each one by the criterion [criterion].
Then compare: which is better, and why?

Version A:
[text A]

Version B:
[text B]

This applies to emails, posts, scripts — any content where relative quality matters more than absolute quality.

💡 The "separate what to say from how to say it" principle: This study's finding is a special case of a broader rule. Content instructions and form instructions compete within a single prompt. Separate them:

• Prompt 1: what needs to be said (content, arguments, details)
• Prompt 2: how it should look (format, style, constraints)

This works not only for text constraints but also for structural requirements: "format it as a table," "split it into 5 short paragraphs," "write it as an FAQ."

"One Token Away from Collapse: The Fragility of Instruction-Tuned Helpfulness"

Erfan Baghaei Potraghloo, Seyedarmin Azizi, Souvik Kundu, Massoud Pedram

University of Southern California; Intel AI

Related work mentioned in the study: - IFEval (Zhou et al., 2023) — an instruction-following benchmark - MT-Bench (Zheng et al., 2023) — a standard answer-quality benchmark - Format tax (Lee et al., 2026) — the impact of structured formats (JSON/XML) on reasoning quality