conorbronsdon/avoid-ai-writing

avoid-ai-writing

Audit & rewrite content to remove AI writing patterns. A practical skill for any AI agent. Supports detect-only and edit-in-place modes, plus voice profiles.

A portable writing skill for Claude Code, Codex, OpenClaw, Hermes, and any other agentskills.io-compatible agent. Audits and rewrites content to remove AI writing patterns ("AI-isms").

The rules and bundled detector are calibrated for English. See community language adaptations for independently maintained versions in other languages.

Three modes:

• Rewrite (default) — flags AI patterns, applies up to two editing passes, verifies the result when possible, and returns one final version.
• Detect — flags AI patterns without rewriting. Shows which flags are real problems vs. judgment calls. Useful when patterns might be intentional, when auditing content you don't want altered, or when you just want a quick scan.
• Edit — edits a prose file in place (via the Edit tool) with minimal, targeted changes, preserving passages that are already human. Source code, configuration, and generated data are refused because prose rewrites can corrupt structured content. Returns an edits-made + verification report, not the full file.

Use --iterate 1|2 to set the editing-pass ceiling. --iterate 1 allows the initial rewrite only. --iterate 2 uses the default maximum of an initial rewrite plus one correction or preservation repair, and stops early when no justified in-scope edit remains. Checks do not consume a pass, but any change they prompt does. The skill reports how many editing passes it used and any intentional, protected, or unresolved finding.

An optional voice profile (casual / professional / technical / warm / blunt) sets how the prose should sound, independent of the audience context profile.

The glossary defines the terms these docs use: word tiers, severity tiers, modes, profiles, and detector options.

• Quick demo
• Why a skill, not just a prompt
• Installation & Usage
  • Install the complete skill directory
  • Claude Code
  • Claude Cowork — install as a plugin
  • OpenClaw
  • Cursor
  • Hermes
  • OpenAI Codex
  • Native ChatGPT and Codex plugin package
  • Other agents
  • Triggering the skill
• Pattern reference
  • Content Patterns
  • Language Patterns
  • Structure Patterns
  • Communication Patterns
  • Meta Patterns
  • Structural Detection (v3.4)
  • AI-tool fingerprints & later additions (v3.5–3.8)
  • Conversational-register patterns (v3.15)
  • Share-post framing (v3.20)
  • Narrated candor (v3.21)
  • Unnecessary hyphenation (v3.24)
• Full Example
• Run the detector
  • Score a file or piped text from the command line
  • Gate prose in GitHub Actions or pre-commit
  • Use the detector over MCP
• House style is a different job
• More from me
• Credits
• Community / Multilingual
• Disclaimer
• License

Input:

Certainly! Acme Analytics, a vibrant startup nestled in the heart of Boulder's thriving tech ecosystem, has secured $40M in Series B funding — marking a watershed moment for the observability landscape. The platform serves as a unified hub, featuring real-time dashboards, boasting sub-second queries, and presenting a seamless integration layer. Moreover, experts believe Acme is poised to disrupt the market. In conclusion, the future looks bright!

Final rewrite:

Acme Analytics, a Boulder-based startup, raised a $40M Series B. Its observability platform has real-time dashboards, runs queries in under a second, and includes an integration layer.

Verification: One editing pass. Review found no further justified in-scope edit; no deterministic preservation check ran in this prose-only demo.

What it caught: the chatbot opener ("Certainly!"), promotional modifiers, inflated significance, roundabout verbs, vague attribution, and the generic conclusion. The rewrite keeps the funding, location, and three product capabilities. It removes the unsupported market prediction without inventing an investor or an integration mechanism.

A one-shot "make this sound human" prompt catches the obvious stuff. This skill is different:

• Single final rewrite — completes its audit, correction, and available verification before returning one full version. A short change summary follows when useful; a detailed audit remains available on request without adding a competing draft.
• Two-pass editing — review can catch patterns that survive the first edit, while one shared limit covers both corrective edits and preservation repairs.
• Surface-aware delivery — checks how the destination renders single newlines before returning prose, unwraps accidental hard-wrapped paragraphs only when those breaks would show, and preserves intentional structure such as lists, poetry, code, and addresses.
• 112-entry word replacement table across 3 tiers + 10 Tier 3 phrases — not vibes-based. Every flagged word has a specific, plainer alternative. "Leverage" → "use." "Commence" → "start." Tier 1 matches flag unless a listed exception applies, Tier 2 words flag when they cluster, Tier 3 words flag only at high density. Tier 1 itself splits into 1A frequency markers (delve, tapestry) and 1B clarity edits (in order to, utilize) — same fix, but only 1A is evidence about how a passage was produced, and 1B is weighted lower so a wordiness fix cannot push a document toward an AI classification. Tier 3 phrases (multi-word boilerplate like "the integration of," "decentralized compute") flag on per-phrase repetition or when 3+ distinct phrases stack in one piece — the LLM-self-varies-boilerplate shape.
• 74 pattern categories — representative examples below, each with before/after. Includes structural detection (hashtag stuffing, bare-NP bullet lists, hedge-stacked predictions), AI-tool fingerprints (placeholders, citation markup, UTM params), rhythm/uniformity checks, conversational-register tells, and writer-side tests. The full catalog lives in references/patterns.md; this count is enforced against it in CI.
• Detect mode — flag patterns without rewriting. See which flags are real problems vs. judgment calls. Useful when patterns might be intentional or you're auditing content you don't want altered.
• Works across platforms — a directory-based skill runs in Claude Code, Cowork (as a plugin), OpenClaw, Cursor (as a ported rule), and other directory-aware agents. See the install paths below.

Use the plugin install below or clone the repository into your agent's skills directory. Keep SKILL.md with references/patterns.md: the entry file loads the catalog before auditing. The bundled scripts/, detector/, and examples/ provide optional mechanical verification.

For a single-file rules field, use dist/avoid-ai-writing.md (about 138 KB). It includes every rule and profile, with manual fallbacks for commands unavailable outside the bundle. Some rules and instructions fields hold far less than that, so check the size limits under Other agents before pasting. Do not copy the slim entry file alone. Older installers that fetch only root SKILL.md omit its required reference; use a directory install instead.

Option 1: Clone into skills directory

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

Then invoke it with /avoid-ai-writing <your text>.

Option 2: Copy a self-contained file

Download dist/avoid-ai-writing.md and place it in any directory that Claude Code can read. Reference it in your CLAUDE.md:

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

Option 3: Use as a slash command

Optional alias. Claude Code names a command after its file, so use a different name from avoid-ai-writing. If you've done Option 1, the skill already answers to /avoid-ai-writing and a command file with the same name would collide with it. Create a command file (e.g., ~/.claude/commands/clean-ai-writing.md):

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

$ARGUMENTS

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

Then use /clean-ai-writing <your text> in Claude Code.

Cowork loads skills only from installed plugins — it doesn't scan ~/.claude/skills/, so a bare clone (the Claude Code steps above) won't be discovered there. This repo doubles as a single-plugin marketplace, so install it as a plugin instead:

/plugin marketplace add conorbronsdon/avoid-ai-writing
/plugin install avoid-ai-writing@conorbronsdon-skills
/reload-plugins   # or restart the session, to activate the skill

In the Cowork desktop app, do the same from Customize → Plugins → Add marketplace from GitHub (conorbronsdon/avoid-ai-writing), then install avoid-ai-writing. The skill auto-triggers from phrases like "remove AI-isms." New releases arrive when the plugin's version is bumped — run /plugin marketplace update to pull them.

The same plugin install works in Claude Code if you'd rather have a versioned, updatable plugin than the file clone above.

Prefer not to install a plugin? Copy dist/avoid-ai-writing.md into a folder connected to your Cowork session and tell the agent to follow ./avoid-ai-writing.md — works as a one-off, no auto-trigger.

Option 1: Install from ClawHub

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

Drop the ported rule into your project's .cursor/rules/:

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

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.

Drop the skill into Hermes's skills directory — it then appears automatically as /avoid-ai-writing, no registration needed:

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

Codex reads Agent Skills in the same SKILL.md format. Put it in .agents/skills/ at the repo root, or ~/.agents/skills/ to use it across all your projects:

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

Published in the OpenAI Plugins Directory; install it there for ChatGPT or Codex.

The plugin package keeps the canonical SKILL.md as its editorial authority and provides seven focused Skills:

• avoid-ai-writing — uses the canonical audit and rewrite instructions
• avoid-ai-writing-router — routes mixed and multi-stage requests
• ai-writing-detector — runs the bundled deterministic detector
• voice-preserving-rewriter — rewrites returned text while retaining voice
• file-edit-in-place — edits only explicitly named files
• preservation-verifier — checks meaning and constraints before and after a rewrite
• false-positive-reviewer — reviews detector findings that need context

From a cloned checkout, build and validate the package with:

python3 scripts/package-openai-plugin.py . /tmp/avoid-ai-writing.zip --json
python3 scripts/validate-openai-plugin.py . --json

Use the destination below for your tool. Measure the downloaded file with wc -c dist/avoid-ai-writing.md for its exact UTF-8 byte count before comparing byte limits; character limits count characters instead.

For a Custom GPT Knowledge upload, add a short instruction directing the GPT to consult avoid-ai-writing.md when auditing or rewriting prose. Knowledge files supply reference material; uploading one alone does not activate the skill. Test the GPT in Preview with an example from this README before relying on it (GPT configuration docs).

Once installed, ask your assistant to clean up AI writing:

• "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"

In rewrite mode (default), the skill completes its review and available verification before returning the rewritten text exactly once:

1. Final rewrite — the verified or honestly qualified final version
2. Changes — a short summary when edits were made and the summary is useful
3. Verification — editing passes used, checks that ran, stop reason, and any intentional, protected, source-blocked, or unresolved findings

Ask for a detailed or exhaustive audit to add quoted findings before the final rewrite. The response still contains one full version. Clean input can be returned unchanged with zero editing passes.

In detect mode, the skill returns two sections:

1. Issues found — every AI-ism identified, grouped by severity (P0/P1/P2)
2. Assessment — which flags are clear problems vs. patterns that may be intentional or effective in context

Trigger detect mode with: "detect," "flag only," "audit only," "just flag," "scan," or similar.

