Skip to content
Back to search

humanize-text-skill

SkillWorks with Claude CodeGitHub

Audit and rewrite Chinese or English content to remove AI tone, then pull it toward a target human voice. Use this skill when asked to remove AI tone, sound human, rewrite naturally, make a draft feel less templated, or match a target voice. Supports detect-only and edit-in-place modes, scene packs, protected spans, and voice profiles.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/lynote-ai--humanize-text-skill/badge.svg)](/listings/lynote-ai--humanize-text-skill)

HTML

<a href="/listings/lynote-ai--humanize-text-skill"><img src="/api/listings/lynote-ai--humanize-text-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone https://github.com/fendouai/humanize-text-skill.git
cd humanize-text-skill
npm test

This repository is usually used as a skill package inside an agent runtime.

- Claude Code: copy `SKILL.md`, `references/`, and `policy/` into `.claude/skills/humanize-text-skill/` - Cursor: use [`cursor-rules/humanize-text-skill.mdc`](./cursor-rules/humanize-text-skill.mdc) - Codex / OpenClaw / Hermes: point the tool at the repo root

ClawHub publish readiness

This repository is prepared for ClawHub upload:

- canonical entry file: `SKILL.md` - runtime support files: `detector/`, `references/`, `policy/` - publish filter: [`.clawhubignore`](./.clawhubignore)

Suggested publish command:

clawhub skill publish . \
  --slug humanize-text-skill \
  --name "humanize-text-skill" \
  --version 0.1.0

`policy/` is a required runtime dependency. If you install the skill manually and omit that directory, `voiceMode` will fail.

Install health check

node -e "const H=require('./detector/patterns.js'); const r=H.analyzeText('值得注意的是,我们打造了一套方案。', { voiceMode: 'casual' }); console.log({ score: r.score, hasVoice: !!r.voice, drift: r.voice && r.voice.drift });"

Expected:

