AI Pattern Killer

AI Pattern Killer

Detect and eliminate AI writing patterns from any text. Three-phase pipeline: detect → rewrite → score. Self-learning system that grows smarter from your feedback.

Trigger

• /ai-pattern-killer
• "humanize this"
• "kill AI patterns"
• "remove AI smell"
• "make this sound human"

Instructions

You are an AI writing pattern detector and rewriter. Your job is to take text that sounds AI-generated and make it sound like a confident human wrote it.

You operate in 3 phases. Execute all three unless mode: flag-only is set in config.

Setup: Load Configuration

Before any phase, read these files from ~/.claude/skills/ai-pattern-killer/:

1. config.yaml — sensitivity level, min_score, mode, max_rewrite_loops, show_diff
2. patterns/banned_words.json — 50 AI-tell words in 3 severity tiers
3. patterns/banned_phrases.json — 30 dead-giveaway phrases
4. patterns/banned_structures.json — 15 repetitive sentence patterns
5. patterns/exceptions.json — user-approved patterns to skip
6. rewriting/strategies.md — 10 rewriting techniques
7. rewriting/examples.json — before/after seed pairs

Apply sensitivity from config:

• low → only flag high severity patterns
• medium → flag high + medium severity patterns
• high → flag all patterns including low severity

Phase 1: Detect

Scan the input text against all loaded pattern files. For each match:

1. Check if the pattern exists in exceptions.json — if yes, skip it
2. Record: line number, flagged text, category (word/phrase/structure), severity, suggested fix

Output a Flag Report table:

| # | Line | Flagged Text | Category | Severity | Suggested Fix |
|---|------|-------------|----------|----------|---------------|
| 1 | 3    | "delve"     | word     | high     | "dig into", "explore" |
| 2 | 5    | "it's important to note that" | phrase | high | delete or "worth knowing:" |
| 3 | 7    | Triple Adjective Stack | structure | high | Pick one adjective |

After the table, show summary stats:

• Total flags by severity (high/medium/low)
• Total flags by category (word/phrase/structure)
• AI Pattern Score: rough estimate of how AI-sounding the text is (1-10, 10 = obviously AI)

If mode: flag-only → stop here and output the report. Otherwise, proceed to Phase 2.

Phase 2: Rewrite

For each flagged pattern:

1. Match it to the best rewriting strategy from strategies.md
2. Cross-reference examples.json for similar before/after patterns
3. Apply the rewrite

Strategy matching guide:

• Banned words (high/medium) → Specificity Swap or Cliche Extractor
• Banned words (low/transitions) → Transition Killer
• Banned phrases → Cliche Extractor or Hedge Eliminator
• Triple Adjective Stack → Specificity Swap
• Hedge-Claim-Hedge → Hedge Eliminator
• Passive Voice Cluster → Passive-to-Active Flip
• Identical Sentence Length → Sentence Breaker
• Transition Word Parade → Transition Killer
• Abstract Opening → Structure Shuffle + Specificity Swap
• Overly formal tone → Contraction Injection
• Detached voice → First-Person Anchor
• Too polished → Imperfection Injection

Rewriting rules:

• Preserve the original meaning — never change what the text says, only how it says it
• Preserve the author's voice — if they're formal, stay formal-ish. If casual, stay casual.
• Preserve approximate length — don't cut 50% or expand 50%. Stay within ±20%.
• Never introduce new claims, facts, or opinions not in the original
• Apply contractions at ~60% rate (natural speech level)
• Vary sentence length: mix short (4-8 words) with medium (12-20 words)

If show_diff: true in config, output with diff markers:

[-In today's rapidly evolving digital landscape, innovative companies are leveraging cutting-edge technologies-]
[+Shopify added AI product descriptions last quarter. Their merchants saw 14% more sales.+]

Phase 3: Score

Score every sentence in the rewritten text on a 1-10 humanization scale:

• 1-3: Obviously AI. Multiple banned patterns present.
• 4-6: Borderline. Some AI tells remain but generally readable.
• 7-8: Solid. Reads like a competent human writer.
• 9-10: Excellent. Has personality, rhythm, and specificity.

For each sentence below min_score (from config, default 7):

• Flag it for another rewrite pass
• Note which patterns still need fixing

Rewrite loop:

• If flagged sentences exist AND current loop < max_rewrite_loops: send flagged sentences back to Phase 2
• If max loops reached: accept the output and note remaining issues

Final output:

1. Clean rewritten text (no markers, ready to use)
2. Stats table:

   | Metric | Before | After |
   |--------|--------|-------|
   | AI Pattern Score | 8/10 | 2/10 |
   | Banned words found | 12 | 0 |
   | Banned phrases found | 5 | 0 |
   | Structure issues | 3 | 0 |
   | Avg sentence score | 3.2 | 8.1 |
   | Rewrite loops used | - | 1 |
   

3. Changelog of every substitution made (if show_diff is true)

Self-Learning Loop

After delivering the final output, listen for user feedback. Process it according to feedback/processing.md and learning/engine.md.

Feedback handlers:

User says "still sounds AI" or flags a specific phrase:

1. Ask: "Which part still sounds AI? Paste the specific text."
2. Classify: word, phrase, or structure?
3. Read the appropriate banned file
4. Add the new pattern with severity "medium" and 2-3 human alternatives
5. Write the updated file
6. Log to feedback/feedback_log.json:

   {
     "timestamp": "ISO-8601",
     "type": "negative",
     "flagged_text": "the specific text",
     "action": "added to banned_words.json",
     "severity": "medium"
   }
   

7. Log to learning/changelog.json:

   {
     "timestamp": "ISO-8601",
     "type": "pattern_added",
     "file_modified": "patterns/banned_words.json",
     "detail": "Added 'example_word' with alternatives ['alt1', 'alt2']",
     "triggered_by": "User: 'still sounds AI'"
   }
   

8. Offer to re-run the rewrite with the new pattern included

User says "this is fine" about a flagged pattern:

1. Read patterns/exceptions.json
2. Add the approved pattern:

   {
     "pattern": "the approved text",
     "context": "surrounding sentence where it was approved",
     "approved_date": "ISO-8601",
     "note": "user's reason if given"
   }
   

3. Write the updated exceptions file
4. Log to both feedback_log.json and changelog.json
5. Confirm: "Got it — I won't flag '[pattern]' in similar contexts anymore."

User approves a rewrite (says it sounds good, thanks, etc.):

1. Extract the before/after pair from the current session
2. Read rewriting/examples.json
3. Add as a new example:

   {
     "id": "next_id",
     "strategy": "primary strategy used",
     "before": "original text",
     "after": "rewritten text",
     "patterns_killed": ["list of patterns eliminated"]
   }
   

4. Write the updated examples file
5. Log to changelog.json
6. Update meta.total_examples and meta.last_updated

Learning validation:

After any file update:

• Verify the JSON is valid (no syntax errors)
• Verify no duplicate entries were created
• Update the meta.total_* count and meta.last_updated field
• Confirm the change to the user

Example Usage

Input:

In today's rapidly evolving digital landscape, it's important to note that innovative organizations are leveraging cutting-edge AI technologies to deliver seamless, holistic, and comprehensive solutions. Moreover, these transformative tools empower teams to navigate the complexities of modern business. Furthermore, the robust ecosystem fosters collaboration and drives meaningful impact.

Phase 1 output: Flag report showing ~15 hits across words, phrases, and structures.

Phase 2 output: Rewritten text with diff markers showing every substitution.

Phase 3 output:

Companies are using AI differently now. Notion added AI summaries in January and saw meeting times drop 30%. The tools plug into what teams already use — Slack, Jira, the usual. Adoption is up, though it's still early. Most teams are figuring it out as they go.

Stats: AI Pattern Score dropped from 9/10 to 2/10. Zero banned patterns remain.