Representative examples from the catalog — not the exhaustive list (that's references/patterns.md). The skill's human-facing prose catalog and the detector engine use different counts on purpose: the engine implements 54 type categories because it splits the vocabulary tiers and adds stylometric/fingerprint signals (punctuation distribution, function-word entropy, bypass-trick detection) that work as math over a document rather than as a rule you'd look up. The two are mapped in detector/CATEGORIES.md; don't "fix" one count to match the other.

Added in v3.4 to catch LLM output that sidesteps the vocabulary tables by substituting synonyms but still leans on structural shapes detectors can identify. Crypto/web3/AI-infra content is where these patterns concentrate most heavily, but the rules generalize to any social-length post.

Added after a real-world exchange in which a maintainer called out an assisted-sounding GitHub issue reply with "I prefer to talk human to human." Both are judgment calls rather than regex-detectable (an ordinary human paragraph and an AI-generated one can look structurally identical; the tell is the register and the redundant context, not a fixed shape) — see the detector/CATEGORIES.md §C note for why a first attempt at a wall-of-text detector was reverted.

Two writer-side tests round out the catalog (judgment checks, not auto-detected): paragraph-reshuffle immunity (can you swap two body paragraphs without breaking the piece?) and the treadmill effect ("what's actually new in this paragraph?").

Before (AI-generated):

Certainly! Here's a comprehensive overview of Acme's Series B.

Acme Analytics, a vibrant startup nestled in the heart of Boulder's thriving tech ecosystem, has secured $40M in Series B funding — marking a watershed moment for the company and the observability landscape at large. The round was led by Sequoia, with participation from Andreessen Horowitz, Y Combinator, and Index Ventures, underscoring the robust investor confidence in Acme's vision.

The platform serves as a unified hub for engineering teams, featuring real-time dashboards, boasting sub-second query performance, and presenting a seamless integration layer. It's not just another monitoring tool — it's a paradigm shift in how organizations navigate complex distributed systems. Experts believe Acme is poised to disrupt the $15B observability market. Studies show that companies utilizing comprehensive monitoring solutions can ascertain issues 40% faster.

• 🚀 Performance: The platform streamlines incident response, empowering engineers to resolve issues faster.
• 💡 Scale: Acme fosters collaboration across teams, from frontend developers to SRE practitioners to platform builders to infrastructure engineers.
• ✅ Adoption: Customer adoption continues to accelerate, reflecting broader industry trends.

Moreover, Acme's approach showcases the potential of modern observability — symbolizing a shift toward proactive monitoring, reflecting years of R&D investment, and highlighting the intricate interplay between data collection and actionable intelligence. Despite challenges common in the crowded monitoring space, Acme continues to thrive. In order to fully capitalize on this momentum, the company plans to expand its go-to-market endeavors.

In conclusion, the future looks bright for Acme Analytics. Only time will tell how this game-changer will reshape the observability paradigm. Feel free to reach out if you'd like more details!

After (cleaned up):

Acme Analytics, a Boulder-based startup, raised a $40M Series B led by Sequoia, with participation from Andreessen Horowitz, Y Combinator, and Index Ventures.

Its observability platform gives engineering teams real-time dashboards, queries that run in under a second, and an integration layer. The platform helps engineers resolve incidents faster and supports collaboration across frontend, SRE, platform, and infrastructure teams. Customer adoption is accelerating. Acme has invested in R&D for years and plans to expand its go-to-market work in a crowded monitoring market.

Claims needing sources: The input attributes a prediction about a $15B market to unnamed experts and a 40% improvement in issue identification to unspecified studies. Verify those sources before publishing the claims. The rewrite leaves them out; it does not replace them with invented benchmarks, customers, or plans. The product and adoption statements above also remain supplied claims, not independently verified facts.

What the skill caught: chatbot framing, promotional modifiers, inflated significance, roundabout verbs, repeated role synonyms, empty contrast, list decoration, vague attribution, filler, and generic closing language. The rewrite preserves the named investors and supplied capabilities, consolidates the team list, and flags the unsupported market and study claims for verification.

That's 35+ AI tells.

The skill ships a deterministic, zero-dependency detection engine in detector/ — the same engine the rules above describe, as runnable code. It works in Node (>=18) and the browser with no build step.

It's also the single source of the numeric score: the skill itself (and detect mode) report which patterns are present and how severe (P0/P1/P2), and the engine is what turns those into one computed 0–100 score. There's deliberately no second, prose-estimated score in SKILL.md — one scorer, not two.

npm install avoid-ai-writing-detector

The npm package includes the detector runtime and CLI entry points, but not the repository's scripts/ utilities. Clone the repository to run those scripts.

const AIDetector = require("avoid-ai-writing-detector");
const { score, label, issues } = AIDetector.analyzeText("Your text here…");
console.log(score, label, issues.length);

The package also ships a zero-dependency CLI:

npx --package avoid-ai-writing-detector avoid-ai-writing draft.md
cat draft.md | npx --package avoid-ai-writing-detector avoid-ai-writing --context technical

After a global install (npm install -g avoid-ai-writing-detector) the command is available as avoid-ai-writing directly.

It prints the complete analyzeText() result as JSON and exits 0; usage and I/O errors go to stderr with exit code 2. Run avoid-ai-writing --help for the --context and --source-mode options.

The repository also ships a deterministic gate that fails on finding count per file, not the composite 0–100 score. That keeps CI policy independent of score recalibration work such as #70.

View Avoid AI Writing Gate on the GitHub Marketplace, or add it directly to a workflow:

# .github/workflows/prose.yml
steps:
  - uses: actions/checkout@v7
  - id: gate
    uses: conorbronsdon/avoid-ai-writing@v3.36.0
    with:
      glob: "**/*.md"
      threshold: "6"
      context: technical

The example pins the release tag. For stricter supply-chain controls, pin uses: to the full commit SHA for that release.

Step outputs and the gate CLI's --json flag require v3.36.0 or later. On v3.35.0 and earlier, steps.gate.outputs.* resolves to empty strings.

The Action exposes step outputs via $GITHUB_OUTPUT:

• pass: 'true' when all scanned files are within threshold; 'false' on a threshold failure or operational error.
• total-findings: total count of deterministic findings across scanned files; unset on an operational error (exit 2).
• failed-files: count of files exceeding the threshold; unset on an operational error (exit 2).

Downstream steps can consume these outputs:

  - name: Report gate summary
    if: always() && steps.gate.outputs.total-findings != ''
    run: |
      echo "Pass: ${{ steps.gate.outputs.pass }}"
      echo "Total findings: ${{ steps.gate.outputs.total-findings }}"
      echo "Failed files: ${{ steps.gate.outputs.failed-files }}"

The underlying avoid-ai-writing-gate CLI also accepts --json to emit structured JSON on stdout:

{
  "schemaVersion": 1,
  "threshold": 6,
  "context": "technical",
  "sourceMode": "rendered-markdown",
  "pass": false,
  "totalFindings": 9,
  "failedFiles": 1,
  "files": [
    { "path": "README.md", "findings": 2, "pass": true, "types": ["em-dash", "tier1"] },
    { "path": "docs/guide.md", "findings": 7, "pass": false, "types": ["hedge-stack", "tier1", "tier2"] }
  ]
}

Top-level fields report schemaVersion, threshold, context, sourceMode, pass (boolean), totalFindings, failedFiles, and files (preserving scan order). Each file item reports path, findings, pass, and sorted distinct detector types. When no files match the input or glob, files is empty with pass: true.

threshold is the maximum number of deterministic findings allowed in each file. The shipped default is 6. The dated gate calibration records the measured rejection counts, per-register limits and exact detector/corpus revision under the Action's technical + rendered-markdown settings. Set threshold: "0" explicitly when a project intentionally wants a strict zero-findings policy. This is a writing-quality baseline, not an authorship classifier calibration.

The default context is technical, and Markdown is analyzed with rendered-markdown source masking.

Pre-commit users can install the repository hook:

repos:
  - repo: https://github.com/conorbronsdon/avoid-ai-writing
    rev: main
    hooks:
      - id: avoid-ai-writing

Pin rev to a release tag or commit SHA in shared repositories. The hook scans staged .md / .mdx files with the same 6-findings corpus-backed default. Use args to override the threshold, context, or source mode:

      - id: avoid-ai-writing
        args: ["--threshold", "0", "--context", "technical", "--source-mode", "plain", "--"]

Pre-commit replaces the hook's default args: ["--"] when you provide args. End an overriding list with "--" to protect filenames that begin with a dash. The entry keeps its defaults; later options in args take precedence.

The gate only detects. Preservation validation still requires an original and a rewritten file and remains a separate command:

node detector/validate.js before.md after.md

When working from a cloned checkout instead of the published npm package:

npm test          # run the detector's fixtures (no deps to install)

const AIDetector = require("./detector/patterns.js");
const { score, label, issues } = AIDetector.analyzeText("Your text here…");

When the input is a Markdown source file, pass { sourceMode: "rendered-markdown" } to exclude initial YAML frontmatter and HTML comments from the score while keeping issue offsets aligned with the original file. Plain-text behavior remains the default.

To keep a passage out of the score, such as a specimen of AI prose a page quotes on purpose, wrap it in ignore markers. They work in every source mode and in HTML source:

<!-- avoid-ai-writing:ignore-start -->
It's not just a search index, it's a foundation for trust.
<!-- avoid-ai-writing:ignore-end -->

Each marker must sit on a line of its own. The markers and the text between them are blanked before scoring, and stats.ignoredRegions counts the regions. Markers inside code blocks, HTML <pre> or <code> elements, YAML frontmatter, inline prose, or quotations do nothing. Starts nest, so each needs its own end, and a start with no end runs to the end of the text. The detector reads source text, not rendered HTML, so an HTML-to-text step that drops comments also drops the markers.

See detector/README.md for the full analyzeText API and detector/CATEGORIES.md for the rule ↔ category map that keeps SKILL.md and the engine in sync.

avoid-ai-writing-mcp wraps the published detector as a local stdio MCP server. It exposes two read-only tools: score_text for a compact result and audit_text for the full list of findings, suggestions, statistics, and highlighted sentence regions.

claude mcp add avoid-ai-writing -- npx -y avoid-ai-writing-mcp@0.1.0

The server calls no model and sends no text to a network service. It intentionally has no rewrite tool; rewriting stays in the skill, where the agent can apply the full editorial rules and preservation guardrails. See the MCP repository for configuration examples for other MCP hosts.

The engine also ships a preservation validator. detector/validate.js checks protected content and structure, including code, frontmatter, blockquotes, tables, inline code, URLs, paths, and headings. The default gate also blocks residual pattern growth for compatibility; that quality signal does not prove content damage. Editorial workflows use the advisory policy:

node detector/validate.js --residual-policy warn before.md after.md

Mechanical errors still fail. Warnings and residual findings remain visible for review. A pass does not verify meaning; check facts and claims separately. See the validator API for result fields, availability states, and the unchanged default gate.

Does it pass its own pass? PROOF.md scores this repo's documentation with this repo's detector and publishes the result, including two defects the scan found in our own work. npm run self-scan reproduces it, and CI fails when a document drifts past its budget.

This skill removes AI-writing tells. Enforcing a published style guide is the different job: it doesn't do that, and it ships no style guides of its own. The optional --style input takes a house-style config you supply: a register list the model applies, and a mechanics object whose checkable rules scripts/check-style.js verifies deterministically (quote form and Latin abbreviations gate the exit code; heading case, em-dash rate, and number spelling are advisory). This script requires a cloned checkout. examples/ has the schema. You can skip the input entirely and put your guide in your agent's context alongside a voice profile, as instructions rather than as a checked rule set.

From a cloned checkout, after a rewrite, node scripts/normalize-quotes.js draft.md --reference original.md prints prose marks normalized to the original document's convention; add --write to save it. Explicit --quotes straight|curly overrides inference. It shares the checker's Markdown protection. See the usage and limits.

If you want Google, Microsoft, Red Hat, or Salesforce style checked in CI, Vale already covers that. Its package registry carries Vale-compatible implementations of those four, alongside ports of proselint, write-good, and alex. The four style-guide packages are MIT-licensed, though the guides they implement are not always (see the audit below); the linter ports vary, and proselint's is BSD-3-Clause. The two tools do different jobs and compose: Vale gates a document against a rule set, applying fixes one alert at a time, while this skill rewrites whole passages as you draft.

Paywalled guides (Chicago, APA, MLA, AP) have no machine-readable implementation here or in Vale, and won't get one here. Nothing in this repo could verify that a rewrite is Chicago-compliant, so claiming it would fail the same bar PROOF.md holds every other number to. Passing one of their names to --style bundles nothing; it falls back to the model's own knowledge, and SKILL.md instructs it to say so and to claim no compliance. That is an instruction rather than a checked rule, which is the point: there is nothing here to check it against. The license audit behind that line is public.

I run agents against my own email, money, and publishing, so I build the guardrails first.

Follow me on GitHub for new tools and practical examples from maintaining them.

• What I'm building — public projects across agent skills, MCP servers, creator tools, and Mojo.
• Chain of Thought — conversations with the people shipping AI systems.
• repo-audit — checks whether repository claims are enforced, advisory, or guidance.

Pattern research informed by:

• Pangram Labs AI detection research — structural regularity insights, vocabulary flags from a decoder-only classifier trained on 28M human documents
• Wikipedia's Signs of AI-generated text documentation — the canonical reference for AI writing tells, maintained by Wikipedia editors
• blader/humanizer Claude Code skill
• brandonwise/humanizer — tiered vocabulary system, statistical analysis research (burstiness, sentence length variation, trigram repetition), and rewrite philosophy
• OpenClaw humanizer skill ecosystem — community patterns and vocabulary research

Pull requests get an automated first-pass review from Qodo Merge, free through Qodo's open source program. Thanks to the Qodo team for supporting OSS maintainers.

Authored by Conor Bronsdon · LinkedIn · Chain of Thought podcast

Community-maintained adaptations are linked here for discovery. Their authors own their rules, evidence, releases, and support; a link does not mean this repository maintains or validates their results.

• avoid-ai-writing-multilingual by Jürgen Kraus — German (SKILL-DE.md), French (SKILL-FR.md), Italian (SKILL-IT.md), Romanian (SKILL-RO.md), and Swedish (SKILL-SV.md) adaptations, grounded in native-language research rather than translated from English.
• evitar-escrita-ia by Mário Rabelo Neto — European Portuguese adaptation with dialect and formal-register guidance. Its vocabulary tables are editorial hypotheses, not corpus measurements.

Built an adaptation? See the language adaptation guidance, then open an issue with the language, dialect, maintainer, evidence, limitations, and link. We can link independent versions without taking over their maintenance.

This is an independent personal project, not affiliated with, sponsored by, or endorsed by any company. All views expressed are my own.

MIT