避免AI写作

Installation & Usage

Install the complete skill directory

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.

Claude Cowork — install as a plugin

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.

Full Example

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.

Quick demo

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.

Pattern reference

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.

Native ChatGPT and Codex plugin package

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

.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:

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

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](evals/gate-calibration/2026-10-15.md) 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:

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:

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:

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

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:

It's not just a search index, it's a foundation for trust.

```

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.