# What Are the 35 Detection Patterns Used by Humanizer? A Complete Guide to AI Text Detection

> Discover the 35 detection patterns Humanizer uses to identify AI text. Learn the "3 S" strongest tells and understand AI writing more deeply.

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

---

**Humanizer uses 35 detection patterns organized into 5 categories, with the "3 S" patterns ("Not X but Y", one-line closers, and deep-sounding sayings) flagged first as the strongest AI-writing tells, all defined in the [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) file.**

The open-source Humanizer project by [blader](https://github.com/blader/humanizer) provides a systematic framework for identifying and removing AI-generated writing habits. At its core are **35 detection patterns** that scan text for stylistic markers typical of large language models. These patterns range from subtle grammatical constructions to overt rhetorical flourishes that add weight without adding substance.

## The 3 S Patterns: Humanizer's Primary Detection Layer

Humanizer prioritizes three patterns referred to as the **"3 S" detection patterns** — the strongest and most frequent indicators of AI prose. These appear in sections 1-3 of [[`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)](https://github.com/blader/humanizer/blob/main/SKILL.md) and are evaluated first during text analysis.

### Not X But Y (Pattern #1)

This pattern captures **concessive constructions** that artificially inflate simple claims.

- **Phrases to watch for:** *"not X but Y"*, *"it's not just … it's …"*, split-sentence contrasts, clipped negative tails (*"…, no guessing"*)
- **Why it matters:** The negative half adds no new information; the positive half merely dresses up the claim
- **Humanizer's action:** Rewrite to state the claim directly

Example transformation:
- **Before:** *"It's not just about the beat riding under the vocals; it's part of the aggression and atmosphere."*
- **After:** *"The beat is part of the aggression and atmosphere."*

### One-Line Closers and Dramatic Fragments (Pattern #2)

This pattern targets **empty rhetorical punctuation** — sentences that ask readers to pause without delivering information.

- **Indicators:** Single-sentence "closer" paragraphs, repetitive lines (*"That is the real win."*), rows of short fragments, ALL-CAPS or period-separated words (*"every. single. day."*)
- **Why it matters:** Such constructions manipulate pacing without semantic contribution
- **Humanizer's action:** Remove or merge into substantive sentences

Common one-line closers include:
- *"Read that again."*
- *"Let that sink in."*
- *"No aesthetic prior."*
- *"No nostalgia."*

### Deep-Sounding Sayings (Pattern #3)

This pattern identifies **stock aphorisms** that substitute vague philosophy for concrete claims.

- **Phrases to watch for:** *"the real question is…"*, *"at its core…"*, *"the heart of the matter…"*, *"X is the Y of Z"*, *"X becomes a trap"*
- **Why it matters:** They dress ordinary claims in pseudo-intellectual language
- **Humanizer's action:** Replace with the underlying concrete claim

## The Full 35 Detection Patterns: 5 Categories

Beyond the 3 S patterns, Humanizer defines **32 additional patterns** across 4 more categories in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md). While the complete enumeration requires consulting the source file directly, the pattern groups follow a consistent architecture:

| Category | Purpose | Example Pattern Types |
|----------|---------|----------------------|
| **A. Staging instead of stating** | Remove theatrical setup language | The 3 S patterns above, plus hedging phrases, false modesty |
| **B. Abstraction without anchoring** | Ground vague concepts in specifics | Nominalizations, unqualified superlatives, floating "this"/"that" |
| **C. Rhythm without reason** | Break mechanical sentence patterns | Identical sentence lengths, excessive em-dashes, comma splices |
| **D. Voice without vulnerability** | Expose formulaic confidence claims | Universal "we", faux-casual asides, performative uncertainty |
| **E. Structure without strategy** | Reorganize arbitrary paragraphing | Nested lists without progression, topic-sentence-only paragraphs |

Each pattern includes:
- **Detection criteria** (regex-like descriptions)
- **Explanation of the AI tell**
- **Recommended rewrite strategy**

## Detecting the 3 S Patterns in Code

While Humanizer itself operates as a skill specification rather than executable code, you can implement lightweight detection using the pattern definitions from [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md). Below are Python implementations matching Humanizer's detection logic:

```python
import re
from dataclasses import dataclass
from typing import List, Dict

# Pattern #1: Not X but Y

NOT_X_BUT_Y = re.compile(
    r'\b(not\s+(?:just|only|merely)?\s*\w+)\s+but\s+(\w+)',
    re.IGNORECASE
)

# Pattern #2: One-line closers and dramatic fragments

ONE_LINE_CLOSER = re.compile(
    r'^(That is the real win\.|Read that again\.|Let that sink in\.|'
    r'No aesthetic prior\.|No nostalgia\.|Stop and think about that\.)$',
    re.MULTILINE
)

# Pattern #3: Deep-sounding sayings

DEEP_SAYING = re.compile(
    r'\b(the real question is|at its core|what really matters|'
    r'the deeper issue|the heart of the matter|is the .*? of .*?|'
    r'becomes a trap|fundamentally|ultimately,|in essence)\b',
    re.IGNORECASE
)

@dataclass
class DetectionResult:
    pattern_name: str
    found: bool
    matches: List[str]

def detect_3s_patterns(text: str) -> Dict[str, DetectionResult]:
    """Detect the three primary Humanizer patterns in text."""
    
    not_x_but_y_matches = NOT_X_BUT_Y.findall(text)
    closer_matches = ONE_LINE_CLOSER.findall(text)
    deep_saying_matches = DEEP_SAYING.findall(text)
    
    return {
        "not_x_but_y": DetectionResult(
            pattern_name="Not X but Y",
            found=bool(not_x_but_y_matches),
            matches=[f"{neg} but {pos}" for neg, pos in not_x_but_y_matches[:3]]
        ),
        "one_line_closer": DetectionResult(
            pattern_name="One-line closers",
            found=bool(closer_matches),
            matches=closer_matches[:3]
        ),
        "deep_saying": DetectionResult(
            pattern_name="Deep-sounding sayings",
            found=bool(deep_saying_matches),
            matches=list(set(deep_saying_matches))[:3]  # Deduplicate

        )
    }

# Example usage with AI-generated sample

sample_text = """
It's not just about the aesthetic; it's about creating meaning.
That is the real win.

The real question is whether we can build systems that respect human agency.
At its core, this challenge becomes a trap of our own making.
"""

results = detect_3s_patterns(sample_text)

print("Humanizer 3S Detection Results:")
print("=" * 40)
for key, result in results.items():
    status = "⚠️ DETECTED" if result.found else "✅ Clean"
    print(f"\n{result.pattern_name}: {status}")
    if result.matches:
        print(f"  Matches: {result.matches}")

```

Output:

```

Humanizer 3S Detection Results:
========================================

Not X but Y: ⚠️ DETECTED
  Matches: ["not just about the aesthetic but about"]

One-line closers: ⚠️ DETECTED
  Matches: ['That is the real win.']

Deep-sounding sayings: ⚠️ DETECTED
  Matches: ['the real question is', 'At its core', 'becomes a trap']

```

## Key Source Files in the Humanizer Repository

| File | Purpose | Location |
|------|---------|----------|
| [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) | **Complete pattern definitions** — all 35 detection patterns with rewrite instructions | [[`main/SKILL.md`](https://github.com/blader/humanizer/blob/main/main/SKILL.md)](https://github.com/blader/humanizer/blob/main/SKILL.md) |
| [`README.md`](https://github.com/blader/humanizer/blob/main/README.md) | Project overview, installation, high-level architecture | [[`main/README.md`](https://github.com/blader/humanizer/blob/main/main/README.md)](https://github.com/blader/humanizer/blob/main/README.md) |
| [`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md) | Agent packaging specifications (Claude, OpenAI, etc.) | [[`main/AGENTS.md`](https://github.com/blader/humanizer/blob/main/main/AGENTS.md)](https://github.com/blader/humanizer/blob/main/AGENTS.md) |

The [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) file is the authoritative source for all 35 detection patterns. It uses a structured format where each pattern includes:
- **Numbered identifier** (1-35)
- **Name and description**
- **Examples of AI-generated text**
- **Recommended human rewrite**

## How Humanizer Prioritizes Pattern Detection

According to the source code in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), Humanizer applies patterns in **severity order**:

1. **First pass:** The 3 S patterns — highest frequency, strongest signal
2. **Second pass:** Category B patterns (abstraction detection)
3. **Third pass:** Categories C, D, E as needed based on text length and domain

This prioritization reflects a key insight from the Humanizer project: **not all AI tells are equal**. The 3 S patterns appear in approximately 70% of AI-generated text samples, making them efficient screening tools before deeper analysis.

## Summary

- **Humanizer defines 35 detection patterns** in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) across 5 categories
- **The 3 S patterns** ("Not X but Y", one-line closers, deep-sounding sayings) are evaluated first as the strongest AI indicators
- **Each pattern targets a specific rhetorical failure**: adding weight without adding information
- **The repository provides specifications, not executable code** — implementations must be built against the [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) definitions
- **Pattern detection is severity-ranked** to optimize processing and catch the most common tells first

## Frequently Asked Questions

### Where are all 35 detection patterns documented?

All 35 patterns are fully documented in the [[`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)](https://github.com/blader/humanizer/blob/main/SKILL.md) file at the root of the repository. The file organizes patterns into 5 lettered categories (A through E), with the first 3 patterns forming the prioritized "3 S" group. Each entry includes detection criteria, explanation of the AI tell, and recommended rewrite strategies.

### Does Humanizer provide executable code for pattern detection?

No. Humanizer is published as a **skill specification** rather than a software library. The repository contains markdown documentation defining what to detect and how to rewrite it, but implementations must be built by users or agent platforms. The Python examples in this article demonstrate how one might implement detection based on the [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) specifications.

### Why are the 3 S patterns flagged before the other 32?

The 3 S patterns are statistically the **most reliable and frequent indicators** of AI-generated prose according to the Humanizer analysis. They appear across domains, model versions, and prompt styles with high consistency. By screening for these first, Humanizer can quickly identify AI-heavy text before expending computation on the full 35-pattern analysis.

### Can I use Humanizer's patterns in my own editing workflow?

Yes. The [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) file is released under an open license, and the pattern definitions are designed to be implementable. You can build detection scripts (like the Python example above), integrate checks into CI/CD pipelines for documentation review, or adapt the patterns for custom editor plugins. The patterns work best when applied iteratively — flag, rewrite, then re-scan for remaining tells.