Cleaning AI text means stripping the typographic fingerprints that large language models leave behind — em dashes, smart quotes, ellipsis characters, hidden Unicode, and double spaces — and replacing them with ordinary keyboard characters, all without rewriting a single word. A clean paste lands in your CMS, email, or spreadsheet as plain text instead of a paste that drags with it zero-width spaces, byte order marks, and curly quotation marks that look wrong on a phone and break find-and-replace. The job is formatting only: no synonyms are swapped, no sentences are reshaped, no AI detector is fooled. You paste the AI draft, switch on the rules that matter for your draft, run the cleanup, and copy the result. Each rule reports a count of what it changed, so you can verify the work instead of trusting a silent rewrite. Every run happens in your browser, which means the draft you are cleaning is never uploaded, never stored, and never attached to an account.
What "Cleaning AI Text" Actually Removes
AI assistants pull from training text written in publishing software, so their output inherits publishing typography by default. The result is a draft full of characters that look right on a manuscript but look out of place in a help center article, a Jira comment, or a WordPress post. Four families of artifact show up over and over.
First, the typographic dashes. Large language models love the em dash — U+2014 — and use it the way a human writer might reach for a colon. They also leak the en dash U+2013, the horizontal bar U+2015, and three hyphens that look identical to a keyboard hyphen but are not one: U+2010, U+2011, and U+2012. Together they make find-and-replace and search behave inconsistently across a document, since "left–right" and "left-right" do not match the same string.
Second, smart quotes. Curly single and double quotes (U+2018 through U+201F) and the prime and double prime marks replace the straight apostrophe and the straight double quote. The straight forms are what most CMSes, spreadsheets, and search engines expect.
Third, the ellipsis character U+2026, a single code point that renders as three dots. Plain text workflows expect three literal full stops.
Fourth, invisible Unicode. This is where the cleanup does the most important work, and the dedicated section below explains why in detail.
The Six Switchable Rules at a Glance
The AI Text Cleaner exposes six rules, each as its own switch. Tick the ones that matter for your paste and leave the rest off — for example, you can straighten quotation marks without touching dashes, or strip invisible characters while leaving your paragraph spacing exactly as it is.
| Rule | What it changes | What it leaves alone |
|---|---|---|
| Dashes | Em dash, en dash, horizontal bar → your choice of hyphen, comma, or single space; a run of several dashes collapses to one replacement and never produces a double space or a space before a comma | U+2010, U+2011, U+2012 always become a single hyphen; the minus sign U+2212 stays because it is a math operator |
| Quotes | U+2018 through U+201F plus prime and double prime marks → straight apostrophe and straight double quote | Guillemets and CJK brackets, since rewriting them would damage legitimate non-English quoting |
| Ellipsis | U+2026 → three ordinary full stops | Nothing else in the ellipsis rule |
| Invisible characters | Zero-width space, word joiner, byte order mark, soft hyphen, combining grapheme joiner, LTR/RTL marks, invisible math operators, Unicode Tags block, supplementary variation selectors, bidirectional embeddings, overrides and isolates | Zero-width joiner, zero-width non-joiner, and variation selectors U+FE00 to U+FE0F, because they hold emoji and non-Latin scripts together |
| Spacing | Two or more spaces or tabs collapse to one; trailing spaces are trimmed at the end of every line | Newlines are handled by the blank-line rule instead |
| Blank lines | Runs of blank lines collapse to at most one; leading and trailing blank lines are removed | A single blank line between paragraphs is preserved |
Every code point in these lists was checked against the Unicode Character Database and cross-checked against a second authoritative source, so the rules cover full ranges instead of a sampled subset. Each run reports the per-rule change count, so the totals you see match the output exactly.
How to Clean AI Text in Three Steps
The whole workflow fits three clicks.
- Paste the AI-generated text into the box, or select Load sample to see a typical example.
- Tick the rules you want to run and, for the dash rule, pick whether each typographic dash should become a hyphen, a comma, or a single space.
- Select Clean text, check the per-rule change counts, then copy the cleaned result.
The per-rule change counts matter. They tell you, for example, that the dash rule replaced nine characters and the invisible-character rule stripped four, so you can confirm the cleanup did what you expected instead of trusting a silent rewrite. The output always uses LF line endings, so carriage returns from Windows and the U+2028 and U+2029 line separators that come out of PDFs, InDesign, and older Word documents all normalize the same way as text copied from a web chat.
If you only want to fix one thing — say, the em dashes in a blog draft — switch off every other toggle so the same rule participates. The dash rule collapses a run of several dashes into a single replacement and repairs the surrounding spacing, so you never end up with a double space or a space before a comma at the seam.
Why Hidden Unicode Deserves the Most Attention
Smart quotes and ellipses are visible the moment you open the draft. Hidden Unicode is invisible until something goes wrong, and then the fix is rarely obvious.
The invisible-character rule removes the zero-width space, the word joiner, the byte order mark, the soft hyphen, the combining grapheme joiner, the left-to-right and right-to-left marks, the invisible mathematical operators, and both hidden watermark carriers: the Unicode Tags block and the supplementary variation selectors. It also removes the bidirectional embeddings, overrides, and isolates behind the Trojan Source vulnerability, which are invisible, survive copy and paste, and can reorder how a line renders on screen.
Every fixed-width and no-break space becomes an ordinary space, so later find-and-replace and word counts behave as expected. The result is text that looks identical on screen but behaves predictably in any downstream tool — a paste into Excel no longer inherits a stray BOM, a paste into a CMS no longer drags with it a zero-width space that breaks search.
Characters the Cleaner Keeps on Purpose
Not every invisible character is junk. Three are deliberately kept because they are load-bearing for legitimate text.
The zero-width joiner holds multi-person emoji sequences together: a family of four followed by a heart, a flag, a keycap, or a skin tone all rely on it. Strip it and the sequence falls apart into a row of unrelated glyphs.
The zero-width non-joiner is grammatically required in Persian, Arabic, and several Indic scripts. Removing it from a single Arabic word can change its meaning, so the cleanup tool treats it as part of the word, not as junk.
Variation selectors U+FE00 through U+FE0F are what make an emoji render as an emoji rather than as a black-and-white text glyph. U+FE0F in particular flips a code point into the colored emoji presentation that users expect on a phone.
The split is intentional: the listed characters are removed as AI artifacts and the three load-bearing ones are kept, so cleaning the text does not break legitimate Unicode use while it strips the fingerprints that large language models leave behind.
Browser-Only Cleanup, One Million Character Cap
Every step of the cleanup runs locally in your browser. The text is never uploaded to a server, never stored, never sent to an API, and never attached to an account. That matters when the draft you are cleaning is client work, a confidential brief, or an unpublished manuscript.
Input is capped at one million characters per paste, so a large paste cannot freeze the tab. The cap exists because the rule engine walks the entire input against the verified Unicode ranges, and an unbounded paste would lock up the page.
The first thing the engine does is fold every line separator to a line feed: carriage returns from Windows, U+2028 from PDFs, U+2029 from older Word documents, and CR-LF combinations all become LF. That way every paste behaves the same as text copied from a web chat, and the output is consistent for the next tool in your workflow.