Writing Plugin

The writing plugin bundles three prose-quality skills and works in both Claude Code and Codex. Invoke a skill for an editing pass, or ask the agent to use jev-prose while writing each paragraph. The original agent-style and remove-ai-patterns skills remain explicit-trigger only.

Skills

Skill	What It Does
agent-style	21 literature-backed rules for formal technical prose (papers, design docs, proposals, READMEs, commit messages)
remove-ai-patterns	Remove AI-writing patterns (“AI-isms”) from text at any register, with voice profiles and a deterministic detector
jev-prose	Jev pattern checks and up to three guided revisions

Installation

One command installs the three skills into Claude Code, Codex, and most other agents (add -g for every project; -s agent-style for one skill):

npx skills add pchalasani/claude-code-tools -s agent-style -s remove-ai-patterns -s jev-prose

The plugin marketplaces remain available (Claude Code reads .claude-plugin/marketplace.json, marketplace cctools-plugins; Codex reads .agents/plugins/marketplace.json, marketplace cctools-codex-plugins):

Claude Code

claude plugin marketplace add pchalasani/claude-code-tools
claude plugin marketplace update cctools-plugins   # refresh if already added
claude plugin install writing@cctools-plugins

Or run /plugin inside a session for the interactive browser.

Codex

codex plugin marketplace add pchalasani/claude-code-tools
codex plugin marketplace upgrade cctools-codex-plugins  # refresh if already added
codex plugin add writing@cctools-codex-plugins

If you added the marketplace before this plugin was published, the upgrade step is what refreshes the cached snapshot so the plugin shows up.

The original skills are self-contained; their deterministic detector needs Node.js. Jev checks require the separate CLI and backend setup below.

Jev feedback while writing

Install the CLI from a checkout of this repository:

uv tool install ./packages/jev-prose
jev-prose install-skill --target both

The second command is an alternative to installing the writing plugin: it places the same skill in both agents’ global skill directories. New sessions can use it from any project.

Configure CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN, or use an existing sysone account configuration and Wrangler login. Jev uses AI Gateway credit. For TypeSafe directly, use --backend typesafe and TYPESAFE_API_KEY.

jev-prose check paragraph.txt --profile general > findings.json
jev-prose check paper.txt --profile formal --format text

The persistent bank has 118 narrow questions: 95 general, 117 with formal preferences, and 118 with the opt-in strict profile. Requests batch questions against the same prose. Output includes each probability and rewrite guidance for findings at or above the default 0.90 threshold. These are editorial flags, not proof of AI authorship or calibrated probabilities of bad writing.

Ask: “Use jev-prose while writing each paragraph; preserve the facts and revise up to three times.” The skill makes an initial check and at most three revisions, checking the last revision too. It stops on clean output, unhelpful or repeated feedback, errors, or the limit, and discloses remaining findings. No automatic per-keystroke hook is installed. The agent must not invent facts or delete necessary qualifications just to get a passing score.

Exit 0 means a complete check with no findings; exit 1 means findings; exit 2 means failure. Require ran: true, ok: true, and equal answered/expected counts before treating a result as valid. Inputs are sent to the chosen backend. The CLI leaves files unchanged and supports a custom bank and compatible endpoint.

See the CLI guide for setup, source attribution, evaluation evidence, and limitations.

Original writing skills

The skills are complementary and deliberately kept apart:

• agent-style is a clarity and composition ruleset for formal technical prose: passive voice, needless words, claim calibration, parallel structure, stress position, and a set of field-observed rules about LLM habits (bullet overuse, dash overuse, summary closers, and so on). It is based on The Elements of Agent Style (CC BY 4.0).
• remove-ai-patterns de-AIs text of any voice: it applies the avoid-ai-writing catalog (MIT, by Conor Bronsdon) of AI-writing tells, supports voice profiles (casual / professional / technical / warm / blunt), and ships a self-contained Node.js detector for machine-checkable audits.

Pick one as the final gate on a given document; interleaving passes of both tends to churn the same sentences back and forth.

How to Use

Usage is the same in Claude Code and Codex: ask for a pass by name, in natural language.

“Apply agent-style to this design doc.”

“De-AI this blog post with remove-ai-patterns, technical voice, and iterate until the detector is clean.”

“Run a detect-only audit of README.md.”

remove-ai-patterns supports three modes (defined in its vendored catalog): detect-only (report findings, change nothing), edit-in-place (minimal rewrites at flagged spans, meaning preserved), and iterate-to-convergence (revise, re-detect, repeat until clean). agent-style keeps its 21 compact rules in the SKILL.md itself and the full rule bodies (BAD/GOOD pairs, rationale) in a vendored references/RULES.md.

