Fixing Broken Bullet Points in Copilot Generated Emails

You’ve just spent five minutes prompting Microsoft Copilot to summarize a chaotic thread of twenty emails. The output in the side pane looks perfect: crisp bullet points, bolded key terms, and a clear call to action. Then you click "Insert" or copy-paste it into your Outlook draft, and the formatting explodes. The bullets have turned into tiny, unreadable dots, the indentation is halfway across the page, or worse—you have double bullets, one from the AI and one from Outlook trying to help.

This is the hidden tax of using AI tools: the time you save generating text is often lost fixing the mess it makes of your email client’s rendering engine. Here is the technical breakdown of why copilot bullet points break and exactly how to fix them without rewriting the whole email.

The Core Conflict: Markdown vs. The Word Engine

To understand why your lists break, you have to understand the language barrier between your AI and your email client.

Copilot, like the GPT-4 model it’s built on, "thinks" primarily in Markdown. When it generates a list, it’s creating a simple text structure using hyphens (-) or asterisks (*) to denote list items. It’s lightweight and web-friendly.

Outlook for Desktop, however, does not render HTML like a web browser. It uses Microsoft Word’s rendering engine. When you paste that AI-generated text, Outlook tries to translate that Markdown-flavored HTML into Word’s proprietary VML (Vector Markup Language) and complex XML schemas.

The translation layer fails because Copilot often wraps the list items in <span> tags with specific CSS styles (like font-family: Segoe UI) that clash with your Outlook default styles (usually Calibri or Aptos). Outlook panics and either strips the list tag (leaving you with a wall of text) or hard-codes the bullets as symbols, making them impossible to adjust with the paragraph ruler.

Anatomy of a Broken List

Before we fix broken lists, identify which type of formatting failure you are dealing with. The solution depends on the symptoms.

The "Phantom" Bullet

This happens when the AI generates a visual bullet character (•) but doesn't wrap it in HTML list tags (<ul> and <li>). Outlook sees this as a standard paragraph that just happens to start with a circle.

• Symptom: When you press "Enter" at the end of a line, a new bullet does not appear.
• Why it matters: You cannot reorder these lines easily, and indentation adjustments move the whole block, not just the text.

The Double Bullet

This occurs when Copilot sends the HTML list tag, but also includes a hard-coded bullet character inside the list item text.

• Symptom: You see • • Text goes here.
• Why it matters: It looks sloppy and unprofessional. Deleting one often deletes both because of how Outlook groups list markers.

The Indentation Drift

The most common issue in Copilot Outlook integrations. The AI adds inline CSS for margin-left or padding-left.

• Symptom: The bullets are aligned differently than the rest of your email, or nested bullets drift so far right they look like a separate conversation.

Solution 1: The "Keep Text Only" Nuclear Option

The fastest native way to fix this is to strip everything down to the studs.

1. Copy the Copilot text.
2. Right-click in the email body.
3. Select the clipboard icon with the letter 'A' (Keep Text Only).

The Downside: This is a destructive fix. You lose all bolding, italics, and hyperlinks that Copilot generated. If the AI bolded specific action items or dates—which is one of the main benefits of using AI for summaries—you have to manually read through and re-bold them. This defeats the productivity gain.

Solution 2: The PasteClean Method

This is where a specialized intermediary tool becomes necessary. You need a way to strip the "bad" HTML (proprietary background colors, font spans, and weird margin definitions) while keeping the "good" HTML (semantic list tags, bold tags, and anchor links).

This is exactly what PasteClean is designed for.

1. Copy the formatted text from Copilot.
2. Paste it into the PasteClean interface.
3. The tool parses the HTML strings. It identifies <ul> and <ol> tags and strips the inline CSS styles that confuse Outlook.
4. It ensures that <strong> tags remain intact.
5. Copy the cleaned text and paste it into Outlook.

By normalizing the HTML before Outlook’s engine touches it, you force Outlook to apply your default email styles (font, size, color) to the structure, rather than trying to interpret the AI’s styles.

Deep Dive: The HTML Horror Show

For those who want to know what's happening under the hood, let’s look at the code.

When Copilot generates a list, the raw HTML often looks like this:

<div style="color: #242424; font-family: 'Segoe UI';">
  <span>- First item</span><br>
  <span>- Second item</span>
</div>

Notice there is no <ul> (unordered list) tag. It’s just divs and spans simulating a list. Outlook interprets this strictly as text.

Ideally, you want this:

<ul>
  <li><strong>First item</strong></li>
  <li>Second item</li>
</ul>

However, even when Copilot does output a list tag, it often attaches specific class attributes:

<ul style="margin-top:0; margin-bottom:0;">
  <li style="margin-left: 36pt;">Item</li>
</ul>

Outlook hates margin-left on list items. Outlook controls list indentation via mso-list definitions in the header of the email HTML. When it sees inline margins, it attempts to convert them to tab stops, often resulting in bullets that are 2 inches away from the margin.

Solution 3: The "Format Painter" Shuffle

If you are stuck on a corporate machine without access to cleaning tools, you can use the Format Painter, but you have to do it in a specific order to avoid the "mso-style" bug.

1. Paste the AI text into your email.
2. Type a new, manual bullet point above the AI text using your email client's toolbar.
3. Type a few words (e.g., "test").
4. Highlight your "test" bullet.
5. Double-click the Format Painter (paintbrush icon).
6. Click on each line of the AI-generated list.

Why this fails sometimes: If the AI text has hard-coded line breaks (<br>) instead of paragraph breaks (<p>), the Format Painter will apply the bullet style to the entire block of text as one giant bullet point. You must ensure there are actual paragraph breaks between items first.

Outlook Web (OWA) vs. Outlook Desktop

The severity of ai email formatting issues depends heavily on your environment.

Outlook Web (OWA): OWA renders HTML much like a standard browser. If you paste Copilot text here, it usually retains the list structure reasonably well because both the AI and the client speak standard HTML/CSS. The main issue here is usually font mismatching (e.g., the list is in Roboto while your email is in Arial).

Outlook Desktop (Classic & New): This is the danger zone. The "New Outlook" is essentially a web wrapper and behaves like OWA, but "Classic Outlook" (which most enterprises still use) relies on the Word engine. This is where the translation from Markdown to VML causes the most breakage.

Prompt Engineering to Prevent Formatting Bugs

Sometimes the best fix is prevention. You can instruct Copilot to output format-agnostic text.

Instead of asking: "Summarize this email thread."

Try asking: "Summarize this email thread. Use a plain text list format with no markdown styling. Do not use code blocks."

Or, if you want to force a structure that Outlook handles well: "Draft a response listing these points. Use standard HTML unordered list tags."

While LLMs don't always obey structural constraints perfectly, explicitly asking for "plain text" reduces the amount of inline CSS garbage the model injects into the response.

Concrete Example: Before and After

Let’s look at a real-world scenario of a project update summary.

The Copilot Output (The Problem): Copilot generates a summary. You paste it.

• The font is Segoe UI, 10pt (your email is Calibri, 11pt).
• The bullets are hollow circles instead of solid dots.
• The text is indented 0.5 inches further right than your signature.
• When you try to backspace the indentation, the bullet disappears entirely.

The Cleaned Output (The Goal):

• The list adopts your default email font (Calibri/Aptos).
• Bullets align perfectly with the left margin of your previous paragraphs.
• Key metrics (e.g., $50k revenue) remain bolded.
• The list is semantic—meaning screen readers can identify it as a list, which is crucial for accessibility.

Why "Paste into Word First" is a Myth

You will often hear advice to paste the text into Microsoft Word, fix it there, and then copy it to Outlook.

Do not do this.

Since Outlook uses the Word rendering engine, pasting into Word first simply cements the "bad" formatting into a "Word-compatible" format that is still broken. You aren't cleaning the code; you are just moving the mess from one room to another. Word will try to preserve the AI's background colors and font spans just as aggressively as Outlook does.

You need to strip the styling before it hits the Microsoft Office ecosystem, not within it.

The Checklist for AI-Generated Emails

Before you hit send on that Copilot-assisted email, run through this 10-second format check:

1. Select All (Ctrl+A): Look for font discrepancies. If the list text flickers in the font selector box, you have mixed fonts.
2. The Ruler Test: Click inside the list. Look at the ruler at the top of the message window. If the hourglass markers jump wildly compared to the paragraph above, your indentation is broken.
3. The Enter Test: Go to the end of a list item and hit Enter. If a new bullet doesn't appear automatically, you don't have a list—you have text with symbols.
4. Dark Mode Check: Switch Outlook to Dark Mode for a second. If your AI text has a white background block behind it, it means the AI pasted a background-color: white style. This looks terrible for recipients using Dark Mode.

Conclusion

AI is incredible at synthesizing information, but it is terrible at understanding the legacy architecture of email clients. Copilot generates text for the web; Outlook renders text for a word processor.

Don't let bad formatting undermine the professionalism of your message. If a client sees a broken list with mismatched fonts, they subconsciously register the email as hasty or copy-pasted. Whether you use a dedicated tool like PasteClean or master the "Keep Text Only" workflow, taking control of your HTML is the only way to ensure your AI-generated emails actually look like you wrote them.