compress-text

Compress Text

Produce a leaner, better-structured version of any text that costs less context without losing meaning. Method: group content MECE (mutually exclusive, collectively exhaustive), rephrase each group with the Pyramid Principle (key point first, detail beneath), drop anything off-purpose. When multiple groupings fit, generate candidates, measure, keep the best. Preserve original meaning and every distinct instruction, key point, requirement, reference, and example. Works on any format: prose, docs, notes, prompts, code comments, transcripts, Markdown.

When to use

• Shrink, compress, trim, restructure, or optimize any text/document
• Reduce a text's token/context-window footprint
• Measure a compression's effectiveness
• Content feels bloated, repetitive, wordy, or disorganized
• Deduplicate or consolidate overlapping content

When NOT to use

• Goal is interpretation/analysis/conclusions, not a shorter version (compression rephrases and removes; it never adds claims)
• No detail may be lost (e.g. legal text, exact quotes) — compress only surrounding prose, never the protected content

Parameters

• text reference (required): content to compress — a file path/name to read, or pasted text, in any format.
• mode (optional): dense (LLM-oriented) maximizes info per token — telegraphic, abbreviations and symbols ok, readability secondary; readable (human-oriented) keeps fluent prose, no cryptic fragments. Default readable; use dense when the target is an LLM prompt/context.
• aggressiveness (optional): conservative (default) consolidates and tightens clear cases only; aggressive also merges related groups and freely rewrites verbose passages.
• candidates (optional): alternative groupings to compare. Default 2-3; set 1 to skip comparison.
• template (optional): an output shape with named <!-- slot:NAME --> slots to emit into instead of the default Output template (see below).

Tags

Two tag families are always honored, in any format:

• Engine tags (auto-detected, locked verbatim): {{…}}/{{#…}}/{{/…}} (Handlebars/Mustache), {%…%} (Jinja/Liquid), ${…}/$NAME (JS/shell), <%…%> (ERB/EJS), {0}/{name} (format strings). Reproduce each exactly and in original order; never reorder, merge, or de-duplicate control-flow pairs ({% for %}…{% endfor %}, {{#each}}…{{/each}}) even when the text between them looks repetitive.
• Explicit markers (author-controlled): <!-- keep -->…<!-- /keep --> = reproduce verbatim; <!-- drop -->…<!-- /drop --> = always remove. Comment delimiters are invisible in rendered Markdown and never collide with engine tags. Strip the delimiters from the output unless the user asks to keep them.

Procedure

1. Load source. Read the full current version from the path/name or pasted text. Never work from memory of a prior version, so recent edits aren't dropped.
2. Anchor on purpose, inventory what to preserve. State the text's purpose in one line — the test for what stays. Count the load-bearing elements (the Step 6 fidelity baseline): distinct instructions/steps/requirements; structure/ordering readers or tooling depend on; key claims, decisions, definitions; references, links, parameters, names, numbers, required inputs/outputs; verbatim spans where exact content/format matters (code, quotes, tables, identifiers); every template tag (see Tags) and <!-- keep --> span, plus its position. Compression changes how briefly these are expressed, never whether they exist. Remove <!-- drop --> spans up front and exclude them from the baseline.
3. Generate candidate groupings (MECE). Produce candidates groupings (default 2-3): every idea in exactly one group (mutually exclusive), every preserved element mapped to a group (collectively exhaustive). Make candidates genuinely different by varying the grouping axis (topic, reader task, section, or content type) — different axes expose different redundancies and reveal the leanest structure.
4. Rephrase each candidate (Pyramid Principle). Per group, lead with the key point, then nest qualifiers, steps, examples. Merge duplicates into the single most specific version; use direct active phrasing; cut filler and hedging ("please note that", "it is important to", "as mentioned above"); don't restate in prose what a list, example, or heading shows; keep wording fuller wherever brevity would change meaning. Apply the mode — dense: telegraphic, drop articles/copulas, use standard abbreviations and symbols (w/, &, →, #, >=) when clear; readable: complete fluent sentences, no cryptic abbreviations.
5. Eliminate unrelated content. Drop anything failing the Step 2 purpose test: tangents, background informing no decision or action, out-of-scope content. Keep and flag ambiguous items rather than guessing.
6. Measure each candidate. Score size and meaning (shorter helps only if content survives): size reduction = token reduction % (best context-savings proxy; an estimate), word/char count as fallback, reported before→after; fidelity coverage = share of Step 2 elements surviving, per category and overall (target 100%) — including every template tag reproduced exactly and in original order; MECE audit = ideas in more than one group (must be 0) and preserved elements left ungrouped (must be 0); readability check (optional, strongest) = a reader can still find each key point and follow the flow (each lost or buried point is a fidelity failure).
7. Select the best and report. Efficiency-with-fidelity rule: a candidate's size reduction counts only if fidelity is 100% and the MECE audit is clean. Among passing candidates pick the largest reduction, breaking ties by cleaner Pyramid structure then readability. If none reach 100% fidelity, present the closest and explain the gap rather than shipping a lossy version. Reassemble the winner, preserving any title and the structure readers or tooling rely on, then report using the template below.

Output template

## Compressed text: <title or first line>

<full rephrased text of the selected candidate>

---

### Candidate comparison
| Candidate | Grouping axis | Size reduction | Fidelity | MECE clean? |
|-----------|---------------|----------------|----------|-------------|
| A         | <axis>        | ~<percent>%    | <n/n>    | yes/no      |
| B         | <axis>        | ~<percent>%    | <n/n>    | yes/no      |
Selected: <candidate> - <why it won>

### Preserved intact
- <count> instructions/requirements, <count> references, <count> verbatim spans/examples, structure

### How it was compressed
- MECE grouping: <ideas consolidated; duplicates removed>
- Pyramid rephrasing: <key-point-first rewrites and tightening>
- Removed as unrelated: <what was dropped and why>

### Estimated size reduction
~<before> tokens/words -> ~<after> (~<percent>% smaller)

If a template parameter is supplied, emit it instead: fill each <!-- slot:NAME --> with the matching value (compressed, title, reduction, candidate_table, preserved), pass unknown text through verbatim, and drop slots with no value.

Success criteria

• Meaning fully preserved (fidelity coverage 100%)
• Multiple candidates generated, measured, and compared (unless candidates=1)
• Selected candidate has the best size reduction among those passing the efficiency-with-fidelity rule
• Groups are MECE; each leads with its key point (Pyramid Principle)
• Output matches the requested mode (dense or readable)
• All template tags reproduced exactly and in order; <!-- drop --> spans removed; output template (if given) filled
• Title and structure preserved; candidate-comparison metrics reported

Error handling

• Source unreadable: ask the user to paste the text.
• Already lean: say so; report a small or zero reduction rather than cutting meaningful content to hit a target.
• No candidate reaches 100% fidelity: present the closest, explain what couldn't be preserved, let the user decide.
• A rephrase or removal risks changing meaning: keep the original and note why.

Guardrails

• Preserve meaning above all: rephrase, regroup, or remove only when meaning is fully retained; never invent details not in the source.
• Never drop a distinct instruction, requirement, reference, or example; never alter verbatim spans (code, quotes, identifiers) except to remove genuine duplication.
• Never edit, reorder, merge, or drop a template tag (engine tag or <!-- keep --> span); compress only the prose around them.
• Remove content only when it fails the purpose test, never just to save space; when in doubt, keep and flag it.

Keywords

compress text, shrink content, trim text, restructure, reduce tokens, save context window, measure effectiveness, pyramid principle, MECE, candidate grouping, semantic grouping, deduplicate, summarize, optimize, bloated content, dense mode, readable mode, template, template tags, placeholders, handlebars, mustache, jinja, liquid, keep tag, drop tag, output slots