Redundant Phrase Compression Prompt

This prompt is a surgical tool for text generation pipeline operators who need to clean up verbose model outputs before they reach end users or downstream systems. It targets a specific failure mode: a single model response that contains repeated phrases, boilerplate language, or filler words that add token cost and reduce readability without contributing semantic content. Use this prompt as a post-generation repair step when you need to compress output while preserving all factual claims, logical structure, and the original tone. The ideal user is a backend engineer, platform developer, or AI pipeline operator who observes that model outputs are consistently longer than necessary due to internal repetition rather than substantive detail.

This is not a summarization prompt. It should not be used to shorten content by removing substantive information or to rewrite output in a different style. Do not apply this prompt when the repetition is intentional—such as refrains in creative writing, emphasis in instructional content, or repeated data entries that carry distinct contextual meaning. The prompt works best on outputs longer than 200 words where redundancy is visibly degrading quality. For shorter outputs, the overhead of the repair step may exceed the benefit. If you need to deduplicate structured records, merge near-duplicate paragraphs across multiple outputs, or collapse redundant JSON fields, use the sibling deduplication prompts in this pillar instead.

Before wiring this prompt into a production pipeline, establish a compression ratio baseline on a sample of your model's typical verbose outputs. Measure token count before and after compression, and spot-check a subset of compressed outputs for factual preservation. If the prompt consistently removes claims, alters numbers, or changes the tone, your model may be over-compressing—adjust the constraints or add a factual consistency eval before shipping. For high-risk domains where information loss could cause harm, always route compressed outputs through human review or an LLM judge that compares key claims against the original.

This prompt template is designed to be dropped directly into your application's prompt layer. It instructs the model to act as a compression engine that identifies and collapses repeated phrases, filler words, and boilerplate language within a single text block. The goal is to reduce token count and improve signal-to-noise ratio without losing factual claims, logical structure, or necessary nuance. Use this when you have a verbose model output—such as a long-form summary, a generated report, or a chat response—that needs to be tightened before it reaches a user, a database, or another model in a chain.

textCopy
You are a text compression engine. Your task is to compress the provided [INPUT_TEXT] by removing redundant phrases, filler words, and repetitive boilerplate while strictly preserving all semantic content, factual claims, and logical relationships.

[CONSTRAINTS]
- Do not remove any unique facts, figures, dates, names, or claims.
- Do not alter the original meaning or tone.
- If a concept is stated multiple times, keep the most complete and clear instance.
- Remove filler phrases such as "it is important to note that," "as previously mentioned," and "in other words" when they do not add new information.
- Preserve all [REQUIRED_ELEMENTS] if specified.

[OUTPUT_SCHEMA]
{
  "compressed_text": "string",
  "compression_ratio": "number (original_tokens / compressed_tokens)",
  "removed_phrases": ["string"],
  "preserved_claims": ["string"]
}

[INPUT_TEXT]
"""
[PLACEHOLDER_FOR_VERBOSE_MODEL_OUTPUT]
"""

[EXAMPLES]
Input: "The quarterly revenue increased by 15%. It is important to note that the quarterly revenue saw an increase of 15% compared to the previous period. In other words, revenue went up by 15%."
Output: {
  "compressed_text": "The quarterly revenue increased by 15% compared to the previous period.",
  "compression_ratio": 3.0,
  "removed_phrases": ["It is important to note that", "In other words, revenue went up by 15%."],
  "preserved_claims": ["quarterly revenue increased by 15%"]
}

To adapt this template, replace [PLACEHOLDER_FOR_VERBOSE_MODEL_OUTPUT] with the actual text you need to compress. If your use case has specific elements that must survive compression—such as legal citations, product names, or numerical ranges—list them in a [REQUIRED_ELEMENTS] array and append it to the constraints. The [OUTPUT_SCHEMA] block enforces a structured JSON response, which is critical for programmatic consumption. If you are using a model that struggles with JSON adherence, consider appending a stricter format instruction or using a validation harness that retries on schema mismatch. For high-stakes content like medical or legal text, always route the compressed output to a human reviewer and compare the preserved_claims array against the source document's fact set before accepting the result.

The Redundant Phrase Compression Prompt is designed to sit as a post-processing step in your text generation pipeline, immediately after the primary model produces its output. It should be called before the output reaches any downstream consumer—whether that's a user-facing UI, a database, or another model in a chain. The prompt expects a single text block as input and returns a compressed version with a structured compression report. Wire this as a synchronous transformation step: your application receives the verbose model output, injects it into the [INPUT_TEXT] placeholder along with any [COMPRESSION_TARGET] (e.g., 'aggressive', 'moderate', 'conservative') and [READABILITY_THRESHOLD] constraints, then passes the result through validation before forwarding it.

Validation is the critical harness component here. After the compression prompt returns its output, you must parse the structured response to extract both the compressed_text and the compression_report object. Run automated checks: verify that compression_ratio (calculated as 1 - (output_tokens / input_tokens)) falls within an expected range for your target setting—aggressive compression might target 40-60% reduction, while conservative should stay under 20%. Check the readability_score field against your configured [READABILITY_THRESHOLD]. If either check fails, retry with adjusted parameters or escalate to a human review queue. Log every compression event with the input hash, output hash, ratio, readability score, and the list of phrases_removed for observability. For high-stakes content like legal summaries or medical notes, always route outputs below the readability threshold to a human reviewer before publication.

Model choice matters for this workflow. The compression task requires strong instruction-following and precise text manipulation, making it well-suited for models like GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro. Avoid smaller or older models that may drop semantic content during aggressive compression or fail to produce valid structured reports. Implement a retry strategy with exponential backoff for malformed responses—if the model fails to return parseable JSON with both compressed_text and compression_report fields, retry up to two times with an explicit error message injected into the prompt context. After two failures, log the raw output and route the original uncompressed text through a fallback path. Do not silently pass uncompressed or corrupted text downstream. For streaming applications, buffer the full primary output before invoking compression; this prompt is not designed for partial or chunked input.