# How Humanizer Identifies Content Patterns in AI Writing: The 35-Pattern Detection System

> Discover how Humanizer identifies AI writing patterns using its 35-pattern detection system. Learn about keyword matching and structural cues for efficient AI content analysis.

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

---

**Humanizer identifies content patterns in AI writing through a static catalog of 35 lexical patterns defined in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), using keyword matching and structural cues rather than machine learning models.**

The `blader/humanizer` repository provides a pure-Markdown skill that guides LLM agents to spot and neutralize AI-style writing. When you invoke the `/humanizer` command, the agent executes a deterministic pipeline to identify content patterns in AI writing by cross-referencing input text against a curated vocabulary of robotic tells and structural markers.

## The Pattern Detection Pipeline

According to the source code in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), Humanizer processes text through five distinct stages. Each stage is encoded as natural-language instructions that the LLM interprets as executable rules.

### Loading the Pattern Catalog from SKILL.md

The detection process begins by loading the **35 pattern definitions** stored in the repository’s [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) file. These definitions reside in the "Content patterns" and "Language and grammar patterns" sections. Unlike neural classifiers, Humanizer uses a static rule set that maps specific lexical triggers to pattern IDs, allowing the agent to reference exact phrases associated with AI-generated prose.

### Scanning for Words-to-Watch and Structural Cues

Each pattern includes a **"words-to-watch"** list—specific strings or regular-expression fragments that signal automated writing. For example, pattern 4 ("Sales language") watches for terms like *boasts*, *vibrant*, and *groundbreaking*. The agent treats these as keywords to locate potential matches within the input text, effectively performing a lexical scan for known AI stylistic fingerprints.

### Marking Pattern Occurrences with Context

In the "Find AI patterns" step outlined in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), the agent records every match with three data points: the **pattern number**, the **offending phrase**, and the **surrounding context**. This creates a hit list of segments requiring revision while preserving the original semantic content. The agent marks these occurrences without altering the text, creating a structured map of violations for the subsequent rewrite phase.

### Rewriting Flagged Segments

After identification, the agent enters the "Rewrite process" phase documented in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md). It reconstructs the flagged segments while preserving factual claims, effectively stripping the identified patterns from the text. This step targets the specific linguistic artifacts found during the scanning phase, ensuring the output retains the original meaning minus the AI stylistic markers.

### Self-Check Validation and Iteration

The pipeline concludes with a validation loop. The agent asks two sanity-check questions to ensure no new AI-style artifacts were introduced during rewriting and that no factual information was lost. This iterative refinement continues until the text passes the self-check, creating a feedback mechanism that improves output quality without human intervention.

## Pattern Detection in Action

When you submit text to Humanizer, the detection logic follows a keyword-driven matching process. Consider this interaction:

```text
/humanizer

The new platform boasts a vibrant, groundbreaking experience that showcases our pivotal role in the industry.

```

The agent detects **pattern 4** ("Sales language") because the input contains *boasts*, *vibrant*, *groundbreaking*, and *pivotal*—all listed in the "Words to watch" section for that pattern in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md). The resulting rewrite removes the inflated claims while retaining the core message about the platform's industry role.

### Pattern Matching Logic

The detection algorithm operates similarly to this Python illustration:

```python

# Simplified illustration of Humanizer’s pattern detection

PATTERNS = {
    1: {"watch": ["stands as", "serves as", "key role"], "desc": "inflated claims"},
    4: {"watch": ["boasts", "vibrant", "groundbreaking"], "desc": "sales language"},
    # … patterns 2‑35 omitted for brevity …

}

def find_patterns(text):
    hits = []
    for num, data in PATTERNS.items():
        for word in data["watch"]:
            if word.lower() in text.lower():
                hits.append((num, word))
    return hits

```

Running `find_patterns` on the sample text returns `[(4, "boasts")]`, triggering the rewrite step for pattern 4. This demonstrates how Humanizer identifies content patterns in AI writing through explicit string matching rather than probabilistic inference.

## Key Files in the Repository

Understanding the detection system requires familiarity with three core files in the `blader/humanizer` repository:

- **[`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)** – The source of truth containing all 35 pattern definitions, detection instructions, and the rewrite workflow. This file houses the "words-to-watch" lists and the five-step process described above.

- **[`README.md`](https://github.com/blader/humanizer/blob/main/README.md)** – Provides a high-level overview of the detection methodology and lists all patterns in tabular form for quick reference.

- **[`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md)** – Documents how the skill is packaged for different LLM agents (Claude, OpenCode, etc.), explaining the integration points for the detection pipeline.

## Summary

- Humanizer identifies content patterns in AI writing through a **static catalog of 35 patterns** defined in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), not through machine learning.
- The detection pipeline follows five steps: loading the catalog, scanning for keywords, marking occurrences, rewriting flagged text, and validating with a self-check.
- Pattern matching relies on **"words-to-watch"** lists—specific lexical triggers that indicate AI-generated phrasing.
- The system is **keyword-driven** and deterministic, using natural-language instructions in Markdown to guide the LLM agent's analysis.

## Frequently Asked Questions

### How does Humanizer differ from AI content detectors like GPTZero?

Traditional detectors use statistical models or neural networks to classify text. Humanizer, by contrast, uses a **rule-based system** with explicit pattern definitions. It identifies content patterns in AI writing by matching against a curated list of 35 specific linguistic tells rather than calculating perplexity or burstiness.

### Can I add custom patterns to Humanizer's detection system?

Yes. Because the patterns live in the [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) file as Markdown front-matter and structured lists, you can extend the detection catalog by editing this file. Each new pattern requires a unique ID, a description, and a "words-to-watch" list that the agent will use during the scanning phase.

### What types of patterns does Humanizer detect?

The 35 patterns cover categories like **inflated claims**, **sales language**, **nominalizations**, **hedging phrases**, and **excessive adjectives**. Each pattern targets specific structural or lexical habits common in LLM-generated text, such as overuse of "-ing" phrases or stilted transitional phrases.

### Is the detection process deterministic?

Yes. Because Humanizer relies on **static keyword matching** and explicit rules in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), it produces consistent results for identical inputs. The detection pipeline does not involve random sampling or probabilistic thresholds—it either finds the words-to-watch or it does not.