Keep Your Formatting on Every AI Rewrite
You rewrite a formatted paragraph — a couple of bolded terms, an embedded link, a bulleted list — and what comes back is a gray wall of plain text. Now you re-bold, re-link, and re-bullet by hand, and the rewrite that was supposed to save you time cost you more. Formatting loss is one of the quietest, most common ways AI editing fails. This page explains why it happens, what it takes to keep formatting through a rewrite, and how to tell whether a tool actually does.
Why rewrites flatten your formatting
Formatting gets destroyed at the boundary between rich text (what you see — bold, links, bullets, styled headings) and plain text (the raw characters the AI works with). A naive editing flow goes:
- Grab the selected text — often as plain text only, dropping all the styling on the way in.
- Send the plain text to the AI, which returns plain text.
- Paste the plain result back, which — depending on how the paste is done — lands as unstyled text.
At step one and step three, the formatting is simply not carried. The AI never even knew there was a bold run or a link, and the paste-back has nothing to restore. The result is technically the right words with none of the structure that made them usable.
Markdown content has its own version of this: a rewrite can strip the **asterisks**, the [link](url) syntax, the - bullets, and the # headers, turning structured markdown into a paragraph. Same failure, different surface.
What it takes to keep formatting
Preserving formatting through a rewrite is genuinely harder than dropping it, which is why so many tools don’t bother. Done right, it involves:
- Read the selection as rich text, not just characters. Capture the styling — which spans are bold, where the links are, what’s a list item — alongside the words.
- Protect or map the styled spans. Either keep the structure aside and re-apply it to the corresponding text after the rewrite, or instruct the model to preserve the markup and return it intact. (This overlaps with structure-safe editing, which protects code and variables by the same general approach.)
- Write back as rich text. Use the path that lands styled text into the field, not a plain-text paste that strips it — which is also why a reliable native write matters, since native writes preserve formatting where a crude clipboard paste may not.
- Keep markdown syntax intact when the document is markdown, so bullets stay bullets and links stay links.
The goal is that the only thing that changes is the words you asked to change — the bold stays bold, the link stays linked, the list stays a list.
Formatting is part of the larger “don’t break my text” promise
Keeping formatting sits alongside the other ways a rewrite shouldn’t damage your text:
- Clean output — stripping the AI’s “Sure, here’s…” preamble and stray quotes so only the result lands.
- Structure-safety — leaving code,
{variables}, and tables untouched (Structure-safe edits). - A diff before commit — so if formatting did shift, you see it before accepting.
A tool that nails the rewrite but flattens your text has only done half the job. The whole point of editing in place is that the place — including its formatting — survives.
How to test for it
Make a worst case and run it:
- Write a sentence with bold, a [hyperlink], and an italic phrase, select it, and run a tone rewrite. The bold, link, and italics should survive on the corresponding words.
- In a markdown app (Obsidian, Notion), select a small bulleted list with a link in it and run “tighten.” It should come back as a bulleted list with the link intact, not a flat paragraph.
- In an email client, rewrite a formatted signature-adjacent paragraph. Links and styling should hold.
If any of those flatten, you’ll pay the re-formatting tax on every rewrite — and that tax often exceeds the time the rewrite saved.
Formatting preservation in EditSnappy
EditSnappy keeps your formatting through every rewrite. It reads your selection as rich text, preserves bold, links, bullets, line breaks, and markdown across the replace, and writes the result back styled — so the only thing that changes is the wording you asked to change. It’s part of the same safe loop as every edit: the change streams into place, shows as a diff before it commits (Tab to accept, Esc to keep your original), strips the AI’s preamble, leaves code and variables alone, and is undoable with one key. Same behavior on Mac and Windows.
No flatten, no re-formatting tax. The rewrite that saves you time actually saves it. See it on the homepage →