# Documents and Writing: Office Skills, doc-coauthoring and writing-guidelines

URL: https://developertoolkit.ai/en/ecosystem/skills/document-and-writing-skills/
Description: Install Anthropic's docx, pdf, pptx and xlsx skills, doc-coauthoring, Vercel writing-guidelines and humanizer, and chain them from RFC draft to published deck.

Document and writing skills let a coding agent produce the files and prose around your code. Anthropic's `docx`, `pdf`, `pptx` and `xlsx` create real Office files and PDFs, `doc-coauthoring` runs a three-stage RFC workflow, Vercel's `writing-guidelines` reviews prose, and `humanizer` strips AI tells. None ships with Claude Code, and the Office skills' licence is proprietary.

You ship a release on Friday. Product wants an all-hands deck, the platform team wants a migration RFC, and both come out of your repository's changelog, tickets and design notes. Asking the agent to "make a PowerPoint" without a skill gets you a Python script that half-works, or Markdown with a `.pptx` extension. This page is for developers who want documents from the agent as reliably as code, and tech leads who want one reviewable writing pipeline.

## What a document and writing skill setup gives you

- Which of five skills to reach for, with install commands for Claude Code, Codex and Cursor (tested 2026-09-26, skills CLI 1.7.0)
- A PPTX release deck built from `CHANGELOG.md`, and a workflow from RFC draft through reader testing to a published document
- Copy-paste prompts, a verification checklist, and the traps that make these skills fail quietly

## Which document or writing skill should you use?

The five skills do different jobs. Two of them produce files, one runs a process, and two edit prose.

| Skill | Publisher | What it does | Output | Licence |
| --- | --- | --- | --- | --- |
| `pptx`, `docx`, `xlsx`, `pdf` | Anthropic (`anthropics/skills`) | Create, read and edit PowerPoint, Word, Excel and PDF files with scripts (pptxgenjs, Python libraries, LibreOffice), then validate them | Real `.pptx`, `.docx`, `.xlsx`, `.pdf` files | Proprietary, source-available ("LICENSE.txt has complete terms") |
| `doc-coauthoring` | Anthropic (`anthropics/skills`) | A three-stage workflow for RFCs, specs, PRDs and decision docs: context gathering, section-by-section refinement, reader testing with a fresh model | A Markdown file (or an artifact on claude.ai) | No licence file in its folder; the repository README says "many" of its skills are Apache 2.0 |
| `writing-guidelines` | Vercel Labs (`vercel-labs/agent-skills`) | Reviews docs against Vercel's writing handbook, which it fetches from GitHub on every run | Terse `file:line` findings, no edits | Rules repository `vercel-labs/writing-guidelines`: MIT; `agent-skills` had no root licence file on 2026-09-26 |
| `humanizer` | blader (`blader/humanizer`), v3.1.0 | Detects 26 numbered patterns of AI-sounding prose, based on Wikipedia's "Signs of AI writing", and rewrites them without changing the claims | Rewritten text, or an edited file in file mode | MIT |

**Popularity, as of 2026-09-26.** GitHub stars: `anthropics/skills` 178.4k (the whole repository) and `blader/humanizer` 52k. All-time skills.sh installs from the third-party `LinklyAI/best-skills` snapshot of 2026-09-26, a secondary source (re-read skills.sh before you quote them): `doc-coauthoring` 86,463, `writing-guidelines` 75,985.

### How to pick a writing skill for the job

| If you need to… | Use | Why this one |
| --- | --- | --- |
| hand a stakeholder a deck, a Word document or a spreadsheet | `pptx`, `docx` or `xlsx` | They produce valid files and check them with a validator and a render, which a bare prompt does not |
| extract tables from a PDF, fill a form, merge or split | `pdf` | It scripts the job with PDF libraries instead of guessing at text |
| write an RFC, design doc or decision record | `doc-coauthoring` | It interviews you before drafting and tests the result on a model that has not seen your conversation |
| check docs against a written style guide | `writing-guidelines`, or your own guide (see traps) | It reports findings by line and changes nothing |
| strip "reads like ChatGPT" patterns from release notes or a README | `humanizer` | It keeps facts, code, commands and YAML unchanged and checks its own rewrite for added or dropped claims |

For deeper anti-slop tooling with deterministic scanners and a published eval, see [anti-slop writing skills](/en/ecosystem/skills/unslop/). For product, marketing and knowledge-work skills, see [skills for product, marketing and knowledge work](/en/ecosystem/skills/top-skills-business/).

## How do you install the document and writing skills?

