Humanizer: Teaching Claude to Unwrite Like an AI

Hook

Wikipedia editors have documented 24 statistical patterns that reveal AI-generated text—and now there’s a Claude Code skill that applies those exact rules to make your AI writing pass human inspection.

Context

The internet has an AI writing problem, but it’s not the one you think. The issue isn’t that AI-generated content exists—it’s that it’s obviously AI-generated. Language models have tells: they overuse em dashes, avoid simple linking verbs, inflate significance with phrases like “serves as a testament,” and structure everything in threes. These patterns emerged because LLMs optimize for statistical likelihood, not authentic human expression. When you train on billions of tokens, you learn what words tend to follow other words, which creates a distinctive statistical fingerprint.

Wikipedia’s WikiProject AI Cleanup has been fighting this battle in the trenches. Thousands of editors have catalogued the specific linguistic markers that betray AI authorship—not through speculation, but through analyzing real contributions flagged as AI-generated. Those observations became a living style guide, and Humanizer is the executable version of that knowledge. It’s a Claude Code skill that transforms AI-sounding text into something that reads like a human actually wrote it, using the same 24 patterns Wikipedia editors use to clean up articles. The irony is intentional: using AI to make AI writing less AI-like is the most pragmatic solution when you’re already in the LLM ecosystem.

Technical Insight

Humanizer’s architecture is deceptively simple: it’s a single SKILL.md file that Claude Code interprets as executable instructions. Claude Code skills are markdown documents with a specific structure that the model treats as a combination of system prompt and procedural guide. When you invoke /humanizer or ask Claude to “humanize this text,” it loads the skill document and applies the patterns sequentially.

The real engineering is in the pattern catalogue. Each of the 24 rules targets a specific statistical artifact. Here’s how the skill handles one of the most common tells—copula avoidance:

## Pattern: Copula Avoidance

**Detection:** Look for phrases that use complex verbs or 
"serves as" constructions where simple linking verbs 
(is, are, was, were) would be more natural.

**Examples:**
- "Python serves as a programming language" → "Python is a programming language"
- "The function operates as a validator" → "The function validates"
- "This approach represents a solution" → "This approach solves"

**Fix:** Replace unnecessarily complex verb phrases with 
simple, direct linking verbs or active verbs.

This pattern exists because LLMs see “serves as” frequently in formal writing (academic papers, documentation) and overweight it during generation. Humans use it sparingly for emphasis; AI uses it reflexively. The skill’s approach is to make the pattern explicit with detection criteria, concrete examples, and a transformation rule.

Another sophisticated pattern targets what Wikipedia calls “significance inflation”—the AI tendency to make everything sound more important than it is:

## Pattern: Significance Inflation

**Detection:** Phrases that add dramatic weight without 
adding information: "notably", "significantly", 
"it's worth noting", "importantly", "crucially".

**Examples:**
- "Notably, the function returns null" → "The function returns null"
- "It's worth noting that HTTP is stateless" → "HTTP is stateless"
- "Significantly, this approach reduces latency" → "This approach reduces latency by 40%"

**Fix:** Remove hedging qualifiers or replace with 
specific data. If something is actually significant, 
show why with numbers or consequences.

The skill understands that humans establish significance through what they say, not through meta-commentary about importance. The before/after examples show the transformation in action—not just removing words, but replacing vague emphasis with concrete facts when appropriate.

The execution model is where Claude Code’s architecture shines. Traditional linting tools need parsers, ASTs, and pattern matchers. Humanizer just needs Claude to read instructions and apply them—the model’s language understanding is the parser. When you feed text to the skill, Claude:

1. Loads all 24 patterns into working context
2. Scans the input text for matches (using the same comprehension abilities it uses for conversation)
3. Applies transformations while maintaining semantic meaning
4. Returns rewritten text with specific calls to which patterns were triggered

The skill document even includes meta-instructions for handling edge cases:

## Execution Guidelines

- Apply patterns conservatively. Not every em dash is wrong.
- Preserve technical accuracy above stylistic changes.
- Flag ambiguous cases rather than guessing.
- If a phrase is both technically correct and stylistically 
  appropriate, don't change it just because it *could* be an AI tell.

This is the crucial difference between a simple find-and-replace script and a skill that leverages Claude’s reasoning. The model can distinguish between “This approach is significant because it reduces O(n²) to O(n)” (keep it) and “This approach is significantly better” (remove the qualifier or add specifics). It understands context in ways regex never will.

The skill also handles compound patterns—cases where multiple tells cluster together in ways that create a distinctively AI voice. The classic example is what Wikipedia calls the “chatbot opening”:

Before: "In the realm of modern web development, React 
serves as a powerful library that notably transforms 
the way developers approach UI construction."

After: "React is a JavaScript library for building 
user interfaces. It introduced component-based 
architecture to mainstream web development."

Seven different patterns intersect here: realm language, copula avoidance, significance inflation, vague transformation claims, and compound qualifiers. The skill doesn’t just fix each in isolation—it restructures the entire sentence to sound like something a human developer would actually write in documentation.

Gotcha

The fundamental limitation is that Humanizer is as reliable as Claude’s ability to follow instructions—and LLMs aren’t consistent interpreters. Run the same text through the skill twice and you’ll get variations. Sometimes it over-applies rules, turning perfectly good prose into choppy fragments. Sometimes it misses obvious tells because the surrounding context made them seem appropriate. There’s no test suite, no validation logic, no quality metrics. You’re trusting Claude’s judgment on every transformation, and that judgment varies based on factors you can’t control (context window state, model version updates, even the randomness inherent in sampling).

The portability problem is equally severe. This is a Claude Code skill, full stop. You can’t export it to a CI/CD pipeline, can’t run it in VS Code, can’t integrate it with your documentation build process. If you switch to Cursor or use GitHub Copilot, you’d need to completely reimplement the logic. The Wikipedia patterns are portable, but the execution layer isn’t. And because the skill operates through natural language instructions rather than code, you can’t write unit tests or regression checks. You’re locked into an interactive, manual workflow where every use requires human review of the output. For one-off document cleanup that’s fine. For systematic quality control across a content pipeline, it’s a non-starter.

Verdict

Use Humanizer if you’re already working in Claude Code and need to post-process AI-generated drafts for contexts where obvious AI tells would damage credibility—Wikipedia contributions, professional documentation, technical reports, or any writing that will be scrutinized by audiences familiar with LLM output patterns. The Wikipedia-sourced rules are battle-tested and well-documented, and the skill integrates seamlessly into your existing Claude workflow without requiring separate tools. Skip it if you’re not using Claude Code (you’re buying into a completely closed ecosystem), if you need programmatic integration (it’s interactive-only with no API access), or if your writing needs actual human voice rather than just the absence of AI tells—Humanizer is pattern removal, not authenticity injection. Also skip it if you’re working on creative writing or marketing copy where the goal is distinctive voice rather than neutral professionalism; removing statistical tells makes text less obviously AI-generated, but it doesn’t make it meaningfully human. This tool is best understood as a final polish for technical content where the writing itself should be invisible, not as a replacement for actually understanding your subject matter well enough to write with authority.