# AI Pattern Killer

> Detect and eliminate AI writing patterns from any text. Use when the user says '/ai-pattern-killer', 'humanize this', 'kill AI patterns', 'remove AI smell', or 'make this sound human'.

- Skill: `rap-p/ai-pattern-killer` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add rap-p/ai-pattern-killer`
- Raw SKILL.md: https://api.skillmd.com/api/skills/rap-p/ai-pattern-killer/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: rap-p (https://skillmd.com/u/rap-p)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/rap-p/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`:
   ```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`:
   ```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:
   ```json
   {
     "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:
   ```json
   {
     "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.