On claude.ai and the Claude API the four document skills are pre-built. Anthropic's docs say they "are not available in Claude Code", so every coding agent needs an explicit install. Install the skills for the documents you produce, not the whole catalogue.

**Claude Code**

```bash
# Office and PDF skills: the document-skills plugin holds exactly docx, pdf, pptx, xlsx
claude plugin marketplace add anthropics/skills
claude plugin install document-skills@anthropic-agent-skills

# doc-coauthoring alone (the example-skills plugin would add 11 more skills)
npx skills add anthropics/skills --skill doc-coauthoring --agent claude-code -y

# Writing review and de-slopping
npx skills add vercel-labs/agent-skills --skill writing-guidelines --agent claude-code -y
claude plugin marketplace add blader/humanizer
claude plugin install humanizer@humanizer
```

Plugin skills are namespaced: `/document-skills:pptx`, `/humanizer:humanizer`. You rarely need the command, because the skill fires when you mention a deck, slides or a `.pptx` file. The humanizer plugin needs Claude Code 2.1.142 or later. If `anthropic-agent-skills` already appears in `claude plugin marketplace list`, skip the `marketplace add` line.

**Codex**

```bash
# Project scope: files land in .agents/skills/
npx skills add anthropics/skills --skill pptx docx xlsx pdf doc-coauthoring --agent codex -y
npx skills add vercel-labs/agent-skills --skill writing-guidelines --agent codex -y
npx skills add blader/humanizer --agent codex -y
```

Invoke a skill by name with `$pptx` or `$humanizer`, and type `/skills` to see what loaded. Codex 0.157.1 can also read Anthropic's marketplace (`codex plugin marketplace add anthropics/skills`, then `codex plugin add document-skills@anthropic-agent-skills`). In our test on 2026-09-26 (Codex 0.157.1, `codex plugin add document-skills@anthropic-agent-skills`, then counting the `SKILL.md` files under `~/.codex/plugins/cache`), that install copied all 20 skill folders of the repository into the plugin cache, not only the four, so use the skills CLI to get exactly the skills you name.

**Cursor**

```bash
npx skills add anthropics/skills --skill pptx docx xlsx pdf doc-coauthoring --agent cursor -y
npx skills add vercel-labs/agent-skills --skill writing-guidelines --agent cursor -y
npx skills add blader/humanizer --agent cursor -y
```

The skills CLI writes Cursor's project skills to `.agents/skills/`, the same folder Codex reads, so one install serves both. Ask for a skill by name in Agent chat ("use the pptx skill").

One command can target all three agents: `--agent claude-code codex cursor` writes the skill to `.agents/skills/` and adds a symlink under `.claude/skills/` for Claude Code (skills CLI 1.7.0, tested 2026-09-26). Commit `skills-lock.json` and the MIT-licensed `humanizer` folder so the team runs the same versions, but add `.agents/skills/{docx,pdf,pptx,xlsx}/` to `.gitignore`: those four are proprietary, and committing them copies Anthropic's files into your repository. Treat `doc-coauthoring` like the Office skills (gitignore it and restore it from the lock file) until Anthropic adds a licence file to it. Teammates restore everything from the lock file with `npx skills experimental_install` ("restore from skills-lock.json", skills CLI 1.7.0). The CLI ends every install with "Review skills before use; they run with full agent permissions"; [skill supply-chain security](/en/ecosystem/skills/skill-security/) has the checklist, and [installing and managing skills](/en/ecosystem/skills/installing-managing/) covers updates and removal.

## How do you generate a PPTX release deck from a changelog?

The `pptx` skill builds a new deck by writing a pptxgenjs script, then checks the file three ways: a schema and structure validator, a text dump, and rendered slide images. The example turns the latest release in `CHANGELOG.md` into an eight-slide deck.

1. **Install the local dependencies.** Anthropic's sandbox has them preinstalled; your machine does not. In the terminal:

    ```bash
    npm install --save-dev pptxgenjs          # 4.0.1 on 2026-09-26
    python3 -m venv .venv && . .venv/bin/activate   # keeps pip off the system Python
    pip install "markitdown[pptx]" defusedxml lxml Pillow
    # plus LibreOffice (soffice) and Poppler (pdftoppm) from your OS package manager
    ```

    Without LibreOffice and Poppler the deck still builds, but the agent cannot render slides to images, so visual QA is skipped.

2. **Give the agent a source of truth and a slide budget.** Paste the prompt below into Claude Code, Codex or Cursor. It names the changelog section, the audience, the output path and the checks, so the agent cannot fill slides with invented features.

