Email Spam Checker Detects AI Text: Hidden Unicode Character Method

Our email spam checking tools are equipped with an advanced invisible character detection feature, available in both our Spam Words Checker and Email Builder, providing users with a reliable method to identify copy-pasted AI content.

The Problem Nobody Talks About

Let me start with a confession: we've been trying to solve the wrong problem.

For months, our team wrestled with building an "AI detector" for our email spam checking tool. We tested every approach you can think of. Statistical analysis, machine learning models, we even considered using AI to detect AI (yes, the irony wasn't lost on us). The results? Consistently disappointing. The best commercial detectors claim 80-99% accuracy, but dig deeper and you'll find they're wrong one out of every five times. Worse, they discriminate against non-native English speakers with error rates up to 70%.

Then we discovered something fascinating: AI text generators leave behind invisible breadcrumbs. Not intentionally, mind you. It's what OpenAI calls "a quirk of large-scale reinforcement learning." These breadcrumbs are Unicode characters that are literally impossible to type on any keyboard.

And that changed everything.

Why We Gave Up on Traditional AI Detection

Here's the uncomfortable truth about AI detection that vendors won't tell you: it's a losing game.

Think about it. Every new AI model writes differently. GPT-4 doesn't write like GPT-3.5. Claude doesn't write like ChatGPT. By the time you train a detector on today's AI, tomorrow's model is already here, writing in ways your detector has never seen.

But it gets worse. Modern AI can write genuinely good content. That's the whole point! The better AI gets, the more human-like it becomes. Trying to detect "AI-ness" in text is like trying to detect whether a perfect forgery is fake. If it's perfect, how can you tell?

We also realized something else: email content is incredibly diverse. A cold sales email looks nothing like a newsletter, which looks nothing like a transactional receipt. What patterns could possibly identify AI across all these formats?

So we stopped trying to detect AI. Instead, we decided to detect something much simpler: characters that no human can physically type.

The Discovery: Unicode's Hidden World

Here's a quick experiment. Try typing this character on your keyboard: ​

Can't see it? That's because it's a Zero Width Space (U+200B). It's sitting right there between the colon and the word "Can't", completely invisible. You literally cannot type it on any standard keyboard. Not on Windows, not on Mac, not on your phone.

These invisible characters are everywhere in AI-generated text. When you copy-paste from ChatGPT, Claude, or Gemini, you're bringing along stowaways:

• Zero Width Space (ZWSP) - U+200B
• Narrow No-Break Space (NNBSP) - U+202F
• Em Dash - U+2014 (yes, that long dash that's not on your keyboard)
• Em Space - U+2003
• Zero Width Joiner - U+200D

And about 25 others.

These aren't bugs. They're legitimate Unicode characters used for text formatting in various languages and contexts. AI models learned to use them from their training data, which included millions of documents that contained these characters. The models don't "know" they're adding invisible characters; they're just reproducing patterns they've learned.

The Critical Distinction: What We Can and Can't Prove

Let me be crystal clear about what this detection actually tells you:

What we CAN prove: If we find these invisible characters, they were NOT typed by a human on a keyboard. Period. Near 100% certainty.

What we CAN'T prove: That text without these characters is human-written.

This is a one-way street. Finding these characters is like finding fingerprints at a crime scene. They prove someone was there. Not finding them proves nothing.

And you know what? That's perfectly fine. Because unlike traditional AI detectors that give you a "73.6% chance this is AI" (what does that even mean?), we give you something concrete: "This text contains 5 characters that cannot be typed on a keyboard."

Why This Works So Well for Email

Emails are perfect for this approach. Think about how emails are actually written:

1. Most people type them directly in their email client
2. Some compose in Google Docs or Word, then copy over
3. Others use templates or signatures
4. And increasingly, some use AI to draft or polish their messages

The first group will never have invisible characters. The second might have a few from smart quotes or em dashes. But the fourth group? They're bringing a whole parade of invisible Unicode characters along for the ride.

The beauty is in the simplicity. We're not analyzing writing style (which varies). We're not checking grammar patterns (which depend on education and native language). We're not running complex algorithms (which become obsolete). We're just asking: "Are there characters here that no human could have typed?"

The Elephant in the Room: Yes, This Can Be Bypassed

I'll save you the gotcha moment: anyone can remove these characters with a simple find-and-replace.

There. I said it.

And you know what? We don't care. We're not building a security system. We're not trying to catch cheaters. We're not in the business of playing cat-and-mouse games with people trying to hide their AI use.

We're building a simple tool that answers a simple question. If someone wants to clean their AI-generated text of invisible characters, more power to them. They're making their content better by removing unnecessary formatting artifacts.

Our users aren't looking to prosecute anyone. They want to know things like:

• "Did my assistant just copy-paste this from ChatGPT?"
• "Is this guest post original content?"
• "Are my email templates clean and professional?"

For these questions, our simple check works beautifully.

Real-World Implementation: How We Built It

The technical implementation is embarrassingly simple, and that's a feature, not a bug.

// That's literally it. Check if text contains these characters.
const invisibleChars = [
  '\u200B', // Zero Width Space
  '\u202F', // Narrow No-Break Space
  '\u2014', // Em Dash
  // ... and so on
];

const hasInvisibleChars = invisibleChars.some(char => text.includes(char));

No machine learning models. No training data. No cloud API calls. No privacy concerns. Just a simple character check that runs in microseconds.

Compare that to AI detectors that need to:

• Send your text to their servers
• Run it through massive neural networks
• Compare against training datasets
• Return a probability score
• Hope their model isn't outdated

Which approach would you rather use?

How We Communicate This to Users

The key to making this feature valuable is honest communication. Here's how we present it:

Invisible Characters Detected

Found 7 characters that cannot be typed on a standard keyboard, including Zero Width Spaces and Em Dashes. These typically appear when text is copy-pasted from AI tools or certain word processors.

What this means: This text was not manually typed character-by-character.

What this doesn't mean: We cannot determine if the content was AI-generated or just formatted elsewhere.

No percentages. No confidence scores. No accusations. Just facts.

The Surprising User Reactions

When we launched this feature, we expected pushback. "That's it? You just check for invisible characters?"

Instead, users loved it. Here's why:

It's transparent. Users can understand exactly what we're checking and why. No black box algorithms.

It's instant. No waiting for API calls or model processing.

It's actionable. Found invisible characters? Here's a button to remove them.

It's honest. We don't oversell what it does.

One user told us: "Finally, a detection tool that doesn't pretend to be magic. It does one thing, explains it clearly, and does it well."

The Philosophy: Building Honest Tools

The tech industry has a bad habit of overpromising. "Our AI detector uses advanced machine learning to identify AI-generated content with 99.6% accuracy!" Sure it does.

We chose a different path. We built a tool that:

1. Makes limited claims (We detect invisible characters, nothing more)
2. Explains its limitations (We're upfront about what this doesn't prove)
3. Provides clear value (Even with limitations, it's genuinely useful)
4. Respects users (No false accusations or inflated confidence scores)
5. Stays simple (Complexity is not a feature)

This approach might seem underwhelming in a world of AI hype. But our users don't want hype. They want tools that work.

Looking Forward: The Future of AI Transparency

Will AI models stop adding invisible characters? Probably, eventually. OpenAI or Anthropic could remove them in their next update.

When that happens, our detection will stop working. And that's okay.

We're not building our business on this one feature. We're not selling it as the ultimate solution. It's just one useful signal among many, valuable while it lasts.

The broader lesson is this: instead of engaging in an arms race between AI generation and detection, we should focus on transparency and education. Help people understand how AI works. Give them tools to make informed decisions. Be honest about capabilities and limitations.

The Truth About AI Detection

We built a tool that detects invisible Unicode characters in text. These characters can't be typed on keyboards, so their presence indicates copy-pasting or generation. That's it.

We don't claim to detect all AI content. We don't pretend absence of these characters proves human authorship. We just provide one simple, reliable, understandable check.

In a world of overengineered solutions and exaggerated claims, sometimes the most valuable tool is the one that does something simple and does it well.

Is it perfect? No.
Can it be bypassed? Yes.
Is it still useful? Absolutely.

Because at the end of the day, we're not trying to win a war against AI. We're just trying to help people understand their content better. And for that, a simple check for invisible characters works surprisingly well.

You can experience this feature yourself in our Spam Words Checker for analyzing existing text, or use it while creating emails in our Email Builder for real-time feedback during the design process.

Actually, you know what's funny? As I write this, I realize I'm doing exactly what we tell our users not to worry about. I'm trying to make my writing "sound human" to avoid detection. But here's the thing: good writing is good writing, whether it comes from a human or an AI or a collaboration between the two. The invisible characters? They're just a technical artifact, a tiny detail that happens to be useful for now.

What matters more is being honest about our tools, our limitations, and our intentions. That's what builds trust. Not perfect detection, but perfect transparency.

Want to try it yourself? Copy this article into a Unicode detector. You'll find it's clean, every character typed by human hands on a regular keyboard. Well, except for those example characters I showed you earlier. Those I had to copy from a Unicode table. Even I can't type them.