# How Humanizer Handles Pasted Text Input: The Complete Processing Pipeline

> Discover how Humanizer processes pasted text input through a four-stage markdown pipeline. It detects AI writing, rewrites content while preserving voice, critiques output, and delivers a polished final text.

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

---

**Humanizer treats pasted text as its default input mode, executing a four-stage markdown-driven pipeline that flags AI-writing "tells," drafts a voice-preserving rewrite, critiques the output, and returns three components: an initial draft, a list of remaining patterns, and a polished final text.**

The **blader/humanizer** repository implements a zero-code markdown skill that transforms synthetic-sounding prose into natural human writing. Unlike traditional CLI tools that require file paths, Humanizer’s primary interface accepts **pasted text input** directly, making it compatible with any AI agent capable of loading markdown instructions, including Claude and OpenAI models. This design choice eliminates file system dependencies while standardizing the humanization workflow across different platforms.

## The Four-Stage Processing Pipeline

The core logic resides in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), which defines a rigid processing contract executed sequentially whenever text is pasted into the skill. The pipeline operates through four distinct stages documented in the **"How to work"** section of the skill definition.

### Stage 1: Mark the Tells

The skill first scans the entire input passage to identify AI-writing "tells"—linguistic fingerprints typical of synthetic text. According to the [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) implementation, these patterns include **not-X-but-Y contrasts**, **forced triads**, **dash overuse**, and other stylistic markers that signal machine generation. This diagnostic phase creates a map of specific locations and pattern types requiring remediation without altering the original text.

### Stage 2: Draft the Rewrite

Using the flagged locations from Stage 1, the skill produces an initial draft that preserves every factual claim while eliminating or rephrasing the identified tells. The draft strictly maintains the original voice and context; it **never invents new details** or hallucinates information not present in the source material. This stage balances aggressive de-AI-ing with factual fidelity.

### Stage 3: Check the Draft

The draft undergoes a virtual "read aloud" review where the skill generates a short critique highlighting any remaining AI-like phrasing. This quality assurance step simulates editorial oversight, catching residual patterns that survived the initial transformation. The critique focuses specifically on cadence, rhythm, and unnatural collocation—elements that statistical language models often mishandle.

### Stage 4: Write the Final Version

In the final stage, the skill applies the critique to produce the polished output. As defined in the **"Pasted text (default)"** section of [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), the system returns exactly three components to the user:

- The initial draft generated in Stage 2
- A concise list of any still-present patterns (cited by section number)
- The finalized human-sounding rewrite

Because the input consists of raw text rather than a file path, Humanizer writes no files to disk; all output is returned inline within the conversation context.

## Input Methods and Syntax Examples

Humanizer accepts pasted text through two primary invocation patterns, both documented in the repository's [`README.md`](https://github.com/blader/humanizer/blob/main/README.md).

### Direct Skill Invocation

Use the `/humanizer` command followed by a blank line and the text block:

```markdown
/humanizer

I think the new feature — which many developers love — will make the product better.

```

**Returned output:**

1. **Draft**
   > I think the new feature, which many developers love, will make the product better.

2. **Remaining patterns**
   - Dashes as the universal connector (§8)

3. **Final rewrite**
   > I think the new feature, loved by many developers, will improve the product.

### Plain-Language Request

Alternatively, invoke the skill using natural language instructions:

```markdown
Please humanize this text:

Our API is fast — really fast — and developers love it.

```

**Returned output:**

- **Draft:** "Our API is fast, really fast, and developers love it."
- **Remaining patterns:** "Dashes as the universal connector (§8)"
- **Final rewrite:** "Our API is very fast, and developers love it."

## Technical Architecture and Agent Compatibility

The entire pasted text workflow is driven entirely by the markdown skill file ([`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)) and requires **no external code or runtime**. This architecture means any compatible agent that can parse and execute markdown-based skill instructions will process pasted text through identical logic. Developers seeking to modify the behavior without breaking the contract should consult [`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md), which provides guidance for extending the skill while maintaining the four-stage pipeline integrity.

Because Humanizer handles **pasted text input** as its default mode, it bypasses file I/O operations entirely. This design prioritizes conversational workflows where users paste content directly into chat interfaces rather than managing local file paths.

## Summary

- Humanizer processes **pasted text input** through a four-stage pipeline defined in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md): Mark the tells, Draft the rewrite, Check the draft, and Write the final version.
- The system detects specific AI-writing patterns including dash overuse, forced triads, and not-X-but-Y contrasts during the initial scanning phase.
- Output always consists of three components: an initial draft, a diagnostic list of remaining patterns, and a polished final text.
- No files are written during processing; all interaction occurs through inline text exchange compatible with Claude, OpenAI, and similar agents.
- The skill requires zero external dependencies or runtime environments, functioning purely through markdown instruction parsing.

## Frequently Asked Questions

### What specific AI-writing patterns does Humanizer detect in pasted text?

According to the [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) specification, Humanizer scans for "tells" such as **dash overuse** (using em-dashes as universal connectors), **forced triads** (unnatural groupings of three), and **not-X-but-Y contrasts** (artificial rhetorical structures). Each identified pattern is flagged with a section reference (e.g., §8) that appears in the remaining patterns list of the final output.

### Can Humanizer process file-based inputs instead of pasted text?

While the **"Pasted text (default)"** mode handles raw text input, the repository architecture supports alternative workflows. However, the default configuration documented in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) is optimized for conversational pasted text and does not perform file system operations. Users requiring file-based processing would need to modify the skill instructions documented in [`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md) to implement path-based I/O.

### How does the "Check the draft" stage improve the final output quality?

The third stage performs a virtual read-aloud critique that evaluates cadence and rhythm—elements often missed by automated replacement rules. By generating a secondary editorial review before finalizing text, the skill catches residual AI-like phrasing that survived the initial drafting phase, ensuring the final rewrite achieves natural human prosody rather than just superficial word substitution.

### Which AI agents are compatible with Humanizer's pasted text processing?

Any agent capable of loading and executing markdown-based skills can run Humanizer's pasted text pipeline. The repository explicitly mentions compatibility with **Claude** and **OpenAI** models. Since the logic resides entirely in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) without external dependencies, the behavior remains consistent across different LLM platforms that support skill-based instruction following.