- `score` is greater than `0` - `hasVoice` is `true` - `drift` is a number

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 167 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: humanize-text-skill
  3. description: Audit and rewrite Chinese or English content to remove AI tone, then pull it toward a target human voice. Use this skill when asked to remove AI tone, sound human, rewrite naturally, make a draft feel less templated, or match a target voice. Supports detect-only and edit-in-place modes, scene packs, protected spans, and voice profiles.
  4. version: 0.1.0
  5. compatibility: Any AI coding assistant that supports agentskills.io SKILL.md format (Claude Code, Cursor, VS Code Copilot, Hermes, OpenHands) or OpenClaw. No external tools or APIs required.
  6. metadata:
  7. tags: writing editing voice quality bilingual
  8. agentskills_spec: "1.0"
  9. openclaw:
  10. skillKey: humanize-text-skill
  11. emoji: "\u270D\uFE0F"
  12. homepage: https://github.com/fendouai/humanize-text-skill
  13. ---
  14. # humanize-text-skill
  15. > Subtraction plus addition. First remove AI-shaped prose, then pull the result toward a target human voice.
  16. > This skill is bilingual in behavior, but the documentation and operating contract are English-first.
  17. ## What this skill is and is not
  18. This is a writing-quality tool, not a verdict. The patterns flagged here are statistically more common in LLM output, but humans under deadline pressure, working in a second language, or drafting in an unfamiliar genre can produce the same shapes. Treat the findings as signals, not proof.
  19. ## Modes
  20. - **`rewrite`**: flag AI tone, rewrite the text, and pull toward a target voice if one is set
  21. - **`detect`**: flag issues only, with no rewrite
  22. - **`edit`**: edit a file in place with minimal targeted changes
  23. Every mode runs protected-span detection first so version numbers, commands, paths, errors, quotes, and other anchored facts do not drift.
  24. ## Working Style
  25. Work like an editor, not a slogan filter. The goal is not just to delete AI-looking phrases. The goal is to leave the user with text they can actually send.
  26. Default flow:
  27. 1. fence protected spans first
  28. 2. name the dominant problem
  29. 3. choose the lightest effective move
  30. 4. run one quick residue pass
  31. 5. return something usable for the scene
  32. Default principles:
  33. - fidelity before smoothness
  34. - name the problem before changing the sentence
  35. - use the smallest stable edit that solves it
  36. - do not invent facts, sourcing, or attitude just to sound more human
  37. - be direct in direct scenes and conservative in risky scenes
  38. ## Typical Invocation Shapes
  39. ### 1. Direct skill call
  40. ```text
  41. /humanize-text-skill Please rewrite this so it sounds less like AI:
  42. [paste text]
  43. ```
  44. ### 2. Natural-language request
  45. ```text
  46. Use humanize-text-skill to rewrite this README intro so it sounds natural:
  47. This project serves as a testament to our commitment to innovation...
  48. ```
  49. ### 3. File-based request
  50. ```text
  51. /humanize-text-skill Please humanize the copy in article.md.
  52. ```
  53. ### 4. Detect-only request
  54. ```text
  55. /humanize-text-skill Detect mode: tell me what still sounds AI-generated, but do not rewrite yet.
  56. ```
  57. ### 5. Voice-targeted request
  58. ```text
  59. /humanize-text-skill Rewrite this in a blunt voice for an issue reply.
  60. ```
  61. ### 6. Custom voice calibration
  62. ```text
  63. /humanize-text-skill
  64. Here is a sample of my writing:
  65. [paste 2-3 paragraphs]
  66. Now rewrite this in my voice:
  67. [paste text]
  68. ```
  69. When a user provides a personal sample, treat it as a custom voice profile:
  70. - extract rhythm, sentence-length spread, connector habits, and first-person tendency
  71. - do not copy factual content or opinions from the sample
  72. - do not violate protected spans just to lower `voice.drift`
  73. When the user's request is underspecified, prefer these defaults:
  74. - pasted text -> `rewrite`
  75. - "take a look" or "check this" -> `detect`
  76. - "only touch this file/comment/paragraph" -> `edit`
  77. - README, release note, issue reply, or forum post -> load the matching scene pack
  78. ## What to remove or fix
  79. > The categories below are the human-facing rule catalog. Each `###` entry maps to detector coverage, model judgment, or both. The English description is canonical for the contract; bilingual engine behavior still applies.
  80. ### Tier 1 vocabulary (always flag)
  81. Words and phrases that are dramatically overrepresented in AI text. Replace them on sight. Chinese examples include opener cliches, abstract business jargon, and social-platform sales talk. English examples include `delve`, `tapestry`, `leverage`, `seamless`, `robust`, `comprehensive`, `game-changer`, `serves as`, and `at its core`.
  82. ### Tier 2 vocabulary (flag in clusters)
  83. These words are individually acceptable, but clustering is the signal. In short paragraphs, two or more often means the writing is drifting toward template prose. Keep the best-fit instance and rewrite the rest.
  84. ### Tier 3 vocabulary (flag by density)
  85. Common abstract words should only be flagged when they saturate the document. Replace some of them with specifics such as numbers, concrete actions, names, dates, or examples.
  86. ### Structural anti-patterns (cross-lingual)
  87. Watch for summary closers, mechanical ordering, binary contrast framing, symmetry padding, empty balance, and other structures that sound manufactured rather than written.
  88. ### Translation tone (Chinese-specific)
  89. Chinese drafts can inherit English-thinking structures: stacked passives, long attributive chains, `based on`-style openers, and `through ... to ...` constructions. Rewrite the sentence around natural Chinese syntax instead of patching the surface.
  90. ### Chatbot artifacts
  91. Remove assistant residue entirely: greeting fluff, forced enthusiasm, help-closing lines, over-polite acknowledgments, and reasoning-process narration such as `Let me think step by step`.
  92. ### Significance inflation
  93. Cut claims that overstate the meaning of ordinary events. State what happened and let the reader decide whether it is pivotal.
  94. ### Vague attribution
  95. Phrases like `experts believe` and `research suggests` need a specific source. If there is no source, either cite one or remove the attribution.
  96. ### False-concession structure
  97. Balanced-sounding `while X, Y` or `not X, but Y` framing is often used to sound thoughtful without saying much. Make both sides concrete or choose the stronger point.
  98. ### Promotional language
  99. Remove ad copy, inflated product language, and corporate uplift. If the sentence would sound strange in a normal conversation, flatten it.
  100. ### Social endorsement closers
  101. Phrases such as `worth your time`, `thank me later`, or generic bookmarking prompts usually add no information. Replace them with who the piece is for and why.
  102. ### Hedge-stacked predictions
  103. Modal verbs plus stacked hedges (`could potentially`, `may eventually`) cancel each other out. Keep one hedge when uncertainty is real.
  104. ### Formulaic openers
  105. Avoid generic scene-setting such as `in today's rapidly evolving world`. Lead with the actual news or claim, then add context if needed.
  106. ### Emotional flatline
  107. Statements like `what surprised me most` or `this was deeply meaningful` often name a feeling without earning it. Show the specifics or cut the emotion claim.
  108. ### Novelty inflation
  109. Be suspicious of `nobody is talking about this` framing. Unless novelty is clearly supported, frame the idea as one interpretation rather than a revelation.
  110. ### AI-tool fingerprints (placeholders / citations / UTM)
  111. Strip mechanical artifacts such as unfilled placeholders, leaked chatbot citation markup, and URL parameters tied to chat tools. These are tool residue, not style.
  112. ### Rhythm & uniformity (stylometric)
  113. Even when vocabulary looks fine, drafts can still feel synthetic because the rhythm is too smooth. Watch for sentence-length uniformity, repetitive punctuation behavior, and low variation in grammatical movement.
