# How Humanizer Fixes the 'Not X but Y' Pattern in AI-Generated Text > Humanizer fixes the 'Not X but Y' AI text pattern. It detects negation, removes artificial emphasis, and creates direct positive statements for clearer writing. - Repository: [Siqi Chen/humanizer](https://github.com/blader/humanizer) - Tags: deep-dive - Published: 2026-09-10 --- **Humanizer fixes the "Not X but Y" pattern by detecting rhetorical staging cues through regex-based tell-markers, evaluating whether the negative clause contains substantive information or merely artificial emphasis, and transforming the sentence into a direct positive statement that eliminates unnecessary negation.** The `blader/humanizer` repository implements a specialized text refinement skill designed to identify and correct mechanical rhetorical patterns typical of large language model outputs. When processing content containing the **"Not X but Y" pattern**—catalogued as Pattern 1 in the project's staging detection system—Humanizer removes inflated weighting and restores natural human-like prose by stripping away negation that adds no informational value. ## Understanding the "Not X but Y" Anti-Pattern Large language models frequently employ contrastive constructions to manufacture emphasis, resulting in prose that sounds artificially staged. Humanizer recognizes several variations of this pattern as documented in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), including explicit contrasts like "not X but Y", qualified forms such as "not just/only/merely X, but Y", reframed statements like "it's not X, it's Y", and split-sentence constructions such as "This does not mean X. It means Y." These patterns function as **staging tells**—rhetorical devices that attempt to add weight to a point by first negating a strawman position. When the negative clause merely sets up the positive claim without correcting an actual misconception, Humanizer identifies this as unnecessary computational elaboration rather than genuine communication. ## The Four-Stage Transformation Pipeline According to the implementation in the Humanizer source code, the correction process follows a rigorous pipeline to ensure semantic preservation while eliminating artificial construction. ### Stage 1: Regex-Based Detection Humanizer scans input text using regex-based tell-markers defined in the pattern catalogue. These markers identify cue words and structural signatures that indicate the "Not X but Y" construction is present. ### Stage 2: Information Evaluation The system evaluates whether the negative clause contributes substantive information or merely rhetorical staging. If the negation addresses no real belief held by the reader—meaning it only adds artificial weight without new content—Humanizer flags the clause for removal. ### Stage 3: Positive-Only Rewriting During transformation, Humanizer removes the unnecessary negative half and states the point directly. For split-sentence contrasts, the system merges the clauses into a single coherent statement that preserves the core claim while eliminating the artificial negation structure. ### Stage 4: Semantic Verification The rewritten output undergoes comparison against the original to verify that no factual information has been lost and that genuine contrasts—where the negative portion corrects an actual misconception—remain intact when warranted. ## Practical Implementation and Code Examples You can invoke Humanizer's correction capabilities through direct function calls. The following examples demonstrate how the pattern detection and transformation work in practice. **Example 1: Qualified Contrast** ```python # Input containing "not just... but" construction text = """ It's not just about the beat riding under the vocals; it's part of the aggression and atmosphere. It's not merely a song, it's a statement. """ # Process through Humanizer from humanizer import humanize clean = humanize(text) print(clean) ``` **Output:** > The heavy beat adds to the aggressive tone. **Example 2: Split-Sentence Contrast** ```python text = """ This does not mean every choice is equal. It means there is no external system that confirms which choice is right. """ print(humanize(text)) ``` **Output:** > No external system confirms which choice is right, although the choices still have different consequences. **Example 3: Clipped Negative Construction** ```python text = "The options come from the selected item, no guessing." print(humanize(text)) ``` **Output:** > The options come from the selected item without forcing the user to guess. ## Key Source Files and Architecture The Humanizer implementation relies on specific documentation files that define the pattern catalogue and integration methods: - **[`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)**: Contains the complete pattern catalogue including Pattern 1 (the "Not X but Y" staging tell) and specifies the regex markers used for detection. - **[`README.md`](https://github.com/blader/humanizer/blob/main/README.md)**: Provides installation instructions and invocation context for using the skill in text processing pipelines. - **[`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md)**: Details how the skill is exposed to various agent platforms including OpenAI and Claude integrations. ## Summary - Humanizer treats the "Not X but Y" construction as Pattern 1, a staging tell common in LLM outputs. - The detection system uses regex-based tell-markers to identify variations including "not just/merely X, but Y" and split-sentence contrasts. - The transformation pipeline evaluates whether negative clauses add real information or merely artificial weight before rewriting. - Valid transformations preserve factual content while eliminating unnecessary negation, resulting in more direct, human-like prose. - Pattern definitions and detection rules reside in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), while integration guides are available in [`README.md`](https://github.com/blader/humanizer/blob/main/README.md) and [`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md). ## Frequently Asked Questions ### What makes the "Not X but Y" pattern a problem in AI-generated text? The pattern often signals **rhetorical staging** rather than genuine communication. When models use "not X but Y" constructions without X being an actual misconception the reader holds, they create artificial weight and distance the text from natural human writing styles. Humanizer identifies these instances as tells that indicate computational elaboration rather than necessary contrast. ### How does Humanizer distinguish between necessary and unnecessary negation? Humanizer employs an **evaluation stage** that checks whether the negative clause corrects a real belief or merely sets up the positive claim for emphasis. If the negation adds no new substantive information—meaning the sentence would communicate the same content without it—the system classifies the construction as a tell and removes the negative half. ### Can Humanizer handle complex split-sentence constructions? Yes. The transformation pipeline specifically addresses **split-sentence contrasts** such as "This does not mean X. It means Y." by merging the clauses into a single positive statement. As shown in the code examples, the system preserves the core factual claim while eliminating the artificial negation structure, creating more concise and natural prose. ### Where are the pattern definitions stored in the repository? All pattern definitions, including the complete rules for "Not X but Y" detection and transformation, are documented in **[`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)** at the repository root. Integration instructions for different platforms are found in [`README.md`](https://github.com/blader/humanizer/blob/main/README.md) and [`AGENTS.md`](https://github.com/blader/humanizer/blob/main/AGENTS.md), which explain how to load and invoke the skill within various agent frameworks.