Agent skill

Proofread

by plclub in plclub/sf-in-lean

Drive a two-round editing pass over one SFL chapter — round 1 is low-level grammar, punctuation, usage, and markup; round 2 fixes the higher-level flow, ordering, and consistency problems found…

Apache-2.0Auto-check passedWriting & Content

Install Proofread

skills CLI
$ npx skills add plclub/sf-in-lean --skill proofread -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install plclub/sf-in-lean proofread --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/plclub/sf-in-lean.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/proofread .claude/skills/proofread && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
proofread
GitHub stars
160
Token cost
~1.9k tokens
SKILL.md length
1,124 words
Files
1
Skills in repo
1
Repo updated
First seen
Licence
Apache-2.0

At a glance

Drive a two-round editing pass over one SFL chapter — round 1 is low-level grammar, punctuation, usage, and markup; round 2 fixes the higher-level flow, ordering, and consistency problems found…

  • Works in 3 steps: write the round → apply, and hand over → record
  • The author types /proofread [Chapter]
  • SKILL.md covers Phase 1 — write the round, Phase 2 — apply, and hand over, The high-level read (during… and Round 2 — the high-level round, plus 2 more sections
  • Calls python3

What it does

Proofread is an agent skill from plclub/sf-in-lean. Drive a two-round editing pass over one SFL chapter — round 1 is low-level grammar, punctuation, usage, and markup; round 2 fixes the higher-level flow, ordering, and consistency problems found while reading. Each round is a file of anchored edits, applied for the author to review in the editor, then recorded. Use when the author types /proofread [Chapter] or asks for a chapter to be proofread.

Its SKILL.md is about 1.9k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Writing & Content, covering Copy editing and proofreading. The repository describes itself as: Development repo for translating Software Foundations to Lean. The licence is Apache-2.0.

When your agent uses it

  • The author types /proofread [Chapter]
  • Asks for a chapter to be proofread

Example prompts

  • “/proofread”

Requirements

  • Python 3

Workflow steps

3 steps, taken from the step headings in SKILL.md.

  1. write the round
  2. apply, and hand over
  3. record

What it can do on your machine

Read from SKILL.md and the folder at commit 1894c7c. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Proofread loads about 1.9k tokens when it runs. Until then it costs about 102 tokens; SKILL.md has 1,124 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~102
When it runs · the whole SKILL.md, loaded when a task matches
~1.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from plclub/sf-in-lean at commit 1894c7c, republished under its Apache-2.0 licence (© plclub). 1,124 words, ~1,906 tokens.

Download SKILL.mdSave it as .claude/skills/proofread/SKILL.md (or your agent's skills folder).
name
proofread
description
Drive a two-round editing pass over one SFL chapter — round 1 is low-level grammar, punctuation, usage, and markup; round 2 fixes the higher-level flow, ordering, and consistency problems found while reading. Each round is a file of anchored edits, applied for the author to review in the editor, then recorded. Use when the author types /proofread [Chapter] or asks for a chapter to be proofread.
<!-- This file is maintained by Claude (AI-generated). -->

Proofreading a chapter

A full pass is two rounds over the same chapter, each driven through the same machinery: round 1 is the low-level pass (commas, agreement, markup), round 2 the high-level pass (flow, ordering, consistency — the findings of the high-level read). Each round has three phases, split by the one thing you cannot do yourself: the author reviewing the edits in their editor. You run the commands; the author only ever talks to you.

PROOFREADING.md at the repo root is the authority on what to propose — read it in full before phase 1, every time. This skill is only about driving.

Phase 1 — write the round

python3 scripts/proofread.py start [<Chapter>]

It prints the chapter source to proofread and the round file to write, and refuses when the working tree is dirty (a pass starts from a clean branch) or when another round is already in flight. Relay that refusal to the author and stop — do not commit their work for them, and do not reach for --allow-dirty unless they ask.

Then:

  1. Read PROOFREADING.md in full — "Writing a round", the house rules, and the known non-issues.
  2. Read the recorded rejections: python3 scripts/proofread.py ledger. Nothing already declined, covered by a house rule, or listed as a known non-issue may be proposed again.
  3. Read the chapter and write the round to the path start printed: {"file", "chapter", "round", "proposals": [{"id", "cat", "old", "new", "why"}]}, anchored exactly as PROOFREADING.md requires.

Do not edit the chapter yourself — every edit reaches it through the round, so that the author's accept/decline is what the ledger records.

Phase 2 — apply, and hand over

python3 scripts/proofread.py apply

This makes the edits and opens a side-by-side diff in the author's editor — a snapshot of the chapter before the round on one side, the live chapter on the other (code --diff, or Ediff in a running Emacs; PROOFREAD_EDITOR picks, and it follows the session otherwise). The command prints which one it used and how to revert there; relay that rather than assuming VS Code. Anchor errors mean nothing was applied: fix the round file and run it again.

Then end your turn. Tell the author what is in the round (the category counts the command printed, and any pair of edits it flagged as sharing one change block), and ask them to revert what they don't want — the way the command's own output describes for their editor — and to say when they're done. Under Emacs, remind them to save the chapter buffer: record reads the chapter back off disk. Before ending the turn, do the high-level read (next section) and include its findings in the same handover message — it touches no files, so the author can weigh it while reverting low-level edits. Do not poll, do not watch the file, do not run record on their behalf. They may answer in a minute or tomorrow; proofread/state.json remembers the round either way.

The high-level read (during phase 2's wait)

While the author reviews round 1, re-read the chapter as a reader, not a copyeditor: narrative flow and pacing, ideas introduced out of order or used before they're explained, internal inconsistencies (terminology drift, a convention announced then broken, examples that don't match the surrounding prose, prose that misstates what the adjacent proof actually does), heading structure, redundant or missing transitions, dangling references ("this" with no displayed statement), and exercises whose grading or difficulty metadata seems off or missing.

Also run lake build <Vol>.<Ch> and read every linter.sf.* warning it emits — succeeding is not enough. PROOFREADING.md's "Linter warnings" section (under "The high-level round") has the triage rules, especially for exerciseVisibility: it requires a deliberate full-vs-terse visibility call per exercise, not just silencing the warning.

Never fold these findings into round 1 and never edit the chapter while that round is in flight — the author is editing the same file. Report the findings in prose with the phase-2 handover, ordered by position in the chapter, each anchored by section name (and a short quote so the author can search for the spot), with a one-line suggestion where you have one. Say explicitly when a chapter reads fine and the list is short or empty — a clean report is a result, not a failure. These findings become round 2 after round 1 is recorded and committed.

Show full SKILL.md (417 more words)Show less

Round 2 — the high-level round

After record, lake build, and the round-1 commit, run start again (it names the next round file) and turn the high-level findings into a second round through the same three phases. The "low-level only" rule is a round-1 rule; round 2 is exempt by design (see "The high-level round" in PROOFREADING.md). For each finding:

  • If you can see the fix — a heading at the wrong level, a wrong claim about the adjacent proof, an inconsistent variable name, a missing display or grading spec with an obvious sibling to copy — make it an anchored edit, worded so the diff shows the author exactly what changed and the why says why. Structural edits (moving a heading, inserting a block) need anchor text on both sides of the change, or old/new will contain one another.
  • If the fix needs an author decision — a design question, a grading policy, exercise framing — the edit inserts a :::dev "Claude" note at the spot (no urgency keyword, so it stays visible), stating the problem and the plausible options. The note is the deliverable; do not guess at the decision.

Then apply, hand over, and record exactly as in round 1 — and because round 2 can touch code, headings, and {lean} roles, run lake build <Vol>.<Ch> right after apply rather than waiting for phase 3. Findings the author explicitly rejected in the prose report are dropped, not turned into dev notes.

Phase 3 — record

When the author says they're done:

python3 scripts/proofread.py record

It decides kept-vs-declined by reading the chapter back, appends the declines to proofread/ledger.jsonl, and prints the rejection histogram. Then:

  • If a category is flagged as worth a house rule, propose the wording and, if the author agrees, add the row to the house-rules table in PROOFREADING.md. A flagged category means the proposer — you — was working from a rule this book does not hold; the rule is what stops it recurring in every chapter.
  • Report anything record called unclear (the author rewrote that spot themselves, so nothing was recorded and it will come back in a later round).
  • Run lake build <Vol>.<Ch> and offer to commit the chapter, the ledger, and any PROOFREADING.md change together.

Elsewhere in the pass

  • Real content problems — a stale reference, a wrong claim, an inconsistent term — never go in the round. Report them to the author in prose; they need a decision, not a comma.
  • python3 scripts/proofread.py undo reverses an applied round and leaves it for another day, recording nothing. status says what is in flight.

© plclub, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/proofread of plclub/sf-in-lean.

Open the folder on GitHubat commit 1894c7c

Compare with similar skills

Proofread next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Proofread compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Proofread this skillplclub/sf-in-lean160—~1.9kAutomated safety check: PassApache-2.0
User-Facing Text Cleanupguillaumemeyer/watermarks-remover24k—~3.5kAutomated safety check: PassMIT
Story Multi-Perspective Reviewzenstory-ai/oh-story-claudecode7.4k3 repos~3kAutomated safety check: PassMIT
Chinese Text Humanizerop7418/Humanizer-zh19k—~2kAutomated safety check: PassMIT
Korean AI-Text Humanizerepoko77-ai/im-not-ai5.9k1 repos~4.5kAutomated safety check: PassMIT
Natural Japanese Business Writingcoji/natural-japanese1.9k—~2.1kAutomated safety check: PassMIT

Similar skills

  • User-Facing Text Cleanup

    guillaumemeyer/watermarks-remover

    Audits prose for invisible Unicode characters and rewrites it while keeping facts, citations, code and required disclosures unchanged and the writer's voice intact.

    24k GitHub stars~3.5k tokensUpdated 2 days ago
    Writing & ContentAuto-check passed
  • Story Multi-Perspective Review

    zenstory-ai/oh-story-claudecode

    Reviews Chinese web-novel text with several reviewer agents in parallel, falling back to a single-agent pass, and reports structure, character, prose and setting problems with fixes.

    7.4k GitHub starsUsed in 3 repos~3k tokens
    Writing & ContentAuto-check passed
  • Chinese Text Humanizer

    op7418/Humanizer-zh

    Edits Chinese articles, comments and documents to remove filler, repetition and template phrasing while keeping the facts, the level of certainty and the author's voice.

    19k GitHub stars~2k tokensUpdated 15 days ago
    Writing & ContentAuto-check passed
  • Korean AI-Text Humanizer

    epoko77-ai/im-not-ai

    Rewrites Korean text written by AI so it reads like a human wrote it, detecting translationese and other AI patterns while leaving the content untouched.

    5.9k GitHub starsUsed in 1 repo~4.5k tokens
    Writing & ContentAuto-check passed
  • Writes and edits Japanese business documents so they read clearly and naturally, removes AI-sounding phrasing and can score how AI-like a text reads.

    1.9k GitHub stars~2.1k tokensUpdated 1 mo ago
    Writing & ContentAuto-check passed
  • Defensive Writing Editor

    lennney/stop-that-shit

    Cuts defensive disclaimers, stacked hedging and self-protective narration from proposals and summaries, keeping only limits that affect the reader's decision.

    2.5k GitHub starsUsed in 1 repo~1.2k tokens
    Writing & ContentAuto-check passed

Questions about Proofread

What does Proofread do?

Drive a two-round editing pass over one SFL chapter — round 1 is low-level grammar, punctuation, usage, and markup; round 2 fixes the higher-level flow, ordering, and consistency problems found…. Proofread is an agent skill from plclub/sf-in-lean. Drive a two-round editing pass over one SFL chapter — round 1 is low-level grammar, punctuation, usage, and markup; round 2 fixes the higher-level flow, ordering, and consistency problems found while reading.

When should I use Proofread?

Proofread fits situations like: the author types /proofread [Chapter]; asks for a chapter to be proofread.

How do I install Proofread in Claude Code?

Run `npx skills add plclub/sf-in-lean --skill proofread -a claude-code`. Or copy the skill folder (.claude/skills/proofread in plclub/sf-in-lean) into .claude/skills/proofread in your project. Claude Code loads it when a task matches its description.

How do I install Proofread in Codex?

Run `npx skills add plclub/sf-in-lean --skill proofread -a codex`. Or copy the skill folder (.claude/skills/proofread in plclub/sf-in-lean) into .agents/skills/proofread in your project. Codex loads it when a task matches its description.

Can I use Proofread in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add plclub/sf-in-lean --skill proofread -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/proofread, .gemini/skills/proofread, .github/skills/proofread and .opencode/skills/proofread in your project.

What does Proofread need to run?

Going by SKILL.md and its folder, Proofread needs the command-line tools its instructions call (python3). Our summary lists: Python 3.

Does Proofread access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Proofread safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Proofread use?

Proofread is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Proofread use?

About 1.9k tokens (SKILL.md is roughly 7.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Proofread?

Skills that share tags, products or a category with Proofread: User-Facing Text Cleanup (guillaumemeyer/watermarks-remover, 24k stars), Story Multi-Perspective Review (zenstory-ai/oh-story-claudecode, 7.4k stars), Chinese Text Humanizer (op7418/Humanizer-zh, 19k stars) and Korean AI-Text Humanizer (epoko77-ai/im-not-ai, 5.9k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Proofread?

plclub (a GitHub organization) maintains it in plclub/sf-in-lean, which has 160 GitHub stars. The repository was last updated on October 7, 2026.

Source: plclub/sf-in-lean on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.