Stop Sounding Like a Chatbot! Use avoid-ai-writing Instead

Stop Sounding Like a Chatbot! Use avoid-ai-writing Instead

Your carefully crafted blog post just got flagged as AI-generated. Again. You spent hours refining that pitch deck, and investors dismissed it as "obviously ChatGPT." Your job application? Rejected before a human even read it. Here's the brutal truth: AI detection tools are everywhere now—and they're not wrong. Most AI-written content is dripping with tells that scream "robot." But what if you could audit your writing, strip out every AI pattern, and sound unmistakably human—without losing your actual message? Enter avoid-ai-writing, the open-source skill that's making AI detection tools obsolete and saving writers from the chatbot stigma.

What Is avoid-ai-writing?

avoid-ai-writing is a portable, open-source writing skill created by Conor Bronsdon that audits and rewrites content to eliminate AI writing patterns—what the project calls "AI-isms." Unlike basic prompt engineering or one-shot "humanize this" commands, this tool delivers a structured, two-pass detection system with surgical precision. It's designed to work with popular AI agents including Claude Code, OpenClaw, Hermes, and any other agentskills.io-compatible agent.

The project exploded in popularity for one simple reason: it solves a real problem that millions face. As AI writing tools proliferated, so did AI detection tools—and the arms race left legitimate writers caught in the crossfire. Students, marketers, founders, and journalists found their authentic voices erased by suspicion. Bronsdon's skill doesn't try to "trick" detectors with cheap tricks. Instead, it genuinely improves writing by identifying and eliminating the structural patterns, vocabulary choices, and rhythmic uniformity that make AI-generated text recognizable.

What makes this skill genuinely different? It's not vibes-based. Every flagged pattern has a documented alternative. The system includes 109 vocabulary entries across three tiers, 42 distinct pattern categories, and a second-pass audit that catches surviving tells. This isn't paraphrasing—it's professional-grade editorial intelligence packaged as a reusable skill.

Key Features That Make This Skill Insanely Powerful

Two Operational Modes

Rewrite mode (default) flags every AI pattern and rewrites the text to fix them. But here's the secret weapon: a built-in second pass re-reads the rewrite and catches patterns that survived the first edit—recycled transitions, lingering inflation, copula swaps that snuck through. Most "humanizer" tools stop at one pass. This doesn't.

Detect mode flags patterns without rewriting. This is crucial when patterns might be intentional, when you're auditing content you don't want altered, or when you need a quick scan. It shows which flags are real problems versus judgment calls—a level of nuance almost no other tool offers.

Structured Four-Section Output

The rewrite mode returns:

1. Issues found — every AI-ism identified, with the exact text quoted
2. Rewritten version — clean version with all AI-isms removed
3. What changed — summary of major edits
4. Second-pass audit — catches any surviving tells

This transparency matters. You see exactly what changed and why—building your own pattern recognition over time.

The 109-Entry Vocabulary System

Not all problematic words are equal. The three-tier system reflects this reality:

Tier 3 phrases are particularly clever. They flag on per-phrase repetition (≥2 hits) or when 3+ distinct phrases stack in one piece—catching the "LLM-self-varies-boilerplate" shape where models synonym-swap to avoid repetition but keep the same hollow structure.

42 Pattern Categories

From significance inflation ("marking a pivotal moment") to sycophantic tone ("Great question!"), from hashtag stuffing to bare-NP bullet lists—the coverage is encyclopedic. The v3.4 structural detection additions specifically target LLM output that sidesteps vocabulary tables by substituting synonyms but retains identifiable structural shapes.

Use Cases: Where This Skill Absolutely Shines

1. Founder Pitch Decks and Fundraising Materials

Investors are inundated with AI-generated decks. When your "vibrant startup nestled in the heart of" Silicon Valley reads like every other YC applicant's ChatGPT output, you lose credibility before slide three. The skill transforms promotional fluff into concrete claims: "Acme Analytics raised $40M Series B led by Sequoia" instead of "marking a watershed moment for the observability landscape."

2. Job Applications and LinkedIn Content

Recruiters now run AI detection on cover letters. The skill eliminates chatbot artifacts ("Certainly!", "I hope this helps!") and generic conclusions ("The future looks bright") that trigger automatic rejections. More importantly, it teaches you to replace vague attributions ("Experts believe") with specific evidence ("According to a 2024 Gartner survey").

3. Crypto/Web3 and AI-Infra Social Content