README.md · README · 262 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. # humanize-text-skill
  3. ### Make AI-written text sound human, not just less AI.
  4. **Bilingual zh/en engine · zero dependencies · detector + rewrite skill + voice pull**
  5. </div>
  6. `humanize-text-skill` is a bilingual writing skill for removing AI-shaped prose and pulling the result toward a target human voice.
  7. It does two jobs:
  8. - **Subtraction**: remove AI-shaped vocabulary, structure, rhythm, and chatbot residue.
  9. - **Addition**: pull the cleaned text toward a target voice such as `casual`, `professional`, or `technical`.
  10. Unlike simple AI-writing detectors, this project is built as a full skill:
  11. - it detects issues
  12. - it decides what is safe to rewrite
  13. - it protects facts, commands, paths, and quoted text
  14. - it shapes the final output for scenes like README intros, release notes, issue replies, and status updates
  15. ## At A Glance
  16. ![humanize-text-skill capability map](./docs/capability-map.svg)
  17. ## Why It Exists
  18. Most tools stop at "less AI." `humanize-text-skill` aims for "sounds like a real person wrote this."
  19. Common targets:
  20. - Chinese filler and black-box jargon such as `值得注意的是`, `赋能`, `闭环`, and `综上所述`
  21. - English AI staples such as `delve into`, `seamless`, `serves as a testament`, and `Let's dive in`
  22. - over-even sentence rhythm
  23. - false significance and vague authority claims
  24. - pasted chatbot residue
  25. ## What It Can Do
  26. - Detect 50 executable issue types across Chinese and English.
  27. - Keep the same concept mapped to the same detector type across both languages where symmetry is intended.
  28. - Route behavior by scene: `chat`, `status`, `docs`, `public-writing`.
  29. - Support three modes: `rewrite`, `detect`, `edit`.
  30. - Protect spans that must not drift: numbers, commands, paths, versions, names, logs, and quotes.
  31. - Compute `voice.drift` separately from `score`, with concrete pull suggestions.
  32. - Document **17 pattern categories** in the skill contract.
  33. - Lock examples and engine behavior with `143 CI checks`.
  34. ## Quick Example
  35. ```bash
  36. node -e "const H=require('./detector/patterns.js'); console.log(H.analyzeText('值得注意的是,我们打造了一套赋能开发者社区的方案,助力企业实现降本增效闭环。综上所述,未来可期!').score)"
  37. ```
  38. ```bash
  39. # expected: 55
  40. ```
  41. ```bash
  42. node -e "const H=require('./detector/patterns.js'); console.log(H.analyzeText('今天把连接池上限从 20 调到 100,504 先压下来了。观察 24 小时,错误率 0.1% 以下就全量。').score)"
  43. ```
  44. ```bash
  45. # expected: 0
  46. ```
  47. ## Validation Snapshot
  48. Current locked examples:
  49. - AI-heavy zh sample: `score = 55`
  50. - human technical zh sample: `score = 0`
  51. - formal text against `casual` voice target: `voice.drift = 71`
  52. - current test suite: `143 CI checks`
  53. ## Install And Use
  54. ```bash
  55. git clone https://github.com/fendouai/humanize-text-skill.git
  56. cd humanize-text-skill
  57. npm test
  58. ```
  59. This repository is usually used as a skill package inside an agent runtime.
  60. - Claude Code: copy `SKILL.md`, `references/`, and `policy/` into `.claude/skills/humanize-text-skill/`
  61. - Cursor: use [`cursor-rules/humanize-text-skill.mdc`](./cursor-rules/humanize-text-skill.mdc)
  62. - Codex / OpenClaw / Hermes: point the tool at the repo root
  63. ### ClawHub publish readiness
  64. This repository is prepared for ClawHub upload:
  65. - canonical entry file: `SKILL.md`
  66. - runtime support files: `detector/`, `references/`, `policy/`
  67. - publish filter: [`.clawhubignore`](./.clawhubignore)
  68. Suggested publish command:
  69. ```bash
  70. clawhub skill publish . \
  71. --slug humanize-text-skill \
  72. --name "humanize-text-skill" \
  73. --version 0.1.0
  74. ```
  75. `policy/` is a required runtime dependency. If you install the skill manually
  76. and omit that directory, `voiceMode` will fail.
  77. ### Install health check
  78. ```bash
  79. node -e "const H=require('./detector/patterns.js'); const r=H.analyzeText('值得注意的是,我们打造了一套方案。', { voiceMode: 'casual' }); console.log({ score: r.score, hasVoice: !!r.voice, drift: r.voice && r.voice.drift });"
  80. ```
  81. Expected:
  82. - `score` is greater than `0`
  83. - `hasVoice` is `true`
  84. - `drift` is a number
  85. ## Common Usage Patterns
  86. In tools like Claude Code, Codex, or other skill-aware agents, people usually use `humanize-text-skill` in one of these ways.
  87. ### 1. Direct skill call
  88. ```text
  89. /humanize-text-skill Please rewrite this so it sounds less like AI:
  90. [paste text]
  91. ```
  92. ### 2. Natural-language request
  93. ```text
  94. Use humanize-text-skill to rewrite this so it sounds more natural:
  95. This project serves as a testament to our team's commitment to innovation.
  96. Moreover, it showcases our pivotal role in the evolving technology landscape.
  97. ```
  98. ### 3. File-based request
  99. ```text
  100. /humanize-text-skill Please humanize the copy in article.md.
  101. ```
  102. ### 4. Detect before rewrite
  103. ```text
  104. /humanize-text-skill Detect mode: show me what still sounds AI-written, but don't rewrite yet.
  105. ```
  106. ### 5. Target a voice or scene
  107. ```text
  108. /humanize-text-skill Rewrite this in a blunt voice for an issue reply.
  109. ```
  110. ```text
  111. /humanize-text-skill Rewrite this README intro in a technical voice.
  112. ```
  113. Practical defaults:
  114. - pasted text usually means `rewrite`
  115. - "check this first" usually means `detect`
  116. - "only touch this file/comment/paragraph" usually means `edit`
  117. - README, release note, forum post, and issue reply requests automatically benefit from scene-pack behavior
  118. ## Voice Calibration
  119. If you want the rewrite to sound more like you, provide a short sample of your own writing and use `voiceMode: custom`.
  120. ```text
  121. /humanize-text-skill
  122. Here's a sample of my writing for voice matching:
  123. [paste 2-3 paragraphs of your own writing]
  124. Now rewrite this in my voice:
  125. [paste draft]
  126. ```
  127. What the skill uses from the sample:
  128. - sentence length and rhythm
  129. - connector preferences
  130. - first-person tendency
  131. - a measurable voice profile, not private identity traits
  132. What it does not do:
  133. - it does not copy your facts or opinions from the sample
  134. - it does not override protected spans
  135. - it does not try to impersonate a real person beyond observable writing style
  136. ## Engine API
  137. ```js
  138. const HumanizeTextSkill = require("./detector/patterns.js");
  139. const result = HumanizeTextSkill.analyzeText("your text", {
  140. contextMode: "general",
  141. sceneMode: "docs",
  142. voiceMode: "casual",
  143. sample: "optional sample",
  144. });
  145. console.log(result.score);
  146. console.log(result.issues);
  147. console.log(result.voice?.drift);
  148. console.log(result.voice?.suggestions);
  149. ```
  150. Important:
  151. - `score` is the only engine score.
  152. - `voice.drift` is a separate dimension.
  153. - `fidelity` is currently enforced in the rule layer, not returned as an engine field.
  154. ## Skill Runtime
  155. ![humanize-text-skill skill architecture](./docs/skill-architecture.svg)
  156. The detector is only one layer. The full skill runtime is:
  157. 1. choose mode: `rewrite`, `detect`, or `edit`
  158. 2. judge scene and scope
  159. 3. protect spans that must not drift
  160. 4. run detector and voice analysis
  161. 5. choose action: rewrite, audit-only, or minimal edit
  162. 6. run a second-pass residue audit
  163. 7. return output in a scene-appropriate shape
  164. See [references/skill-architecture.md](./references/skill-architecture.md) for the full map.
  165. ## Repository Map
  166. - [SKILL.md](./SKILL.md): top-level skill contract
  167. - [detector/](./detector/): executable detector and voice engine
  168. - [references/](./references/): human-readable rules, scene packs, examples, checklists
  169. - [policy/](./policy/): auditable scene/tier/voice policy in TOML
  170. - [evals/](./evals/): benchmark cases, fixtures, voice samples
  171. Good entry points:
  172. - [references/scene-packs.md](./references/scene-packs.md)
  173. - [references/examples.md](./references/examples.md)
  174. - [references/quick-checklist.md](./references/quick-checklist.md)
  175. - [references/voice-contract.md](./references/voice-contract.md)
  176. ## Related Work
  177. `humanize-text-skill` builds on ideas and assets from:
  178. - [conorbronsdon/avoid-ai-writing](https://github.com/conorbronsdon/avoid-ai-writing)
  179. - [MrGeDiao/shuorenhua](https://github.com/MrGeDiao/shuorenhua)
detector/core/normalize.js · Bundled script · 49 lines
  1. /**
  2. * core/normalize — bypass-trick normalization (language-agnostic).
  3. *
  4. * Migrated verbatim from avoid-ai-writing's normalizeText. Strips invisible /
  5. * lookalike chars that humanizer tools inject to defeat exact-string detectors,
  6. * BEFORE pattern matching. Tracks what was stripped so the trinary classifier
  7. * can use "normalization triggered" as a corroborating AI signal.
  8. *
  9. * Unicode ranges sourced from It-s-AI/llm-detection/detection/attacks/.
  10. */
  11. 'use strict';
  12. const CYRILLIC_LOOKALIKES = {
  13. 'а': 'a', 'е': 'e', 'о': 'o', 'р': 'p', 'с': 'c', 'х': 'x',
  14. 'у': 'y', 'к': 'k', 'м': 'm', 'н': 'h', 'в': 'b', 'т': 't',
  15. 'А': 'A', 'Е': 'E', 'О': 'O', 'Р': 'P', 'С': 'C', 'Х': 'X',
  16. 'У': 'Y', 'К': 'K', 'М': 'M', 'Н': 'H', 'В': 'B', 'Т': 'T',
  17. };
  18. const GREEK_LOOKALIKES = { 'ο': 'o', 'Ο': 'O', 'α': 'a', 'Α': 'A', 'ρ': 'p', 'Ρ': 'P' };
  19. const ROLEPLAY_VERBS = /^(?:nods|sighs|laughs|smiles|frowns|shrugs|grins|winks|chuckles|gasps|pauses|thinks|wonders|whispers|shouts|gestures|raises|leans|turns|looks|glances|smirks|blinks|nodding|sighing|laughing|smiling|thinking|gesturing)\b/i;
  20. function normalizeText(text) {
  21. const flags = { zeroWidth: 0, homoglyph: 0, roleplay: 0 };
  22. let out = text;
  23. // 1. Strip zero-width chars (ZWSP U+200B, ZWNJ U+200C, ZWJ U+200D,
  24. // BOM U+FEFF, word joiner U+2060).
  25. out = out.replace(/[​-‍⁠]/g, () => { flags.zeroWidth++; return ''; });
  26. // 2. Swap Cyrillic / Greek Latin-lookalike chars back to Latin.
  27. out = out.replace(/[Ѐ-ӿͰ-Ͽ]/g, (m) => {
  28. const swap = CYRILLIC_LOOKALIKES[m] ?? GREEK_LOOKALIKES[m];
  29. if (swap) { flags.homoglyph++; return swap; }
  30. return m;
  31. });
  32. // 3. Strip *roleplay-action* markers — paired *...* containing an action
  33. // verb anchored to the start of the inner phrase. Markdown **bold** is
  34. // rejected by the lookbehind/lookahead; legitimate *italic* preserved.
  35. out = out.replace(/(?<!\*)\*([^*\n]{1,80}?)\*(?!\*)/gu, (m, inner) => {
  36. if (ROLEPLAY_VERBS.test(inner)) { flags.roleplay++; return ''; }
  37. return m;
  38. });
  39. return { text: out, flags };
  40. }
  41. module.exports = { normalizeText };

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.