Agent skill

Technical Writing

by citypaul in citypaul/.dotfiles

Writing developer-facing prose that can be skimmed first and trusted enough to finish — READMEs, guides, tutorials, reference docs, proposals, PR descriptions, release notes.

MITAuto-check passedWriting & Content

Install Technical Writing

skills CLI
$ npx skills add citypaul/.dotfiles --skill technical-writing -a claude-code

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

GitHub CLI
$ gh skill install citypaul/.dotfiles technical-writing --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/citypaul/.dotfiles.git skills-src && mkdir -p .claude/skills && cp -r skills-src/claude/.claude/skills/technical-writing .claude/skills/technical-writing && 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
technical-writing
GitHub stars
740
Token cost
~2.5k tokens
SKILL.md length
1,201 words
Files
9
Skills in repo
44
Repo updated
First seen
Licence
MIT

At a glance

Writing developer-facing prose that can be skimmed first and trusted enough to finish — READMEs, guides, tutorials, reference docs, proposals, PR descriptions, release notes.

  • Tasks that involve Technical writing
  • SKILL.md covers One Primary Reader Job Per Page, Principles, Material Claims Need Receipts and Docs Are Behavior — Verify Them, plus 5 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Tasks that involve Technical documentation

What it does

Technical Writing is an agent skill from citypaul/.dotfiles. Writing developer-facing prose that can be skimmed first and trusted enough to finish — READMEs, guides, tutorials, reference docs, proposals, PR descriptions, release notes. Load before drafting, rewriting, restructuring, or editing technical documents, when a doc reads as a wall of text, claims need receipts, or docs must serve AI agents. Covers reader-first structure, falsifiable claims, docs-as-behavior verification, and agent-readable reference shape. For sentence-level voice or generic AI-shaped prose use…

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 9 other files (for example `resources/agent-docs.md`, `resources/doc-types.md` and `resources/docs-quality.md`).

It sits in Writing & Content, covering Technical writing, Technical documentation and Diagrams. The licence is MIT.

When your agent uses it

  • Tasks that involve Technical writing
  • Tasks that involve Technical documentation
  • Tasks that involve Diagrams

Example prompts

  • “/technical-writing”

What it can do on your machine

Read from SKILL.md and the folder at commit cd4028d. 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

    No scripts in the folder and no shell commands in SKILL.md.

    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

Technical Writing loads about 2.5k tokens when it runs. Until then it costs about 189 tokens; SKILL.md has 1,201 words of instructions outside code blocks.

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

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 citypaul/.dotfiles at commit cd4028d, republished under its MIT licence (© citypaul). 1,201 words, ~2,464 tokens.