3. **Let the skill write and run the generator.** Expect a script such as `scripts/release-deck.js` that sets `pres.layout` first, writes colours as six-digit hex without `#`, and puts speaker notes in `slide.addNotes()`. Those are three of the pptxgenjs traps the skill lists. The first two silently corrupt the file or push shapes off the slide; the third keeps notes out of the visible slide.

4. **Check the validator result.** The skill runs its validator after every build. A clean run ends with:

    ```text
    All validations PASSED!
    ```

    A failure names the part and the fix, for example a stacked chart with `dataLabelPosition: 'outEnd'`, which PowerPoint refuses to open.

5. **Check the text against the changelog.** `markitdown docs/release/release-4.2.pptx` prints one block per slide under a `<!-- Slide number: N -->` marker, with speaker notes under `### Notes:`. Diff that text against the changelog section yourself or with the trace prompt below.

6. **Look at the rendered slides.** The skill converts the deck to PDF with LibreOffice, then to one JPEG per slide with `pdftoppm`, and inspects each image for overflow, overlap and low contrast. Open two or three of the images yourself before the deck goes out.

**Copy-paste prompt: release deck from CHANGELOG.md**

```text
Use the pptx skill. Build docs/release/release-4.2.pptx from the "## [4.2.0]"
section of CHANGELOG.md, for an internal all-hands audience (engineers and
product). Eight slides maximum: title, highlights (three items), one slide
per Added/Changed/Fixed group, breaking changes with the migration step,
and a closing slide with the upgrade command.

Rules:
- Every bullet must come from a CHANGELOG line. Do not add features,
  numbers or dates that are not in that section.
- Put detail in speaker notes, not on the slide. Max five bullets per slide.
- Write the generator as scripts/release-deck.js so it can be rerun.
- Fonts: Cambria for titles, Calibri for body.

When done: run the skill's validator, run markitdown on the deck, and render
every slide to an image and inspect it. Report the validator result, any
slide you had to fix, and a table mapping each slide bullet to the
CHANGELOG line it came from.
```

The generator script is the real deliverable. Once it exists, the next release needs one command, `node scripts/release-deck.js`, and the agent only has to update the script when the changelog format changes. Review the script like any other code in the pull request.

## How do you co-author an RFC with an agent, review it and publish it?

A useful RFC depends on context that lives in your head, your tickets and old threads. `doc-coauthoring` makes the agent collect that context before it writes, and tests the draft on a reader who has none of it. The workflow below adds a style gate, a de-slop pass and a human sign-off, then publishes the document where your readers are.

1. **Start the co-authoring session with the prompt below.** The skill offers its three-stage workflow and asks five meta questions: document type, primary audience, desired impact, template, constraints. Answer in shorthand. Then dump everything you know: the incident that triggered the RFC, rejected alternatives, deadlines, the people who will object. If the agent has a Slack, Google Drive or Linear MCP server, point it at the threads instead of pasting them.

2. **Answer the clarifying questions.** The skill asks five to ten numbered questions about gaps, and you can reply with lines such as `3: no, backwards compat`. It moves on when it can ask about trade-offs without needing the basics explained.

3. **Build the RFC section by section.** The skill creates `docs/rfcs/0042-sessions-kv-to-d1.md` with a placeholder for every section, then works through the section with the most unknowns first. For each one it asks questions, brainstorms 5–20 candidate points, and lets you keep, remove or combine them by number before it drafts. Tell it what to change instead of editing the file yourself; it learns your preferences for the next section.

4. **Run reader testing.** The skill predicts 5–10 questions a reader would ask, then answers them from the document alone. In Claude Code it does this with subagents that see only the document. In Codex and Cursor, or whenever the skill says it cannot spawn a subagent, run the test yourself in a fresh session with the reader-test prompt below. The exit condition is that the fresh reader answers correctly and surfaces no new ambiguities.

5. **Lint the prose.** Ask for a `writing-guidelines` review of the RFC. It returns findings such as `docs/rfcs/0042-sessions-kv-to-d1.md:31 - passive voice` and edits nothing. Apply the findings your own style guide agrees with and discard the Vercel-specific ones (see traps).

6. **De-slop, then diff.** Run `humanizer` on the file. In file mode it writes only the final text and leaves code blocks, inline code, commands, paths, YAML and link targets unchanged. Then run `git diff --word-diff docs/rfcs/` and check that no number, name, date or claim changed. Humanizer checks for added or dropped claims itself, but the diff is your evidence.

7. **Open a pull request and get sign-off.** The RFC goes through review like code: the author owns the content, named approvers (the tech lead and one owner of each affected system) approve, and objections are resolved in the PR thread. Record the decision in an [architecture decision record](/en/workflows/plan/architecture-decisions/) once the RFC is accepted.

