Skill: hosthobbit/ai-writing-humanizer (version 0.1.0)

--- name: ai-writing-humanizer description: Automatically strip AI writing patterns and stock phrases from user-facing prose before sending. Use when preparing longer texts to ensure a natural, human tone without obvious AI tells. --- # AI Writing Humanizer Provide a cleaned, human-sounding version of input text by removing or rewriting common AI-generated writing patterns. Load this skill automatically for any user-facing prose longer than ~150 words. ## Patterns Covered - Overuse of hedging phrases: "At the end of the day", "It's worth noting", "It is important to remember" - Stock transitions and signposts: "First", "Secondly", "Finally" - Structural markers: em dashes (—), parentheses for side notes, bullet-like serial lists - Predictable rule-of-three constructs: "X, Y, and Z" used as checklist language - Passive voice sections flagged by "was", "were", "has been" - Performed authenticity cues: "I hope this helps", "Let me know if you have any questions" ## Usage 1. Pass input text to `scripts/humanize.py --input text.txt --output cleaned.txt`. 2. For integrations, import `humanize_text()` from the script and apply before sending. ## Bundled Resources - scripts/humanize.py — Python script implementing regex-based pattern removal and light rewriting - references/signs-of-ai-writing.md — List of AI writing signs based on Wikipedia - tests/test_humanizer.py — Regression tests to detect patterns

path: references/signs-of-ai-writing.md
content: # Signs of AI Writing

This reference lists common patterns and phrases often found in AI-generated text, based on Wikipedia's "Signs of AI writing" page.

## Common Phrases and Tells

- Hedging language: "It is worth noting", "At the end of the day", "It is important to remember", "Ultimately", "Generally speaking"
- Stock phrases: "In conclusion", "To be honest", "However, it's important to note"
- Rule-of-three lists: "First, second, and third", "X, Y, and Z"
- Transitional signposts: "Firstly", "Secondly", "Next", "Finally"
- Performed authenticity: "I hope this helps", "Feel free to reach out", "Let me know if you have questions"

## Structural Patterns

- Em dashes: extensive use of "—"
- Overuse of parentheses for side notes
- Parenthetical lists and bullet-like enumerations within prose
- Excessive passive voice: frequent "was", "were", "has been" without clear actor

## Usage Notes

Use this reference to update regex patterns in the humanizer script. Keep adding new patterns as they are discovered.


path: scripts/humanize.py
content: #!/usr/bin/env python3
"""
Simple humanizer to strip common AI writing patterns using regex.
Usage:
    humanize.py --input input.txt --output output.txt
Or import humanize_text(text) for programmatic use.
"""
import re
import argparse

def humanize_text(text: str) -> str:
    # Patterns to remove or replace
    patterns = [
        # Hedging phrases
        r"\bAt the end of the day,?\s*",
        r"\b(It is|It's) worth noting,?\s*",
        r"\bIt is important to remember,?\s*",
        r"\bUltimately,?\s*",
        r"\bGenerally speaking,?\s*",
        
        # Stock transitions
        r"\bFirstly,?\s*",
        r"\bSecondly,?\s*",
        r"\bThirdly,?\s*",
        r"\bFinally,?\s*",
        
        # Signposts
        r"\bIn conclusion,?\s*",
        r"\bHowever, it's important to note\b",

        # Performed authenticity
        r"\bI hope this helps\b\.?",
        r"\bFeel free to (reach out|let me know)( if you have questions)?\b\.?",

        # Em dash: replace with comma
        r"—",

        # Passive voice snippets (basic)
        r"\bwas\b",
        r"\bwere\b",
        r"\bhas been\b",
    ]
    result = text
    for pat in patterns:
        result = re.sub(pat, '', result, flags=re.IGNORECASE)
    # Collapse multiple spaces
    result = re.sub(r' {2,}', ' ', result)
    # Clean up spaces before punctuation
    result = re.sub(r' \.', '.', result)
    result = re.sub(r' ,', ',', result)
    return result.strip()

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Humanize AI-generated text')
    parser.add_argument('--input', '-i', required=True, help='Input text file')
    parser.add_argument('--output', '-o', required=True, help='Output text file')
    args = parser.parse_args()
    with open(args.input, 'r') as f:
        src = f.read()
    cleaned = humanize_text(src)
    with open(args.output, 'w') as f:
        f.write(cleaned)


path: tests/test_humanizer.py
content: import unittest
from pathlib import Path
import sys
sys.path.insert(0, str(Path(__file__).parent.parent / 'scripts'))
from humanize import humanize_text

class TestHumanizer(unittest.TestCase):
    def test_hedging_removed(self):
        text = 'At the end of the day, this works.'
        self.assertEqual(humanize_text(text), 'this works.')

    def test_stock_transition(self):
        text = 'Firstly, we check this; secondly, we move on.'
        cleaned = humanize_text(text)
        # Expect 'we check this; we move on.' without 'firstly' and 'secondly'
        self.assertNotIn('Firstly', cleaned)
        self.assertNotIn('secondly', cleaned.lower())

    def test_passive_removed(self):
        text = 'The task was completed successfully.'
        cleaned = humanize_text(text)
        self.assertNotIn('was', cleaned)

    def test_em_dash_replaced(self):
        text = 'This is cool — really cool.'
        cleaned = humanize_text(text)
        self.assertNotIn('—', cleaned)
        # expect comma replacement
        self.assertIn(',', cleaned)

if __name__ == '__main__':
    unittest.main()


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (MEDIUM)