# How Humanizer Detects and Fixes "Shallow ‑ing Analysis" (Pattern 3)

> Humanizer fixes shallow -ing analysis by detecting lexical cues like symbolizing and reflecting, then removes decorative -ing riders for substantiated facts.

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

---

**Humanizer identifies "shallow ‑ing analysis" by scanning for specific lexical cues like "symbolizing" and "reflecting," then removes these decorative ‑ing riders to leave only substantiated facts.**

The `blader/humanizer` repository implements a systematic approach to detecting and correcting shallow ‑ing analysis—one of fifteen documented anti-patterns that make AI-generated text sound artificially profound. This pattern specifically targets **‑ing phrases bolted onto simple facts** to create an illusion of depth without adding genuine informational value.

## What Is Shallow ‑ing Analysis?

Shallow ‑ing analysis occurs when writers attach participial phrases to straightforward statements in an attempt to sound more analytical or insightful. The underlying fact remains unchanged; only the rhetorical packaging grows more elaborate.

Consider this representative example from the Humanizer documentation:

- **Before:** "The temple's color palette of blue, green, and gold resonates with the region's natural beauty, **symbolizing** Texas bluebonnets, the Gulf of Mexico, and the diverse Texan landscapes, **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."

The revised version strips away the unverified "symbolizing" and "reflecting" claims, delivering only what can be directly observed or sourced.

## Detection: The Pattern 3 Lexical Cue List

Humanizer detects shallow ‑ing analysis through a predefined set of lexical triggers documented in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md). According to the source code at lines 33–36, the pattern scans for these specific ‑ing constructions:

```markdown
highlighting, underscoring, emphasizing, ensuring, 
reflecting, symbolizing, contributing to, cultivating, 
fostering, encompassing, showcasing

```

These cues appear in **Pattern 3** (referenced as "Pattern 15" in some documentation versions) within [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md). The detection logic treats any sentence containing these terms as a candidate for shallow ‑ing analysis, flagging it for potential revision.

## Rationale: Why Shallow ‑ing Analysis Weakens Writing

The rule governing this pattern, found at lines 35–37 of [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), establishes a clear editorial principle:

> "An ‑ing phrase is bolted onto a simple fact to make it sound deeper… Keep the fact; keep the rider only when the source supports what it claims."

This formulation captures two critical distinctions:

1. **The core fact** — the verifiable, concrete statement that carries informational weight.
2. **The ‑ing rider** — the speculative or interpretive addition that sounds analytical but lacks substantiation.

Humanizer's stance is unambiguous: riders without explicit source validation constitute **model-generated filler** rather than meaningful contribution.

## Correction Strategy: Three-Step Processing

When Humanizer encounters shallow ‑ing analysis, it applies a consistent three-step correction protocol:

1. **Preserve** the core factual clause—the concrete claim that remains true without embellishment.
2. **Drop** the decorative ‑ing rider unless the original source explicitly validates the interpretive claim.
3. **Rewrite** to a concise, fact-only version that reads with human directness.

The transformation in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) (lines 38–40) demonstrates this protocol in action, reducing a 29-word sentence with multiple riders to a 12-word factual statement.

## Practical Implementation

While Humanizer operates primarily as a Markdown-based skill for agent integration, the detection logic can be extracted for programmatic use. Below is a minimal implementation reflecting the pattern's core heuristic:

```python
def remove_shallow_ing(sentence: str) -> str:
    """
    Remove shallow ‑ing riders from a sentence.
    Based on Pattern 3 from blader/humanizer SKILL.md.
    """
    # Lexical cues sourced from SKILL.md lines 33-36

    cues = [
        "highlighting", "underscoring", "emphasizing", "ensuring",
        "reflecting", "symbolizing", "contributing to", "cultivating",
        "fostering", "encompassing", "showcasing"
    ]
    
    for cue in cues:
        if f" {cue} " in f" {sentence.lower()} ":
            # Split at the cue and retain the left-hand fact

            fact = sentence.split(cue)[0].strip().rstrip(",")
            return fact + "."
    
    return sentence

```

**Usage example:**

```python
original = (
    "The temple's color palette of blue, green, and gold "
    "resonates with the region's natural beauty, symbolizing "
    "Texas bluebonnets, the Gulf of Mexico, and the diverse "
    "Texan landscapes, reflecting the community's deep "
    "connection to the land."
)

print(remove_shallow_ing(original))

# Output: "The temple's color palette of blue, green, and gold resonates with the region's natural beauty."

```

## Integration Architecture

Humanizer's shallow ‑ing detection integrates across multiple system components:

| File | Function |
|------|----------|
| **[`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)** | Defines Pattern 3, including cue list, rationale, and before/after examples |
| **[`README.md`](https://github.com/blader/humanizer/blob/main/README.md)** | Documents installation and pattern reference numbers for end users |
| **[`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md)** | Specifies how skills load across supported agent platforms, ensuring pattern availability |

The skill architecture allows this detection logic to operate consistently whether invoked through command-line tools, IDE extensions, or automated content pipelines.

## Distinguishing Legitimate From Shallow ‑ing Usage

Not all ‑ing phrases warrant removal. Humanizer's correction strategy explicitly **preserves riders when source material validates them**. This creates an important distinction:

- **Remove:** "The proposal passed, **underscoring** bipartisan support" (no source cited for the underscoring claim).
- **Preserve:** "The proposal passed, **reflecting** the 340‑page impact assessment published by the Congressional Budget Office" (source explicitly supports the reflection).

The pattern targets *unsubstantiated* analytical gestures, not interpretive language grounded in evidence.

## Summary

- **Detection:** Humanizer scans for eleven specific lexical cues—`symbolizing`, `reflecting`, `highlighting`, and eight others—defined in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) Pattern 3.
- **Rationale:** These ‑ing riders attach to simple facts without increasing informational value, creating artificially "deep" prose.
- **Correction:** The system preserves core facts, drops unverified riders, and rewrites to concise, human-readable statements.
- **Integration:** Pattern logic resides in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) and loads through [`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md) for cross-platform availability.

## Frequently Asked Questions

### What makes an ‑ing phrase "shallow" rather than substantive?

A shallow ‑ing phrase restates or embellishes an already-complete fact without adding verifiable information. According to the `blader/humanizer` source, these constructions are "bolted onto a simple fact to make it sound deeper." Substantive ‑ing phrases, by contrast, introduce new causal relationships or interpretations that sources explicitly support.

### Can shallow ‑ing analysis detection be customized with additional cue words?

The current implementation in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) uses a fixed lexical list. While the pseudocode example demonstrates extensibility, production deployments reference the documented pattern set. Users seeking customization would modify the cue array in their implementation or extend the skill definition directly.

### How does Humanizer handle multiple ‑ing riders in a single sentence?

The pattern applies iteratively until all shallow riders are processed. The [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) example shows a sentence with both "symbolizing" and "reflecting" riders transformed into a single fact-only statement. The correction preserves the outermost factual clause and removes subsequent riders regardless of count.

### Is shallow ‑ing analysis specific to AI-generated text?

While human writers certainly produce shallow ‑ing constructions, the pattern appears with elevated frequency in model-generated content because language models favor "sounding analytical" as a completion strategy. Humanizer specifically targets this AI-proliferated pattern to restore human-sounding directness.