# What "Weak Alone" Means in Humanizer Pattern Definitions

> Understand what weak alone means in Humanizer pattern definitions. Discover how single AI tells require support from other tells to trigger edits in Blader's Humanizer project.

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

---

**In the Humanizer project, "weak alone" indicates that a single instance of an AI-generated tell is insufficient to trigger an edit and must appear alongside other tells in the same passage before the system will act on it.**

The open-source `blader/humanizer` repository provides a framework for identifying AI-generated text through numbered pattern recognition. Within the project's core definitions, the term **"weak alone"** categorizes specific linguistic cues that lack standalone diagnostic strength but collectively signal synthetic prose. According to [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), these marginal cues require companionship from other tells before warranting editorial action.

## Understanding Pattern Strength and the "Weak Alone" Flag

Humanizer organizes AI-generated tells into numbered patterns ranging from the strongest (§1) to the weakest (§5). The **"weak alone"** designation serves as a critical safeguard against over-editing clean prose based on isolated, low-impact cues.

According to the source code in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) at line 29, the skill's introductory rules state that patterns marked *weak alone* "needs company from other tells in the same passage before you act." This requirement ensures that single instances of marginal punctuation or phrasing—such as an em-dash or a hyphenated buzzword—do not trigger unnecessary rewrites in otherwise human-authored text.

### Common "Weak Alone" Pattern Examples

Throughout [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) (lines 62-63 and 366-367), the documentation repeatedly emphasizes that marginal cues carry the *weak alone* tag. These include:

- **Dashes** (em-dashes and en-dashes)
- **Curly quotes** (smart quotation marks)
- **Stacked qualifiers** (phrases like "to be fair," "might arguably," or "could potentially")
- **Hyphenated pairs** (buzzword constructions like "cross-functional," "data-driven," or "high-quality")
- **Passive voice** constructions

The documentation explicitly states: "Act on a *weak alone* tell only when several tells share a passage."

## Implementing "Weak Alone" Detection Logic

While Humanizer itself is implemented as a Markdown skill, the detection logic can be replicated in any programming language. The key principle requires identifying at least two distinct weak-alone patterns before triggering an edit, embodying the "needs company" rule from the source documentation.

The following Python implementation demonstrates this collective detection approach:

```python

# Example: Detecting whether a tell should be acted upon

WEAK_ALONE_PATTERNS = {
    "dash": r"—|–|--",
    "curly_quotes": r"[“”]",
    "stacked_qualifiers": r"\b(?:to be fair|might arguably|could potentially)\b",
    "hyphenated_pairs": r"\b(?:cross-functional|data-driven|high-quality)\b",
    "passive_voice": r"\b(?:is|are|was|were) \w+ed\b",
}

def find_tells(text):
    """Return a list of (pattern_name, match_span) for all tells found."""
    tells = []
    for name, regex in WEAK_ALONE_PATTERNS.items():
        for m in re.finditer(regex, text):
            tells.append((name, m.span()))
    return tells

def should_edit(passage):
    """Only edit if at least two different weak‑alone tells appear."""
    tells = find_tells(passage)
    unique_patterns = {name for name, _ in tells}
    return len(unique_patterns) >= 2   # need “company”

# Usage

paragraph = "The new policy — announced without warning — affects thousands."
if should_edit(paragraph):
    # Perform rewrite (e.g., replace dash with commas)

    rewrite = re.sub(r"—", ",", paragraph)
    print(rewrite)

```

The `should_edit` function embodies the *weak alone* principle by requiring **two or more distinct weak-alone tells** before any modification is performed, preventing false positives from single, isolated cues.

## Summary

- **"Weak alone"** marks AI-generated tells in Humanizer that require multiple instances before triggering edits.
- Patterns range from §1 (strongest) to §5 (weakest), with weak-alone cues falling in the marginal categories.
- The rule requires "company from other tells in the same passage" as defined in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) at line 29.
- Common examples include dashes, curly quotes, stacked qualifiers, hyphenated pairs, and passive voice.
- As documented in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) (lines 62-63, 366-367), only passages containing several weak-alone tells warrant rewriting.

## Frequently Asked Questions

### What does "weak alone" mean in Humanizer?

In Humanizer, **"weak alone"** describes an AI-generated tell that is not strong enough individually to justify an edit. According to [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), these patterns need to appear alongside other tells in the same passage before Humanizer will act on them, functioning as a safeguard against over-editing.

### Which patterns are marked as "weak alone" in the source code?

The [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) file marks several marginal cues as *weak alone*, including em-dashes and en-dashes, curly quotation marks, stacked qualifiers like "to be fair" or "could potentially," hyphenated buzzwords such as "data-driven," and passive voice constructions. These are considered low-impact individually but significant collectively.

### How many "weak alone" tells are required to trigger an edit?

While the exact threshold depends on implementation, the source logic in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) and the reference Python implementation demonstrate that at least **two different weak-alone tells** must appear in the same passage. The documentation emphasizes requiring "several tells" to share a passage before acting on any of them.

### Where is the "weak alone" rule defined in the Humanizer repository?

The primary definition resides in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) at line 29, which states that patterns marked *weak alone* "needs company from other tells in the same passage before you act." Additional clarifications appear at lines 62-63 and 366-367, reminding users to "Act on a *weak alone* tell only when several tells share a passage."