8. **Publish in the format your readers use.** The Markdown file stays the source of truth. For readers outside the repository, ask the `docx` skill for a Word version with a table of contents, or the `pdf` skill for a PDF, and link the PR in the document so readers can see how it was developed.

**Copy-paste prompt: start an RFC with doc-coauthoring**

```text
Use the doc-coauthoring skill. I need an RFC proposing that we move user
sessions from Cloudflare KV to D1. Audience: the platform team and the two
service owners who read sessions. Desired impact: an approve/reject decision
at next Thursday's architecture review. Template: docs/rfcs/TEMPLATE.md.

Write the file to docs/rfcs/0042-sessions-kv-to-d1.md. Start with the
section that has the most unknowns. Do not state any latency, cost or
traffic figure unless I give it to you or you read it from a file I name;
mark missing figures as TODO(owner) instead.
```

**Copy-paste prompt: reader-test a document in a fresh session**

```text
You have not seen this document before. Read docs/rfcs/0042-sessions-kv-to-d1.md
and nothing else. Answer these questions using only the document, and quote
the sentence each answer comes from:
1. What problem does this RFC solve, and for whom?
2. What exactly changes for a service that reads sessions today?
3. What is the rollback plan, and what triggers it?
4. Which alternatives were rejected, and why?
5. What does the author need decided, by whom, by when?
Then list: anything ambiguous, any knowledge the document assumes the reader
already has, and any internal contradiction.
```

To run the reader test from the terminal in a clean context, pass that prompt to `claude -p --no-session-persistence` or `codex exec --ephemeral`, so the test run is not saved as a session. Both start without your drafting conversation, though they still load the repository's `CLAUDE.md` or `AGENTS.md`.

## How do you verify a document the agent produced?

A generated document goes to people who make decisions from it, so treat it like a release artifact: it passes checks before a human reads it, and the human reads the evidence, not every line.

| Check | What it catches | How it runs |
| --- | --- | --- |
| File validation | A deck or document PowerPoint or Word refuses to open | The skill's validator after every build; a failure blocks delivery |
| Source trace | Invented features, numbers or dates | A table mapping each slide bullet or RFC claim to a changelog line, ticket or file |
| Placeholder scan | `TODO`, `lorem`, `[insert…]`, template text left behind | The `grep` below, from the skill's own QA section |
| Reader test | Gaps only the author can fill | A fresh session answers reader questions from the document alone |
| Style lint | House-style violations | `writing-guidelines` findings, or the same check against your own guide |
| Rewrite diff | Facts changed during de-slopping | `git diff --word-diff` after `humanizer` |
| Human sign-off | A wrong decision, a missed stakeholder | Named approvers on the pull request |

Run the placeholder scan on the text dump:

```bash
markitdown docs/release/release-4.2.pptx | grep -iE "\bx{3,}\b|lorem|ipsum|\bTODO|\[insert"
```

An empty result is the pass.

**Who signs off.** The author owns accuracy and the source trace, whoever typed the words; Vercel's own writing guidelines say the same ("You are accountable for the content you produce, however it is created"). The tech lead approves RFCs that change architecture. For decks, the release owner approves after reading the trace table and opening the rendered slides. Attach both to the pull request as part of the [evidence bundle](/en/workflows/ship/evidence-bundle/).

## What does each writing skill cost in context?

Skills cost their name and description in every session and their body only when they fire. Measured on 2026-09-26. The first three rows come from `claude plugin details document-skills@anthropic-agent-skills` in Claude Code 2.1.283. The last three are the byte size of each file (`wc -c`), converted at roughly four bytes per token:

| What loads | When | Size |
| --- | --- | --- |
| `document-skills` plugin (four skills) | Every session | about 1,028 tokens |
| `pptx` | When it fires | about 7.9k tokens |
| `xlsx`, `pdf`, `docx` | When each fires | about 3k, 3k and 2.4k tokens |
| `doc-coauthoring` `SKILL.md` | When it fires | about 4k tokens (15,815 bytes) |
| `humanizer` `SKILL.md` | When it fires | about 8.1k tokens (32,348 bytes, v3.1.0) |
| `writing-guidelines` `SKILL.md` + the rules it fetches | When it fires | about 3.9k tokens (1,233 + 14,228 bytes) |

Run `claude plugin details document-skills@anthropic-agent-skills` after the install to see your own numbers, and compare `/context` before and after adding portable skills.

**Traps with document and writing skills**

