Top 10 Writing & Docs Skills for AI Coding Agents

Best for: Collaborative proposals and other substantial documents that need iterative author review

doc-coauthoring structures collaborative drafting around context gathering, an outline, and iterative section refinement. The author remains involved as the document develops rather than receiving an unexplained finished draft.

A fresh reader can help expose hidden assumptions and confusing passages. That is a comprehension check, not fact-checking: use a separate reader context only when available and share only authorized, relevant material.

• Elicits context before drafting
• Refines substantial documents section by section
• Optional fresh-reader check tests comprehension, not truth

Best for: A scoped documentation set that distinguishes tutorials, how-to guides, reference, and explanation

documentation-writer uses four Diátaxis categories: tutorials, how-to guides, reference, and explanation. It asks about audience, reader goal, scope, and exclusions before proposing an outline for approval.

It is a composition workflow, not an autonomous research source: its instructions prohibit external research unless the user supplies a link and asks it to use that source.

• Separates tutorial, how-to, reference, and explanation
• Clarifies audience, goal, scope, and exclusions
• Gets outline approval before drafting

Best for: A missing or stale repository entry point that should fit its actual project

crafting-effective-readmes first identifies whether the task is to create, update, or review a README, then tailors structure and detail to the audience and project type instead of forcing every repository into one template.

Its local templates and section guidance support the writing workflow. Verify commands and claims against the actual project files; the templates are not tested setup scripts.

• Create, update, and review task modes
• Structure follows audience and project type
• Includes local templates and section guidance

Best for: AGENTS.md, CLAUDE.md, and other documentation that agents must discover and follow

writing-for-agents focuses on the needs of an agent consuming project documentation: clear instructions, useful context, and a structure that makes relevant guidance discoverable.

Its guidance applies to agent-facing documents generally. The separate skill-authoring mechanics branch assumes a host with corresponding skill metadata and routing controls; those mechanics are not universal across agent platforms.

• Targets agent-consumed project documentation
• Covers instruction files and linked context
• Skill-authoring mechanics are a host-specific branch

Best for: Preserving why a consequential codebase decision was made

documentation-and-adrs focuses on decision rationale that cannot be recovered from the implementation alone: context, alternatives, and consequences. It also recommends comments for intent and gotchas rather than paraphrasing code.

Keep records in the repository's established location and follow its conventions. A new record can supersede an older one without erasing the decision history.

• Captures context, alternatives, and consequences
• Keeps superseded decisions as history
• Comments explain intent and gotchas, not code syntax

Best for: Procedures that an operator needs to carry out and verify

writing-runbooks structures instructions around the operator's task, prerequisites, expected observations, risks, and recovery or rollback. A useful procedure distinguishes an action from evidence that the action succeeded.

Do not present an unrun procedure as verified. If no one has executed it against the relevant system, identify it as a draft and leave verification claims open.

• Prerequisites and operational risks are explicit
• Verification is tied to observable outcomes
• Rollback and recovery belong in the procedure

Best for: Explaining request and response contracts, defaults, errors, and examples to API callers

documenting-contracts describes caller-facing wire behavior, grounding field requirements, defaults, errors, and examples in implementation evidence such as serializers and source anchors.

Use generated OpenAPI or AsyncAPI artifacts for field tables when available, and verify semantic details against the configured serializer. The workflow does not generate a specification or prove conformance.

• Grounds wire behavior in serializers and source anchors
• Covers requiredness, defaults, and error behavior
• Generated API specifications own field tables when present

Best for: A substantial documentation campaign for an inherited or poorly documented system

documenting-legacy-codebases treats existing implementation and wiring as primary evidence for reconstructing inherited or stale documentation. Its inventory and coverage work makes the scope visible, while anchors and explicit unknowns keep claims traceable.

This is a documentation campaign, not a code-fix, security-triage, or rewrite recommendation. It can identify a need for a specific contract or runbook document without replacing those separate deliverables.

• Inventories existing documentation against the system
• Tracks coverage and source anchors
• Leaves unresolved behavior explicitly unknown

Best for: A prose-review pass where Vercel's style and live network rules are appropriate

writing-guidelines reviews documentation prose against Vercel's writing rules and returns findings in file-and-line form. It is a review workflow rather than a general-purpose drafting or research skill.

The skill fetches its rules at review time, so findings reflect the current Vercel rules rather than a permanently fixed ruleset. Treat them as Vercel-flavored house-style feedback and account for the network dependency.

• Produces file-and-line review findings
• Uses Vercel's house style, not a universal standard
• Fetches the effective rules from the network at runtime

Best for: Long-form articles that need a clear thesis and a deliberate sequence of ideas

writing-shape develops an argument-driven article from existing raw material. It asks the author to choose among candidate openings and then builds in blocks whose ideas are grounded before later ideas depend on them.

A prior writing-fragments interview is one possible way to collect source material, not a required selected companion. Keep the material separate and preserve user edits; missing evidence stays a gap rather than becoming an invented fact.

• Chooses a thesis and opening before expanding
• Builds blocks from concepts the reader has already met
• Requires existing material and active author choices