Download SKILL.mdSave it as .claude/skills/technical-writing/SKILL.md (or your agent's skills folder). This skill also uses 8 other files; get the full folder from GitHub.
name
technical-writing
description
Writing developer-facing prose that can be skimmed first and trusted enough to finish — READMEs, guides, tutorials, reference docs, proposals, PR descriptions, release notes. Load before drafting, rewriting, restructuring, or editing technical documents, when a doc reads as a wall of text, claims need receipts, or docs must serve AI agents. Covers reader-first structure, falsifiable claims, docs-as-behavior verification, and agent-readable reference shape. For sentence-level voice or generic AI-shaped prose use clarity; for plain English, lay readers, translation, or ASD-STE100 use simple-english; for recording a learning use expectations; for diagrams use diagrams; for API semantics use api-design; for CLI help use cli-design.

Technical Writing: Skimmed First, Trusted Enough to Finish

Developers skim before they commit. A document earns the full read by answering three questions in its first screen: what is this, why should I care, and how do I start. Everything below serves that contract.

ResourceLoad when...
resources/doc-types.mdChoosing what KIND of page to write — the four Diátaxis modes, tutorial-vs-how-to, the types the model omits, minimalism scoped per type
resources/readme.mdWriting or overhauling a README — the cognitive funnel, short-vs-long resolved, README-driven development
resources/docs-quality.mdMaking docs enforceable — prose lint, executable examples, link checking, friction logs, timeless-docs, every-page-is-page-one
resources/agent-docs.mdDocs serving AI agents — the honest llms.txt verdict, markdown endpoints, RAG-chunkable pages
resources/formatting.mdStructural rules — titles, headings, paragraphs, lists, intros/outros, tables of contents
resources/references.mdSources for every claim above

One Primary Reader Job Per Page

Choose the page's primary reader job: tutorial, how-to, reference, or explanation (Diátaxis; its honest limits live in resources/doc-types.md). Supporting material may cross a boundary when that helps the same job. Split the page when mixed purposes make the next action, completeness contract, or intended audience unclear.

Principles

  • Reader-first — lead with the payoff; the reader's next action is the organizing principle, not the system's internal structure. Name things by what readers recognize, not how the code is built.
  • Scannable — clear headings that summarize their section's payoff, short paragraphs, purposeful emphasis. Add a heading when it gives a skimmer a useful landmark; do not optimize for a word-count quota.
  • Plain and direct — active voice, second person for instructions, short sentences for complex ideas. Complete sentences beat fragments and arrow chains: readable matters more than terse.
  • Selective, not compressed — the way to keep a doc short is to cut what doesn't change the reader's next step, never to compress the prose into jargon the reader must decode.

Material Claims Need Receipts

Make material capability, current-state, compatibility, and quantitative claims checkable. Explanatory prose, clearly labelled judgment, and normative design rationale do not need a fake command or date; unsupported promotional claims do.

  • No capability claim without evidence: numbers a reader can verify, a command they can run, a file they can open. "Fast" is marketing; "the gates run in 14 seconds on this repo's CI" is a claim with a receipt.
  • Counts and versions rot: changing operational numbers quoted in prose (test counts, coverage, versions) are maintenance liabilities — either generate it, date it, or bind it to the kept-current rule (updating it is part of every change's definition of done).
  • Honest limits are content, not confession: when the page's scope could imply protection, coverage, or capability it does not provide, name those limits where the reader makes the decision. A short document need not grow a ceremonial limits section when its bounded scope is already explicit.
  • Idle and empty states must speak: "0 items processed" that reads like success is a lie of layout. Distinguish "nothing to do" from "did nothing" everywhere output appears in docs and examples.
  • Timeless maintained guidance: evergreen READMEs and reference docs avoid unowned "coming soon", "currently", or "new in…" labels. Release notes, migration guides, deprecation notices, and time-bounded status pages may need temporal language; attach a version/date and an owner or removal condition so it remains evidence instead of stale promotion.

Docs Are Behavior — Verify Them

A document that describes a system is a claim about that system, and claims get verified:

  • Verify against the source, not memory: every material flag, exit code, config key, and executable command a doc asks readers to rely on is checked against the code before it ships. Execute the claim when doing so is safe, authorized, and proportionate; otherwise record the evidence gap.
  • Machine-check what machines can check: table-of-contents anchors against the renderer's real slug rules, links against files, command examples against the binary. Hand-verification is the fallback, not the default.
  • Update docs in the same reviewable change: a behavior change that leaves its documentation stale is incomplete work. Follow the repository's commit policy rather than imposing one globally.
Show full SKILL.md (543 more words)Show less

Maintained Docs Describe Current Truth

Use resources/docs-quality.md for the full state-based lifecycle and Git-archaeology workflow.

  • Keep plans and specification workspaces only while their outcomes remain unfinished. Delete them when the outcome ships or their assumptions are superseded; Git history is the archive.
  • Promote lasting constraints to their current owner: source or executable tests for behavior, accepted ADRs for architecture decisions, package or operational docs for maintained procedures, and the authoritative glossary for domain vocabulary.
  • Do not make maintained docs depend on deleted specifications or unexplained delivery identifiers. Introduce the purpose in plain language before any genuinely necessary issue, PR, task, requirement, specification, or ADR identifier.
  • Give documentation indexes a clear starting point and distinguish current authority, active work, decisions, and historical evidence. Prefer a small navigable set of trusted pages; delete duplicated, obsolete, speculative, generated, or unowned prose.
  • Documentation-only changes do not inherently require TDD. Any executable documentation guard still needs a focused test proving it can fail.

Writing for AI Agents Too

Developer docs now have two audiences. Agent-readable means:

  • Enumerable over prose-only: anything an agent must choose from — options, flags, exit codes, states — appears in a table row, not only inside a paragraph.
  • Preconditions and postconditions per operation: what must be true before, what changes after, what exit codes mean. A state-machine table ("in state X, the one correct next action is Y") outperforms narrative for both audiences.
  • Exact strings: agents (and humans under pressure) copy-paste. Give the exact command, the exact config block, the exact error message — never a paraphrase.

Document Shapes

  • README / landing: first screen answers what/why/how-to-start; table of contents when it materially improves navigation; quickstart as one coherent journey in true order; honest limits before credits.
  • Tutorial: state the destination up front ("you will have X working"); number steps; every step's output shown so readers know they're on track; end with where to go next.
  • Reference: completeness over narrative; one entry per flag/option/state; generated where possible; agent-readable tables.
  • Proposal / design doc: the decision requested up front, options with honest trade-offs, a recommendation with reasoning, and what evidence would change it.
  • PR description / release notes: what changed for the READER of the change (behavior, migration), not a commit-log paraphrase.

Boundaries

SituationSkill
Choosing and authoring diagramsdiagrams
REST/API reference semantics (errors, pagination, versioning)api-design
CLI help text, exit codes, output designcli-design
Documenting expectations, gotchas, decisions while freshexpectations
Domain vocabulary in proseubiquitous-language (where installed)
Sentence-level voice, generic prose, or AI-shaped writingclarity (where installed)
Plain English, lay readers, translation, or ASD-STE100simple-english (where installed)

Verification Checklist

  • First screen answers what / why / how-to-start
  • Headings summarize payoffs; a ToC is present where warranted and its anchors are machine-checked
  • Material capability/current-state/quantitative claims carry a receipt or date; promotional claims have evidence
  • Commands, flags, and executable examples readers rely on are verified against source and run where feasible
  • Material limits appear where implied scope could otherwise mislead
  • Enumerable facts appear in tables; exact strings given for anything copy-pasteable
  • Counts/versions bound to the kept-current rule or generated
  • Doc changes ride the same reviewable change as the behavior they describe
  • Maintained docs describe current truth; completed or superseded workspaces are deleted
  • Lasting constraints live with their current owner, not only in historical delivery artifacts
  • Indexes distinguish current authority, active work, decisions, and history

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

Files

SKILL.md and 8 other files in claude/.claude/skills/technical-writing of citypaul/.dotfiles.

  • SKILL.md
  • LICENSE
  • resources/agent-docs.md
  • resources/doc-types.md
  • resources/docs-quality.md
  • resources/formatting.md
  • resources/readme.md
  • resources/references.md
  • resources/source-notes.md

Open the folder on GitHubat commit cd4028d

Compare with similar skills

Technical Writing 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.

Technical Writing compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Technical Writing this skillcitypaul/.dotfiles740—~2.5kAutomated safety check: PassMIT
Technical Writing Standardcursor/plugins10k10 repos~2.4kAutomated safety check: PassNone
Docs Interfacesjh941213/my-cc-harness126—~863Automated safety check: NotesNone
Technical Writingfrappe/skills147—~1.1kAutomated safety check: PassNone
Nbj Write Clearlydaniel-p-green/nbj-write-clearly117—~1.1kAutomated safety check: PassMIT
Plain EnglishFallout-build/Fallout167—~2kAutomated safety check: PassCustom licence

Similar skills

  • Official

    Applies four layers of technical-writing rules to docs, RFCs, readmes, PR descriptions and commit messages so a tired engineer follows them on the first read.

    10k GitHub starsUsed in 10 repos~2.4k tokens
    Writing & ContentAuto-check passed
  • Docs Interfaces

    jh941213/my-cc-harness

    Generate interface/API docs — OpenAPI 3.1/AsyncAPI 3.0 specs, API topology diagrams, interface flow (sequence) diagrams, API changelog.

    126 GitHub stars~863 tokensUpdated 2 mo ago
    Backend & APIsAuto-check: notes
  • Technical Writing

    frappe/skills

    Write prose in "Simplified Technical English". An agent skill from frappe/skills.

    147 GitHub stars~1.1k tokensUpdated 9 days ago
    DevelopmentAuto-check passed
  • Nbj Write Clearly

    daniel-p-green/nbj-write-clearly

    Drafts, revises, and audits reader-first technical and product documentation.

    117 GitHub stars~1.1k tokensUpdated 1 mo ago
    Writing & ContentAuto-check passed
  • Plain English

    Fallout-build/Fallout

    Write clear, plain English for developer-facing prose aimed at an international audience.

    167 GitHub stars~2k tokensUpdated 6 days ago
    DevelopmentAuto-check passed
  • Applies plain language rules to software documentation, architecture explanations, code reviews and technical analysis, following the principles of ISO 24495-3:2026.

    190 GitHub stars~1.6k tokensUpdated today
    Writing & ContentAuto-check passed

More from citypaul/.dotfiles

All 44 skills in this repo
  • Find Skills

    citypaul/.dotfiles

    Discover and, with authorization, install agent skills from the open skills ecosystem.

    740 GitHub stars~2.5k tokensUpdated yesterday
    Auto-check passed
  • Render Code Shape

    citypaul/.dotfiles

    Render the shape of code — module boundaries, the types that cross them, signatures, and a cited call graph — for code that already exists or a change about to be built.

    740 GitHub stars~2.5k tokensUpdated yesterday
    Auto-check passed
  • Structure Codebase

    citypaul/.dotfiles

    Design, audit, and evolve physical source and package structures that expose real architectural boundaries while keeping related behavior together.

    740 GitHub stars~4.4k tokensUpdated yesterday
    Auto-check passed
  • Test Design Reviewer

    citypaul/.dotfiles

    Review test quality using Dave Farley's eight properties of good tests.

    740 GitHub stars~1k tokensUpdated yesterday
    Auto-check passed
  • Characterisation Tests

    citypaul/.dotfiles

    A skill your agent uses when modifying existing code that lacks tests and you need to document its actual current behavior before making changes -- the legacy code dilemma where you need tests to…

    740 GitHub stars~3.6k tokensUpdated yesterday
    Auto-check passed
  • CI Debugging

    citypaul/.dotfiles

    Systematic CI/CD failure diagnosis using hypothesis-first investigation, local reproduction, and environment delta analysis.

    740 GitHub stars~1.5k tokensUpdated yesterday
    Auto-check: notes

Questions about Technical Writing

What does Technical Writing do?

Writing developer-facing prose that can be skimmed first and trusted enough to finish — READMEs, guides, tutorials, reference docs, proposals, PR descriptions, release notes. dotfiles. Writing developer-facing prose that can be skimmed first and trusted enough to finish — READMEs, guides, tutorials, reference docs, proposals, PR descriptions, release notes.

When should I use Technical Writing?

Technical Writing fits situations like: tasks that involve Technical writing; tasks that involve Technical documentation; tasks that involve Diagrams.

How do I install Technical Writing in Claude Code?

Run `npx skills add citypaul/.dotfiles --skill technical-writing -a claude-code`. Or copy the skill folder (claude/.claude/skills/technical-writing in citypaul/.dotfiles) into .claude/skills/technical-writing in your project. Claude Code loads it when a task matches its description.

How do I install Technical Writing in Codex?

Run `npx skills add citypaul/.dotfiles --skill technical-writing -a codex`. Or copy the skill folder (claude/.claude/skills/technical-writing in citypaul/.dotfiles) into .agents/skills/technical-writing in your project. Codex loads it when a task matches its description.

Can I use Technical Writing 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 citypaul/.dotfiles --skill technical-writing -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/technical-writing, .gemini/skills/technical-writing, .github/skills/technical-writing and .opencode/skills/technical-writing in your project.

What does Technical Writing need to run?

SKILL.md names no scripts, command-line tools or credentials: Technical Writing is instructions for the agent only.

Does Technical Writing 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 Technical Writing 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 Technical Writing use?

Technical Writing is published under the MIT licence (from the LICENSE file in the skill folder). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Technical Writing use?

About 2.5k tokens (SKILL.md is roughly 9.9k 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 Technical Writing?

Skills that share tags, products or a category with Technical Writing: Technical Writing Standard (cursor/plugins, 10k stars), Docs Interfaces (jh941213/my-cc-harness, 126 stars), Technical Writing (frappe/skills, 147 stars) and Nbj Write Clearly (daniel-p-green/nbj-write-clearly, 117 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Technical Writing?

citypaul (a GitHub user) maintains it in citypaul/.dotfiles, which has 740 GitHub stars. The repository holds 44 skills in this directory. The repository was last updated on October 9, 2026.

Source: citypaul/.dotfiles on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.