# What Is the Purpose of the Pattern Taxonomy in Humanizer?

> Discover the purpose of Humanizer's pattern taxonomy. This core architecture identifies 35 AI writing tell-tales for precise correction, maintaining integrity and voice.

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

---

**Humanizer's pattern taxonomy serves as the architectural backbone that enumerates 35 distinct AI-writing tell-tales to detect, classify, and systematically correct AI-style prose while preserving factual integrity and the writer's original voice.**

The open-source repository `blader/humanizer` implements this taxonomy as a centralized rule system that drives every stage of the text humanization process. Sourced from Wikipedia’s *Signs of AI writing* and maintained by WikiProject AI Cleanup, the taxonomy provides the concrete "before → after" transformations that distinguish AI-generated content from human writing.

## Core Functions of the Pattern Taxonomy

The pattern taxonomy in Humanizer operates through four integrated mechanisms that ensure reliable text transformation across all supported agents, including Claude, OpenCode, and Claude Desktop.

### Detection of AI-Generated Constructs

When a user submits text, Humanizer scans the input against all 35 patterns to flag potential AI-generated constructs. Each pattern targets specific stylistic fingerprints, such as **inflated claims about importance**, **name-dropping to prove credibility**, and **overused AI vocabulary**. The detection phase identifies sections requiring rewriting without altering the underlying facts.

### Guided Rewriting Rules

The taxonomy supplies explicit transformation rules that dictate how flagged content should be rewritten. According to the rewrite process documented in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), these rules convert AI-style phrasing into natural prose while strictly preserving every factual claim, proper name, date, and citation. For example, a pattern matching "marking a pivotal moment" transforms to factual statements like "was established in 1989," removing hyperbolic language while retaining the core information.

### Consistency and Extensibility

Because the 35 patterns are centrally listed in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), Humanizer maintains consistent behavior across different deployment environments. The architecture supports extensibility—new patterns can be added by appending entries to the taxonomy. The validator script [`scripts/validate-package.py`](https://github.com/blader/humanizer/blob/main/scripts/validate-package.py) enforces this consistency by checking that the pattern count in the README, skill metadata, and plugin manifest remain synchronized, preventing drift between documentation and implementation.

### Safety Nets and Factual Integrity

The taxonomy encodes critical safeguards that prevent hallucination during rewriting. Rules explicitly prohibit inventing facts, altering the writer's voice, or removing supported defenses. As specified in the "Human details to keep" section of [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), the system must retain all verified citations and factual claims, removing only unsupported defensive language or stylistic AI artifacts.

## Implementation in the Codebase

The pattern taxonomy manifests across five key files that collectively enforce the humanization logic:

- **[`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)** – Contains the complete pattern taxonomy, rewrite rules, and processing flow definitions.
- **[`README.md`](https://github.com/blader/humanizer/blob/main/README.md)** – Documents the 35 patterns with example transformations in a reference table.
- **[`scripts/validate-package.py`](https://github.com/blader/humanizer/blob/main/scripts/validate-package.py)** – Validates that pattern counts and version metadata stay synchronized across the repository.
- **[`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md)** – Describes skill packaging for different AI agents, linking to the central taxonomy.
- **[`.claude-plugin/plugin.json`](https://github.com/blader/humanizer/blob/main/.claude-plugin/plugin.json)** – Registers the skill with Claude-based agents, pointing to the same authoritative pattern list.

## Practical Usage Examples

You can interact with the pattern taxonomy through Humanizer's CLI interface or by invoking the skill directly within supported environments.

### Basic Humanization Request

To process text using the full taxonomy automatically, invoke Humanizer with your content:

```text
/humanizer

[paste AI-generated paragraph here]

```

### Listing Active Patterns

To inspect which of the 35 patterns will be checked during processing, request the taxonomy list:

```text
Please list the Humanizer patterns.

```

This returns the enumerated patterns, including transformations such as:

- **1. Inflated claims about importance and legacy** – Converts "marking a pivotal moment" to "was established in 1989"
- **2. Name-dropping to prove importance** – Changes "cited in NYT, BBC…" to "cited in NYT and the BBC"

### Programmatic Pattern Detection

For CI/CD workflows, you can install Humanizer globally and inspect which patterns trigger on specific inputs:

```bash
npx skills add blader/humanizer --global
humanizer --patterns < input.txt

```

The `--patterns` flag outputs which of the 35 taxonomy rules were matched, allowing downstream tools to act on the specific AI-writing tell-tales identified in the text.

## Summary

- The pattern taxonomy in Humanizer enumerates **35 distinct AI-writing tell-tales** derived from Wikipedia's AI writing research.
- **[`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)** serves as the single source of truth, while **[`scripts/validate-package.py`](https://github.com/blader/humanizer/blob/main/scripts/validate-package.py)** ensures metadata synchronization.
- The system **detects** AI constructs, applies **guided rewriting** rules, and maintains **safety nets** to prevent factual hallucination.
- The centralized architecture enables **consistent behavior** across Claude, OpenCode, and other agents while supporting **extensibility** for new patterns.

## Frequently Asked Questions

### Where does Humanizer source its pattern taxonomy from?

Humanizer's 35 patterns are sourced from Wikipedia's article *Signs of AI writing* and maintained by WikiProject AI Cleanup. This academic foundation ensures the taxonomy targets empirically verified AI-writing characteristics rather than heuristic guesses.

### How does the pattern taxonomy ensure factual accuracy during rewriting?

The taxonomy encodes explicit safety rules in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) that prohibit inventing facts, altering dates, or removing supported citations. Each pattern transformation only modifies stylistic elements—such as removing inflated claims—while preserving all verified factual content, names, and dates marked as "human details to keep."

### Can developers extend the pattern taxonomy with custom rules?

Yes. Because the patterns are centrally defined in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), developers can extend the taxonomy by appending new pattern entries to the list. The validator script [`scripts/validate-package.py`](https://github.com/blader/humanizer/blob/main/scripts/validate-package.py) automatically checks that the pattern count remains synchronized across [`README.md`](https://github.com/blader/humanizer/blob/main/README.md) and plugin manifests, ensuring consistency after modifications.

### How can I verify which patterns were triggered by my text?

When using Humanizer programmatically, you can run `humanizer --patterns < input.txt` to output which of the 35 taxonomy rules matched your content. This metadata allows you to audit exactly which AI-writing tell-tales were identified and corrected during the humanization process.