- **"Claude Code has the Word, Excel and PowerPoint skills built in."** It does not. Anthropic's docs say the pre-built document skills are not available in Claude Code (Anthropic's Agent Skills docs, checked 2026-09-26 against Claude Code 2.1.283); install `document-skills@anthropic-agent-skills`.
- **The Office skills are not open source.** Their licence is proprietary and source-available, governed by your agreement with Anthropic. It forbids reproducing, distributing or making derivative works of the skill's files, so do not vendor `validate.py` or the skill folder into your repository or CI image. Whether running them in Codex or Cursor fits your agreement is a question for your legal team.
- **"pptxgenjs is preinstalled"** is true in Anthropic's sandbox, not on your laptop. When `require('pptxgenjs')` fails the agent runs `npm install`; make sure it installs into your project as a dev dependency, not into a random directory.
- **Two skills named `doc-coauthoring`.** Sentry's `getsentry/skills` ships its own, with a different author. Installed together as portable skills they compete for one folder; keep one.
- **`writing-guidelines` is Vercel's house style.** The rules it fetches include Vercel-only checks: `meta.contentType`, screenshots from the ACME demo account, pinned model strings for Vercel's AI Gateway examples, and a ban on em dashes. Tell the agent to skip those, or copy the rule file into your own skill with your guide's rules.
- **`writing-guidelines` fetches its rules from GitHub on every run.** Offline or in a locked-down sandbox it has no rules to apply. The rules can also change between two runs, so pin a copy if you gate on it.
- **The humanizer plugin and the portable skill have different names.** The plugin answers to `/humanizer:humanizer`, the skills CLI install to `/humanizer`.
- **`--skill=<name>` is silently ignored** by the skills CLI 1.7.0; with `-y` it installs every skill in the repository. Write `--skill pptx` with a space.

## What breaks when agents write documents?

**The deck opens in LibreOffice but PowerPoint calls it corrupt.** The `pptx` skill lists generator inputs that produce such files: a `#` or an alpha channel in a hex colour, a negative shadow offset, `outEnd` labels on a stacked chart, a secondary axis without both `valAxes` and `catAxes`. The validator reports the two chart faults; the colour and shadow rules are only in the skill's instructions. Recovery: run the validator, fix the generator (not the packed XML), rebuild, and open the file in PowerPoint once before the first release.

**Text overflows on the real deck but looked fine in QA.** The skill's visual check renders with LibreOffice, which substitutes fonts it does not have; Georgia, Trebuchet MS and Garamond render at different widths. Recovery: use the skill's QA-safe fonts (Arial, Calibri, Cambria and a few others) for body text, and leave about 10% slack elsewhere.

**The deck contains features that are not in the release.** The model filled a thin changelog with plausible items. Recovery: require the trace table from the release-deck prompt, reject any bullet without a changelog line, and fix the changelog if the item is real.

**The RFC reads well but answers nobody's question.** You skipped context gathering, so the agent wrote a generic proposal. Recovery: restart at stage one, answer the five meta questions, and run the reader test before anyone else reads it.

**Humanizer changed a number.** De-slopping merged two sentences and dropped a qualifier. Recovery: `git diff --word-diff`, restore the lost claim, and keep humanizer out of reference tables and changelogs, where the wording is the data.

**`writing-guidelines` returns 60 findings on a short page.** Most are Vercel house rules your docs never followed. Recovery: filter to the categories your style guide shares (voice, headings, links, banned words), or write your own review skill with [building custom skills](/en/ecosystem/skills/building-custom-skills/).

## Where to go next

- [Anti-slop writing skills](/en/ecosystem/skills/unslop/) — Unslop's deterministic scanners, miodkuj for Polish, and what the evals say about de-slopping.
- [Architecture decision records](/en/workflows/plan/architecture-decisions/) — Where an accepted RFC ends up, and how agents read decisions later.
- [Spec-driven development](/en/workflows/plan/spec-driven-development/) — The same interview-then-draft discipline, applied to specs the agent builds from.
- [Skill supply-chain security](/en/ecosystem/skills/skill-security/) — What to read before you install a skill that runs scripts with your permissions.
- [Installing and managing skills](/en/ecosystem/skills/installing-managing/) — The skills CLI, plugins, updates, removal and the traps between them.
- [Documentation as context](/en/workflows/context/documentation-as-context/) — Keeping the docs you write readable for the next agent session, not only for people.

For the interview skill that pairs well with `doc-coauthoring` before a spec, see [Matt Pocock's skills, from grill-me to implement](/en/ecosystem/skills/grill-me/). For how plugins bundle and distribute skills like these, see [plugins and marketplaces](/en/ecosystem/plugins/).
