# How Humanizer Prevents Pattern Detection False Positives: A Technical Deep Dive

> Humanizer prevents pattern detection false positives using layered defenses like multi-tell requirements, weak-alone flagging, and contextual exclusions. Learn more about its safeguards.

- Repository: [Siqi Chen/humanizer](https://github.com/blader/humanizer)
- Tags: deep-dive
- Published: 2026-09-13

---

**Humanizer prevents pattern detection false positives through a layered defense system including multi-tell requirements, weak-alone flagging, contextual exclusions, voice-preserving overrides, and pattern hierarchies defined in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md).**

The `blader/humanizer` repository implements a sophisticated AI-humanizing engine designed to rewrite AI-generated text into natural prose. Without proper constraints, this process risks creating false positives by flagging legitimate stylistic choices—such as em-dashes or bold headings—as artificial patterns. To prevent this, the tool employs specific safeguards detailed in its [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) configuration file and detection logic.

## Multi-Tell Requirements and Weak-Alone Detection

Humanizer's primary defense against over-correction relies on **multi-tell verification** and **weak-alone flagging** mechanisms defined in the skill documentation.

### The "Several Tells Together" Rule

According to the [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) section **"When not to act"**, the engine requires multiple concurrent signals before triggering a rewrite. A single weak pattern—such as an isolated dash or bold label—remains ignored unless it appears alongside other tell-signals within the same passage. This **"several tells together"** rule ensures that isolated coincidences do not trigger unnecessary edits.

### Weak-Alone Pattern Classification

Patterns deemed **"weak alone"** (including repeated dashes or decorative headings) carry explicit flags in the skill file under the **"Weak alone"** notes section. The engine treats these as low-confidence signals and mandates additional supporting patterns before initiating any transformation. This classification prevents the system from overreacting to common stylistic flourishes that appear in both human and AI writing.

## Context-Aware Safeguards

Beyond pattern counting, Humanizer implements **contextual exclusions** that skip detection entirely in protected contexts.

### Protected Context Blocks

As specified in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) under **"When not to act"**, the system automatically bypasses detection inside:

- Quoted text passages
- Code blocks
- Headings that serve as titles
- Passages discussing the target phrase rather than using it directly

These exclusions prevent the model from flagging legitimate formatting or metalinguistic terminology.

## Voice Preservation and Pattern Hierarchy

Humanizer balances sensitivity with specificity through adaptive voice matching and a tiered confidence system.

### Writing Sample Adaptation

When users provide a **writing sample**, the engine adopts that sample's specific style characteristics, including dash frequency, bolding habits, and other stylistic quirks. As documented in the [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) **"Voice"** section, this adaptive behavior prevents the skill from mistakenly labeling intentional authorial choices as AI-generated patterns. The system learns the user's baseline and adjusts its detection thresholds accordingly.

### Pattern Strength Tiers

The skill implements a **pattern hierarchy** that orders detection rules by inherent strength. Patterns categorized in sections **§1–§5** qualify as strong signals capable of triggering rewrites on single sightings. Conversely, patterns in sections **§6–§20** register as weaker signals that require corroboration from stronger patterns before activation. This hierarchy, detailed under **"Two rules follow from this"** in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), functions as a built-in confidence filter that reduces false-positive rates.

## Implementation Example

The following Python implementation demonstrates how to invoke Humanizer while respecting its safeguard mechanisms, including voice preservation through sample submission:

```python
import json
import requests

# Humanizer is delivered as a markdown skill; the consumer sends the text

def humanize(text: str, sample: str | None = None) -> str:
    payload = {"text": text}
    if sample:
        payload["sample"] = sample          # preserves author's voice

    resp = requests.post(
        "https://api.openai.com/v1/engines/humanizer/completions",
        json=payload,
        headers={"Authorization": f"Bearer YOUR_API_KEY"},
    )
    result = resp.json()
    return result["choices"][0]["message"]["content"]

# Example 1 – plain text (multiple tells trigger rewriting)

original = """
It's not just about the beat riding under the vocals; it's part of the aggression and atmosphere.
No aesthetic prior. No nostalgia.
"""

print(humanize(original))

# Example 2 – providing a sample that uses dashes heavily

sample = "The project — a daring experiment — succeeded."
print(humanize(original, sample=sample))

```

In the first call, only the **"not-X-but-Y"** contrast triggers rewriting because it meets the strong-pattern threshold. The second call respects the sample's dash usage, demonstrating how **voice-preserving overrides** prevent false-positive dash removal.

## Summary

Humanizer prevents pattern detection false positives through five coordinated mechanisms:

- **Multi-tell requirements** mandating pattern corroboration before action
- **Weak-alone flagging** that labels low-confidence signals in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)
- **Contextual exclusions** protecting quotes, code blocks, and headings from detection
- **Voice-preserving overrides** that adapt to user-provided writing samples
- **Pattern hierarchy tiers** (§1–§5 strong vs. §6–§20 weak) that filter detection confidence

These safeguards work collectively within the [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) architecture to balance detection sensitivity with correction specificity.

## Frequently Asked Questions

### What triggers a false positive in Humanizer?

A false positive typically occurs when the engine identifies a **weak-alone pattern**—such as a decorative dash or bold heading—in isolation without supporting context. Without the multi-tell requirement and pattern hierarchy safeguards, the system might incorrectly flag legitimate stylistic choices as AI-generated artifacts.

### How does the pattern hierarchy prevent over-correction?

The pattern hierarchy restricts **single-sight triggers** to strong patterns (§1–§5), while requiring weaker patterns (§6–§20) to appear alongside stronger signals. This tiered system ensures that low-confidence detections cannot independently initiate rewrites, significantly reducing false-positive rates.

### Can I customize which patterns Humanizer detects?

While the core pattern definitions reside in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), you can influence detection behavior by submitting a **writing sample** when calling the API. This sample establishes a baseline for acceptable stylistic variations—including dash frequency and formatting choices—effectively customizing the false-positive threshold for your specific voice.

### Where are the safeguard rules formally documented?

The primary safeguard definitions appear in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) within the `blader/humanizer` repository, specifically under the **"When not to act"**, **"Weak alone"**, **"Voice"**, and **"Two rules follow from this"** sections. These sections collectively define the multi-tell requirements, contextual exclusions, and pattern strength classifications.