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

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 file.

The open-source Humanizer project by blader 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) 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. 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. Below are Python implementations matching Humanizer's detection logic:

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

The 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, 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 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 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) 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 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 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}