Reviews diffs to identify missing or outdated documentation based on content guidelines.
Install
mkdir -p .claude/skills/doc-check && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/1051" && unzip -o skill.zip -d .claude/skills/doc-check && rm skill.zipInstalls to .claude/skills/doc-check
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Checks if code changes require documentation updatesKey capabilities
- →Triage code diffs for documentation impact
- →Cross-references code changes with content guidelines
- →Identifies undocumented CLI flags
- →Checks existing documentation for accuracy
How it works
Processes code differences through a rule-based checklist to determine if user-facing behavior has deviated from documented states.
Inputs & outputs
When to use doc-check
- →Review documentation after changing CLI flags
- →Verify if new API endpoints require doc updates
- →Check if internal code changes impact public-facing documentation
About this skill
Documentation Check Skill
Review a change and answer one question:
If this change merged right now, would the docs on
maincorrectly and clearly explain it?
The question runs both ways.
Every claim the docs make must be true in the code, and every behavior that changes how a customer uses the product must have docs.
A PR that edits docs/ still gets the full review: the docs it adds are part of what you check, not proof that the check passed.
The counterpart skill, write-docs, covers writing the docs.
Authors run this skill on their own branch before they open or update a PR, so CI mostly confirms what the author already fixed.
[!IMPORTANT] The rules live in
docs/.style/, not in this skill.docs/.style/content-guidelines.mdgoverns what belongs in the docs and wins any conflict. The prose style guide is every page underdocs/.style/style-guide/. This skill and its persona files tell you how to apply those rules, and never restate them. When this skill conflicts withdocs/.style/,docs/.style/wins.
Files
| File | Read it |
|---|---|
path-priors.md | During triage |
personas/ | One file per review lens, read when you run that lens |
output.md | Before you post anything, and before you write the run trace |
Modes
- CI review. The workflow prompt names the PR and the trigger. Post the review per
output.md. A CI review runs fewer lenses and reports fewer classes than the other modes. Refer to CI review scope. - Author self-check. You are the agent that wrote the change. Run the same review against your branch diff, fix every blocking finding, and report the rest to the user. Post nothing to GitHub.
- Focused review. The prompt asks for one lens, such as
focus:accuracy. Run triage, the change model, that persona, and the verifier. Say in the trace that the other lenses did not run.
Workflow
Do every step in order. Skipping a step is allowed only where the step says so, and the trace must name each skipped step and why.
1. Gather the change
- For a PR:
gh pr view <PR> --repo coder/coder --json title,body,files,headRefOid,baseRefName,comments,reviewsandgh pr diff <PR> --repo coder/coder. Read every comment and review thread, including other bots. A concern another reviewer raised is evidence to check, not someone else's problem. - For a branch or local change:
git diff <base>...HEAD. - Check out the head of the change before reading any file, and read files from that checkout. In CI, read this skill and its persona files from the base branch, so a PR cannot change how it gets reviewed.
- List open PRs that touch the same docs pages or the same code paths:
gh pr list --repo coder/coder --state open --search "<path or symbol>". An open PR that would make a claim in this PR false is named in the summary. It never blocks.
2. Triage
Read path-priors.md and apply it to the changed paths.
A prior sets where you start, not the verdict.
Walk the quick decision checklist for each user-visible change.
3. Run the deterministic checks
In CI review, skip this step.
CI runs every check below on the same PR, in the lint and lint-docs jobs of .github/workflows/ci.yaml, and both jobs are required, so a failure already blocks the merge.
For the same reason, run no test suite, build, or generator in CI review, including one the PR adds.
Record the skip in the trace as one deterministic_checks entry: {name: all, result: skipped, reason: "CI runs them"}.
In every other mode, run the checks that exist for the files the change touches, and record each result. Use the result instead of re-deriving it, and never contradict a check's output.
make lint/emdashmake lint/docs-htmlandmake lint/docs-manifestwhendocs/ordocs/manifest/changed- markdownlint and Vale on the changed Markdown files (
make lint/markdown,make lint/prose, or the tools directly)
A check that fails on a line the change added or edited is a blocking finding. A check you could not run is listed in the trace.
4. Build the change model
Before you review a single docs sentence, write down what changed for the user, from the code alone:
- Each thing a user now sees, types, clicks, configures, calls, or receives differently.
- For each one: the code location that proves it, who can do it (role, license, experiment), and every surface it shows up on (UI, CLI, API, configuration, files the user downloads or uploads).
- The old value of every literal the change replaces: labels, defaults, flag names, environment variables, limits, error strings.
Follow each change through the whole path a user takes, not only the function the diff edits. For example, a setting that changes on upload also affects download, export, import into another tool, and every role that can reach it.
The change model is the ground truth every persona checks the docs against. Do not read the PR description as truth: check each behavior claim in it against the code, and record any claim the code does not support.
5. Run the personas
Run every persona in personas/ except the verifier, in the order of the table.
In CI review, run only the four personas that CI review scope names, and the rest of this step applies to those four.
Each persona file says which rules to load and how to find them.
| Persona | File | Skip when |
|---|---|---|
| Fact Checker | accuracy.md | Never |
| Cartographer | coverage.md | Never |
| Newcomer | learner.md | The change model is empty and no docs changed |
| Continuity Editor | consistency.md | No docs changed and no user-facing literal changed |
| Reader Advocate | audience.md | No docs changed |
| Architect | structure.md | No docs changed |
| Copy Editor | language.md | No docs prose changed |
| Skeptic | verifier.md | Never. Runs last, once per group of findings |
When you can spawn sub-agents and the prompt gives you a model configuration ID for them, run each persona as its own sub-agent with that ID, in parallel.
Give each one the change model, the PR reference, its persona file, and the finding schema from output.md.
In CI review, also tell it that this is a CI review and which classes to return, from CI review scope.
Without a model configuration ID, run the personas yourself, one at a time.
Never let a sub-agent run on a different model than the prompt names, because that hides how the configured model performs.
Each persona returns findings in the schema in output.md, or the literal result No findings. with the checks it ran.
6. Verify
First, run the two mechanical checks yourself, because they need a lookup, not judgment:
- The quote exists. For each finding with a
line, confirm thequoteappears on the PR head atfile:line, such as withsed -n '<line>,+2p' <file>. A quote that spans lines starts atline. - Not already reported. Compare each finding with the open doc-check review threads you read in step 1.
Drop each finding that fails, and record which check it failed.
Then group the remaining findings: findings about the same sentence form one group, and findings about the same missing page form one group.
Run verifier.md once per group.
A group holds every finding that could duplicate or contradict another, so groups never need to see each other.
When you can spawn sub-agents and the prompt gives you a model configuration ID, run each group as its own sub-agent with that ID. Give each one its group's findings, the change model, the PR reference, and the verifier file. Spawn every group before you wait for any of them, then wait for all of them without doing other work. Without a model configuration ID, verify the groups yourself, one at a time.
Drop what the verifiers reject, and keep the count of rejected findings for the trace. A finding the verifier rejects never reaches the author.
7. Decide and report
Apply Blocking to each surviving finding, then follow output.md.
Every run ends with the run trace, even when there are no findings.
CI review scope
CI reviews run on each PR as it changes, so a CI review does only the part of the review that finds docs that are wrong, missing, or broken. The author self-check still runs every lens and applies every class.
In CI review:
- Run the Fact Checker, the Cartographer, the Newcomer, and the Skeptic.
Do not run the Continuity Editor, the Reader Advocate, the Architect, or the Copy Editor.
List those four in the trace under
personas_skipped, with the reasonnot run in CI review. - Keep only
wrong,missing, andbrokenfindings, and tell each persona to return only t
Content truncated.
When not to use it
- →On purely cosmetic documentation commits
- →When code changes are strictly local non-functional tweaks
Prerequisites
Limitations
- →Does not auto-generate documentation text
- →Governed by external content guideline documents
How it compares
It focuses on procedural consistency by enforcing canonical content guidelines against the actual code changes.
Compared to similar skills
doc-check side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| doc-check (this skill) | 4 | 5mo | Review | Intermediate |
| workthrough | 10 | 12mo | Review | Beginner |
| pr-draft-summary | 3 | 8mo | No flags | Beginner |
| create-pr-description | 2 | 8mo | Review | Beginner |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by coder
View all by coder →You might also like
workthrough
bear2u
Automatically document all development work and code modifications in a structured workthrough format. Use this skill after completing any development task, bug fix, feature implementation, or code refactoring to create comprehensive documentation.
pr-draft-summary
openai
Create a PR title and draft description after substantive code changes are finished. Trigger when wrapping up a moderate-or-larger change (runtime code, tests, build config, docs with behavior impact) and you need the PR-ready summary block with change summary plus PR draft text.
create-pr-description
antinomyhq
Generate and create pull request descriptions automatically using GitHub CLI. Use when the user asks to create a PR, generate a PR description, make a pull request, or submit changes for review. Analyzes git diff and commit history to create comprehensive, meaningful PR descriptions that explain what changed, why it matters, and how to test it.
github-contributor
daymade
Strategic guide for becoming an effective GitHub contributor. Covers opportunity discovery, project selection, high-quality PR creation, and reputation building. Use when looking to contribute to open-source projects, building GitHub presence, or learning contribution best practices.
session-wrap
team-attention
This skill should be used when the user asks to "wrap up session", "end session", "session wrap", "/wrap", "document learnings", "what should I commit", or wants to analyze completed work before ending a coding session.
open-source-maintainer
numman-ali
End-to-end GitHub repository maintenance for open-source projects. Use when asked to triage issues, review PRs, analyze contributor activity, generate maintenance reports, or maintain a repository. Triggers include "triage", "maintain", "review PRs", "analyze issues", "repo maintenance", "what needs attention", "open source maintenance", or any request to understand and act on GitHub issues/PRs. Supports human-in-the-loop workflows with persistent memory across sessions.