# How Humanizer Detects and Rewrites Shallow -ing Analysis in AI Writing

> Discover how Humanizer detects and rewrites shallow -ing analysis in AI writing. Our three-step pipeline transforms ornamental phrases into concise factual statements, preserving meaning.

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

---

**Humanizer treats "shallow -ing analysis" as a core AI-writing-pattern detection, using a three-step rule-based pipeline to identify ornamental -ing phrases and rewrite them into concise factual statements while preserving the original meaning.**

AI-generated text frequently relies on vague gerund phrases that sound analytical but lack substance. The `blader/humanizer` repository eliminates this fluff through a deterministic system specifically designed to handle **shallow -ing analysis**. This open-source tool interprets static markdown rules to strip ornamental language without changing underlying facts.

## Pattern Definition in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)

The **shallow -ing analysis** detection logic is codified in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) under the heading `### 3. Shallow analysis with –ing phrases`. This section defines specific **Words to watch**, including *highlighting, underscoring, emphasizing, ensuring, reflecting, contributing, cultivating, encompassing, and showcasing*. When one of these gerunds follows a simple factual clause, the parser flags the sequence for rewriting.

## The Three-Step Rewrite Pipeline

Humanizer processes flagged text through a deterministic pipeline that ensures accuracy and clarity.

### Step 1: Pattern Matching

The engine scans input for the **Words to watch** listed in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md). If an -ing phrase follows a simple factual clause, the system marks it as a shallow-analysis instance requiring intervention.

### Step 2: Fact Preservation

Before any rewrite, Humanizer verifies that the original claim’s facts remain unchanged. The rewrite must never add, remove, or modify factual content; it may only trim the unnecessary -ing clause. This constraint ensures that all substantive meaning is retained while removing stylistic cruft.

### Step 3: Natural-Language Re-write

The flagged clause is converted into a concise statement that conveys the same meaning without the ornamental -ing phrase. For example:

- **Before:** "The temple's color palette of blue, green, and gold resonates with the region's natural beauty, **reflecting** the community's deep connection to the land."
- **After:** "The temple is painted blue, green, and gold, colors meant to evoke Texas bluebonnets and the Gulf of Mexico."

## Rule-Based Architecture

Humanizer’s engine is deliberately **rule-based**, performing no machine-learning inference at runtime. All patterns, including the **shallow -ing analysis** rule, are stored as static markdown data interpreted by a lightweight parser. This design guarantees deterministic, reproducible edits and makes the skill portable across different agent platforms, as documented in [`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md).

## Implementation Examples

You can invoke Humanizer as a Python function or via YAML configuration for agent integration.

### Python API Usage

```python
from humanizer import humanize

raw_text = """
The temple's color palette of blue, green, and gold resonates with the region's natural beauty,
reflecting the community's deep connection to the land.
"""

clean_text = humanize(raw_text)
print(clean_text)

# → The temple is painted blue, green, and gold, colors meant to evoke Texas bluebonnets and the Gulf of Mexico.

```

### YAML Agent Configuration

```yaml
humanizer:
  input: |
    The temple's color palette of blue, green, and gold resonates with the region's natural beauty,
    reflecting the community's deep connection to the land.
  mode: default

```

## Summary

- Humanizer identifies **shallow -ing analysis** by matching text against specific gerunds defined in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) under the section `### 3. Shallow analysis with –ing phrases`.

- The system uses a strict **fact preservation** policy to ensure rewrites only remove ornamental language, never altering underlying information.
- The architecture is **rule-based** and deterministic, relying on static markdown files rather than runtime machine learning for predictable, portable performance.

## Frequently Asked Questions

### What exactly constitutes "shallow -ing analysis"?

Shallow -ing analysis refers to the AI-writing habit of appending gerund phrases like "reflecting," "highlighting," or "ensuring" to factual statements. These phrases create a false sense of depth or analysis without adding substantive information, often making prose sound generic or robotic.

### Where is the shallow -ing analysis pattern defined in the Humanizer codebase?

The pattern is defined in the [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) file at the root of the `blader/humanizer` repository, specifically under the markdown heading `### 3. Shallow analysis with –ing phrases`. This file acts as the single source of truth for all AI-writing-pattern detections.

### Does Humanizer use machine learning to detect these patterns?

No. According to the source code architecture described in the repository, Humanizer operates as a **rule-based** system with no machine-learning inference at runtime. The lightweight parser applies static rules from markdown files, ensuring deterministic and reproducible edits across different environments.

### Can Humanizer modify the factual content of a sentence during a rewrite?

Absolutely not. The **fact preservation** step explicitly forbids adding, removing, or modifying factual content. The system is constrained to trimming unnecessary -ing clauses only, ensuring that the rewrite conveys the exact same factual information as the original text.