As an acceptance gate in a workflow

A skill is most useful as the acceptance criterion of a larger task: the agent keeps editing until the prose gate passes. Pick ONE skill as the final gate (interleaving both on the same document churns the same sentences, per the two-lanes note above); if you want both to weigh in, run one as a single up-front pass and the other as the looping gate. Paired with the dynamic-workflow plugin, the gate becomes an automatic loop. Just describe it:

Tell Claude Code

“Set up a dynamic workflow to draft this blog post. Do one agent-style pass first, then loop on remove-ai-patterns as the acceptance gate: re-run the detector after each revision and stop when it returns a scored result (not UNSCORED) with no issues, or you have completed 2 passes (the skill’s own iterate cap).”

Simpler, without a workflow, you can name the gate inline on any writing task:

Tell Claude Code

“Write the release notes from this changelog, then de-AI them with remove-ai-patterns: iterate until the detector returns a scored result with no issues, or you have completed 2 passes.”

The deterministic detector (below) is what lets such a loop terminate on its own. Its convergence rule, matching the upstream skill, is to repeat until a scored result has no issues or the cap of 2 passes is reached (a rewrite plus one corrective pass). A finding that cannot be removed without changing intended content simply survives to the cap, so the loop still ends; it does not use a separate “score stopped improving” criterion, which could stop before that corrective pass.

The deterministic detector

remove-ai-patterns includes a JSON-emitting detector that needs only a node binary. Resolve it by the skill’s absolute path (the command runs from your working directory, so a bare relative path fails). Set that directory once, then reuse it:

Claude Code

SKILL_DIR="${CLAUDE_PLUGIN_ROOT}/skills/remove-ai-patterns"
node "$SKILL_DIR/scripts/detect.js" FILE

# technical documentation: skip the title-case-header check (see below)
node "$SKILL_DIR/scripts/detect.js" FILE technical

Codex

${CLAUDE_PLUGIN_ROOT} is unset under Codex, so use the absolute path of the installed skill directory. The agent already knows it from loading the skill; it lives under the Codex plugin cache and ends in skills/remove-ai-patterns (the plugin root is the writing plugin, so there is no extra plugins/writing segment). Discover it if unsure:

SKILL_DIR="$(dirname "$(find "$HOME/.codex" -path '*/skills/remove-ai-patterns/scripts/detect.js' | head -1)")/.."
node "$SKILL_DIR/scripts/detect.js" FILE
node "$SKILL_DIR/scripts/detect.js" FILE technical

The optional second argument is the context mode (general (default), technical, marketing, personal). In this detector, technical has one concrete effect: it skips the title-case-header check, because Title Case section headings are legitimate in technical docs. It does not broadly relax vocabulary checks; the wider technical-prose exceptions (words like robust or leverage) live in the upstream skill’s prose rules that the agent applies when rewriting, not in the detector.

The detector reports an overall score, a label, a document_classification, and per-issue findings with severities and suggestions. For “iterate until clean” requests the agent repeats revise → detect using the same convergence rule as above: stop when a scored result has no issues, or at the 2-pass cap. One caveat: on empty, very short (< ~10 words), or very long (> 10,000 words) input the detector returns document_classification: "UNSCORED" with no issues, which is a refused scan rather than a clean document, so the loop must require a scored result and split or trim over-long files.

Updating the vendored catalogs

Both skills derive from third-party GitHub repos, and the plugin vendors a pinned snapshot of each (rule bodies, pattern catalog, detector) rather than fetching at install or run time. That makes the skills work offline and behave identically on every machine. The exact upstream commit is recorded next to the vendored content:

• plugins/writing/skills/agent-style/references/UPSTREAM-PIN
• plugins/writing/skills/remove-ai-patterns/upstream/UPSTREAM-PIN

As a user, you never touch upstream directly; you pick up refreshed catalogs by updating the marketplace and reinstalling the plugin:

# Claude Code
claude plugin marketplace update cctools-plugins
claude plugin install writing@cctools-plugins

# Codex
codex plugin marketplace upgrade cctools-codex-plugins
codex plugin add writing@cctools-codex-plugins

As a maintainer (or in your own fork), refresh the snapshots from the upstream repos with:

plugins/writing/scripts/update-upstream.sh

The script shallow-clones both upstreams, copies the vendored files, and rewrites the UPSTREAM-PIN files. It commits nothing: review the diff before committing, because freshly fetched rule text is third-party input (check that the changes are writing-rule content, not new tool invocations or scope changes). Upstream licenses (CC BY 4.0 and MIT) ship alongside the vendored files, with attribution in references/NOTICE.md.