This is where structural detection (v3.4) becomes essential. The space is saturated with LLM-generated threads full of Tier 3 phrase stacking: "the integration of decentralized compute with community-driven long-term sustainability." The skill catches future-narrative closers, hedge-stacked predictions ("could potentially create, may eventually unlock"), and hashtag stuffing—empirically, 6+ tags is near-universal in LLM social output, rare in thoughtful human posts.

4. Academic and Research Writing

Students and researchers face false positives from AI detectors that flag legitimate technical writing. The skill's detect mode lets you audit your own work preemptively, identifying whether flagged patterns are actually problematic or intentional (like precise terminology in your field). The 42 pattern categories with before/after examples serve as an educational tool for improving your baseline writing.

5. Content Marketing^{↗ Bright Coding Blog} at Scale

Marketing teams using AI assistants for first drafts can run this skill as a mandatory quality gate. The second-pass audit ensures nothing slips through, and the structured output lets editors review changes efficiently rather than rewriting from scratch.

Step-by-Step Installation & Setup Guide

Claude Code (Three Options)

Option 1: Clone into skills directory (Recommended)

# Clone directly to Claude Code's skills directory
git clone https://github.com/conorbronsdon/avoid-ai-writing ~/.claude/skills/avoid-ai-writing

Option 2: Copy the file directly

Download SKILL.md and place it in any directory Claude Code can read. Reference it in your CLAUDE.md:

- Editing for AI patterns → read `path/to/avoid-ai-writing/SKILL.md`

Option 3: Use as a slash command

Create a command file for instant access:

# Create the commands directory if it doesn't exist
mkdir -p ~/.claude/commands

# Create the command file
cat > ~/.claude/commands/clean-ai-writing.md << 'EOF'
---
description: Audit and rewrite content to remove AI writing patterns
---

$ARGUMENTS

Read and follow the instructions in ~/.claude/skills/avoid-ai-writing/SKILL.md
EOF

Then trigger instantly with: /clean-ai-writing <your text>

OpenClaw (Two Options)

Option 1: Install from ClawHub (Easiest)

# Install directly from the community registry
clawhub install avoid-ai-writing

Option 2: Clone into skills directory

git clone https://github.com/conorbronsdon/avoid-ai-writing ~/.openclaw/skills/avoid-ai-writing

Cursor IDE

# Create the rules directory
mkdir -p .cursor/rules

# Download the ported rule
curl -o .cursor/rules/avoid-ai-writing.mdc \
  https://raw.githubusercontent.com/conorbronsdon/avoid-ai-writing/main/cursor-rules/avoid-ai-writing.mdc

Note: See cursor-rules/README.md for activation globs and trigger phrases. Functionally identical to the Claude Code skill—same tier vocabulary, same context profiles, same modes.

Triggering the Skill

Once installed, use natural language prompts:

• "Remove AI-isms from this post"
• "Audit this draft for AI tells"
• "Make this sound less like AI"
• "Clean up AI writing in this paragraph"

For detect mode only, use: "detect," "flag only," "audit only," "just flag," or "scan."

REAL Code Examples from the Repository

Example 1: Basic Installation Command

The README provides this exact clone command for Claude Code users:

git clone https://github.com/conorbronsdon/avoid-ai-writing ~/.claude/skills/avoid-ai-writing

What this does: This single command downloads the entire skill into Claude Code's designated skills directory. The ~/.claude/skills/ path is where Claude Code automatically discovers and loads available skills. By placing avoid-ai-writing here, you make it available to any Claude Code session without additional configuration. The repository structure includes SKILL.md with compatible frontmatter for both Claude Code and OpenClaw platforms—this dual compatibility is intentional, reducing maintenance overhead for users who switch between agents.

Example 2: Slash Command Configuration

Here's the complete slash command setup from the README:

---
description: Audit and rewrite content to remove AI writing patterns
---

$ARGUMENTS

Read and follow the instructions in ~/.claude/skills/avoid-ai-writing/SKILL.md

Breaking this down: The YAML frontmatter (--- delimited) provides metadata that Claude Code uses to populate command suggestions. The $ARGUMENTS placeholder is critical—it injects whatever text you type after /clean-ai-writing directly into the prompt. The instruction to "Read and follow the instructions in..." triggers Claude Code's skill-loading mechanism, which parses the SKILL.md file's structured directives. This pattern of delegating to a skill file (rather than embedding all logic in the command) allows the skill to be updated independently of the command definition.

Example 3: Cursor IDE Rule Download

The Cursor integration uses this curl command:

mkdir -p .cursor/rules
curl -o .cursor/rules/avoid-ai-writing.mdc \
  https://raw.githubusercontent.com/conorbronsdon/avoid-ai-writing/main/cursor-rules/avoid-ai-writing.mdc

Technical insight: Cursor uses .mdc (Markdown^{↗ Smart Converter} with Cursor configuration) files rather than standard .md. The mkdir -p ensures the rules directory exists without error if already present. The raw GitHub URL pulls the latest version directly from the main branch—meaning you'll automatically get updates on re-download, but you should pin to a specific commit for reproducible builds in team environments. The .cursor/rules/ directory is Cursor's convention for project-specific agent behaviors, activated by filename globs defined in the .mdc file's frontmatter.

Example 4: OpenClaw ClawHub Installation

clawhub install avoid-ai-writing

Why this matters: ClawHub is OpenClaw's package registry, analogous to npm or PyPI. The single-command installation demonstrates the project's integration into a broader skill ecosystem—not just a standalone script. The package name avoid-ai-writing resolves to conorbronsdon/avoid-ai-writing through ClawHub's namespace resolution. This ecosystem approach means version management, dependency resolution, and updates are handled by the package manager rather than manual git operations.

Advanced Usage & Best Practices

Combine with Your Editorial Workflow

Don't treat this as a one-time fix. Run detect mode on your first draft to identify your personal AI-tell patterns. Are you overusing "Moreover"? Defaulting to "It's not X, it's Y" constructions? The structured output builds your self-awareness as a writer.

Use the Second-Pass Audit as Training Data

The second-pass section reveals which patterns are most persistent in your writing. Study these. They're your blind spots—the tells that survive because they feel natural to you but read as AI to others.

Know When NOT to Rewrite

Detect mode exists for a reason. Technical documentation, legal contracts, and standardized reports may intentionally use uniform structure. The skill's P0/P1/P2 severity grouping helps you distinguish "always fix" from "context-dependent."

Version Pin for Teams

If you're deploying this across a content team, pin to a specific commit or release rather than main branch. The vocabulary tables and pattern definitions evolve, and you want consistent output across your pipeline.

Comparison with Alternatives

The verdict: Basic prompts catch obvious tells. Bypass tools try to trick detectors with noise—they don't improve your writing and often fail against newer detectors. avoid-ai-writing is the only option that genuinely elevates prose quality while systematically eliminating AI patterns.

FAQ

Does this tool help me evade AI detectors?

No—and that's the point. It removes the patterns that make writing genuinely bad, which coincidentally are what detectors flag. The goal is better writing, not trickery.

Will this work with my custom AI agent?

If your agent supports agentskills.io format, yes. The SKILL.md uses standard frontmatter compatible across platforms.

Can I use this for languages other than English?

The pattern categories and vocabulary are English-specific. However, structural patterns (uniform rhythm, excessive structure, bullet-list inflation) may transfer to other languages.

Is the web app free?

The web app requires burning 1,000 $avoid tokens per audit. The token is community-created on Solana; the skill itself is free via GitHub installation.

How does this differ from Grammarly or Hemingway Editor?

Those tools target general readability. This targets AI-specific patterns that readability tools miss—like hedge-stacked predictions, Tier 3 phrase boilerplate, and LLM structural shapes.

Will detect mode alter my content?

Never. Detect mode only flags patterns with severity ratings. It's explicitly designed for auditing content you don't want rewritten.

How often is the pattern database updated?

The repository is actively maintained. The v3.4 structural detection additions show ongoing evolution as LLM outputs change.

Conclusion

The avoid-ai-writing skill represents something rare in the AI tooling space: a genuine solution to a real problem that doesn't rely on deception. In a world where "AI-generated" has become synonymous with "low-quality," this tool gives writers the editorial intelligence to stand apart—not by tricking detectors, but by producing unmistakably human prose.

The 42 pattern categories, 109-entry vocabulary system, and two-pass audit structure reveal a depth of craft that's absent from one-shot prompts. Whether you're a founder pitching investors, a marketer scaling content, or a student protecting your academic integrity, this skill pays dividends in credibility and clarity.

My take? Install it today. Run detect mode on your last five pieces of writing. I guarantee you'll find patterns you never noticed—and your readers will notice the difference.

👉 Get started now: Clone the repository at github.com/conorbronsdon/avoid-ai-writing and stop sounding like a chatbot.

Authored by Conor Bronsdon · MIT Licensed · Community-powered with web app integration