Agent skill

Technical Documentation

by wondelai in wondelai/skills

Audit, write, and improve developer documentation using Google's Developer Documentation Style Guide and Technical Writing courses.

MITAuto-check passedDevelopment

Install Technical Documentation

skills CLI
$ npx skills add wondelai/skills --skill technical-documentation -a claude-code

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

GitHub CLI
$ gh skill install wondelai/skills technical-documentation --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/wondelai/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/technical-documentation .claude/skills/technical-documentation && 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-documentation
GitHub stars
2.4k
Token cost
~5.4k tokens
SKILL.md length
2,749 words
Files
8 (incl. references)
Skills in repo
61
Repo updated
First seen
Licence
MIT

At a glance

Audit, write, and improve developer documentation using Google's Developer Documentation Style Guide and Technical Writing courses.

  • Works in 8 steps: Know the Reader and the Document's Job → Voice: You, Active, Present, Timeless → Sentences and Words → …
  • Any documentation work
  • SKILL.md covers Core Principle, Scoring, Framework and Common Mistakes, plus 3 more sections
  • Needs API_KEY

What it does

Technical Documentation is an agent skill from wondelai/skills. Audit, write, and improve developer documentation using Google's Developer Documentation Style Guide and Technical Writing courses. Use this skill for any documentation work, even when the user names no style guide: "audit our docs", "review this README", "write a README", "getting started guide", "how-to or tutorial", "API reference", "docstrings", "CLI help text", "changelog or release notes", "migration guide", or "our docs are confusing". Also use it when writing docs from code, rewriting a doc for clarity…

Its SKILL.md is about 5.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 8 other files, including reference files (for example `references/api-reference.md`, `references/audit-checklist.md` and `references/document-types.md`).

It sits in Development, covering Technical documentation and Changelog and release notes. The repository describes itself as: Wondel.ai Agent Skills — Business, Marketing, UX & Coding Frameworks from Bestselling Books. 50 skills + 12 guided journeys for Claude Code, Codex, Cursor & other agentskills.io… The licence is MIT.

When your agent uses it

  • Any documentation work
  • Even when the user names no style guide: audit our docs
  • Review this README
  • Getting started guide

Example prompts

  • “audit our docs”
  • “review this README”
  • “write a README”
  • “/technical-documentation”

Requirements

  • A credential in YOUR_API_KEY
  • A credential in API_KEY

Workflow steps

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

  1. Know the Reader and the Document's Job
  2. Voice: You, Active, Present, Timeless
  3. Sentences and Words
  4. Structure: Headings, Lists, Tables, Notices
  5. Procedures and Code
  6. Reference Docs: API, Docstrings, CLI Help
  7. Release Notes, Changelogs, Migration Guides
  8. Running the Audit, Rewrite, or Write

What it can do on your machine

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

    Links to these hosts (documentation or services it may open):

    • developers.google.com
    • amazon.com
    • creativecommons.org
    • keepachangelog.com

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

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • API_KEY

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

Context cost

Technical Documentation loads about 5.4k tokens when it runs, and up to ~34k if it reads all its reference files. Until then it costs about 253 tokens; SKILL.md has 2,749 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~253
When it runs · the whole SKILL.md, loaded when a task matches
~5.4k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~34k

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 wondelai/skills at commit c172996, republished under its MIT licence (© wondelai). 2,749 words, ~5,390 tokens.

Download SKILL.mdSave it as .claude/skills/technical-documentation/SKILL.md (or your agent's skills folder). This skill also uses 7 other files; get the full folder from GitHub.
name
technical-documentation
description
Audit, write, and improve developer documentation using Google's Developer Documentation Style Guide and Technical Writing courses. Use this skill for any documentation work, even when the user names no style guide: "audit our docs", "review this README", "write a README", "getting started guide", "how-to or tutorial", "API reference", "docstrings", "CLI help text", "changelog or release notes", "migration guide", or "our docs are confusing". Also use it when writing docs from code, rewriting a doc for clarity, fixing headings, procedures, or code samples, or enforcing consistent voice and terminology across a docs set — prefer it over editing documentation unaided. Covers reader and doc-type fit, second person and active voice, procedures, headings, lists and tables, code samples and placeholders, link text, notices, the word list, timeless docs, and accessibility. For code comments and naming, see clean-code. For marketing or landing-page copy, see storybrand-messaging.
license
MIT
metadata.author
wondelai
metadata.version
1.0.0

Technical Documentation

Audit, write, and improve developer documentation the way Google's technical writers do: start from the reader's task, verify every fact against the code, then apply the style guide in severity order — structure before voice, voice before word choice.

Core Principle

Write for the reader's task, not the product's feature list. Google's guide asks for prose that is conversational but not frivolous, precise, and consistent, because a developer reading docs is trying to get something done, not to admire the product. Two framing rules from the guide shape everything below:

  • Guidelines, not rules. Depart from the guide when doing so improves the content — established domain terminology wins — but stay consistent within the document.
  • Precedence. A project's own style guide comes first, then Google's guide, then Merriam-Webster (spelling), the Chicago Manual of Style (general style), and the Microsoft Writing Style Guide (technical style).

Rules come in two layers. Structural and content rules (headings, procedures, code samples, second person, active voice, timeless docs, accessibility) apply to documentation in any language. Rules tagged [EN] (spelling, serial comma, contractions, the word list) apply only to English text — skip them for other languages, and never translate a document unless asked.

Scoring

Goal: 10/10. Score = number of Quick Diagnostic rows passed (10 rows, 1 point each; the [EN] row auto-passes for non-English docs). Bands: 9-10 = ships as is; 7-8 = word- and voice-level edits only; 5-6 = restructure sections, then re-edit; ≤4 = rewrite from the doc-type skeleton. Blocking findings — wrong or unverifiable facts, a procedure that can't be completed, information that exists only in an image or in an image without alt text — are a separate gate: the doc is not shippable at any score until they're fixed. Report the score, the failed rows, and the exact edits that reach 10/10.

Framework

1. Know the Reader and the Document's Job

Core concept: Every page serves one reader with one task. Name both before writing a word — audience and level, what they'll be able to do afterwards — and pick the document type that fits: tutorial (learn by doing), how-to (accomplish a task), concept (understand), reference (look up), README (orient and start).

Why it works: Readers scan for their task; a page that mixes concept, procedure, and reference forces them to read everything to find anything.

Key insights:

  • Google's Technical Writing course opens a doc with an audience statement and a scope plus non-scope statement — the non-scope rescues readers who are on the wrong page
  • "Before you begin" lists prerequisites before step 1, not inside step 4 (convention)
  • Key points first: the intro states what the reader gets, not the product's history
  • Every procedural page ends with verification ("Confirm that…") and "What's next" (convention)

Applications:

ContextApplicationExample
READMEOrient: what it is, who it's for, three-step start, links outPurpose → install → first run → docs map
Mixed pageSplit concept from procedure into linked pages"How OAuth works" + "Configure OAuth"
Tutorial vs how-toTutorial teaches one path end to end; how-to assumes context"Build your first plugin" vs "Add a hook"

See references/document-types.md when choosing or restructuring a doc type — skeletons for README, getting started, tutorial, how-to, and concept pages, the audience and scope statements, and the self-editing pass for large doc sets.

2. Voice: You, Active, Present, Timeless

Core concept: Address the reader as "you", make the actor of every sentence explicit, describe behavior in the present tense, and write as if the page will be read in five years.

Key insights:

  • "We" hides who acts; "the user" turns the reader into a third party — both weaken an instruction
  • Passive voice is allowed only when the actor is unknown or irrelevant ("The file is encrypted at rest")
  • "Will" belongs only to genuinely later effects: "The server sends an ack", not "will send"
  • Contractions are fine — Google prefers "isn't" over "is not" for negations [EN]
  • Software doesn't want, see, or think: "The API detects", not "the API sees"
  • No "please" (reserve it for asking permission), no "simply / easily / just", no superlatives — if a step is easy, the reader will notice
  • Timeless: cut "currently", "new", and "soon"; never pre-announce unreleased features

Before → after:

  • "Please note that the new dashboard will simply be shown once the user has logged in." → "After you sign in, the dashboard appears."
  • "We recommend that the token is refreshed by the client." → "Refresh the token from the client."

See references/voice-and-words.md when a doc's tone is off or inconsistent — the voice rules with the guide's exact exceptions, inclusive and global-audience language, and the full word list.

3. Sentences and Words

Core concept: Put the condition before the instruction, keep one idea per sentence, and choose the plain word the guide's word list prefers.

Key insights:

  • "To delete the document, click Delete" — readers decide whether a step applies before they act, not after
  • Spell out an abbreviation on first use with the short form in parentheses; skip only universally known ones (URL, HTML)
  • Latin abbreviations translate and scan poorly: "for example", not "e.g."; "that is", not "i.e."; omit "etc." or finish the list [EN]
  • "can" = ability, "may" = permission, "might" = possibility [EN]
  • Word list samples [EN]: sign in (not log in) · set up as a verb · lets you (not allows you to) · through or by using (not via) · after (not once) · use (not leverage or utilize) · checkbox · email
  • Jargon is fine for the stated reader and a defect for anyone else — define it or link it

Before → after:

  • "Click Save in order to persist the settings once you are done, i.e. when all fields are filled." → "After you fill in all fields, click Save."
  • "The CLI utilizes the GCP SDK (e.g. for auth)." → "The CLI uses the Google Cloud SDK, for example for authentication."

See references/voice-and-words.md when auditing word choice — the word list table (avoid → use → why), abbreviation rules, and modal verbs.

4. Structure: Headings, Lists, Tables, Notices

Core concept: Structure is the reader's map. Headings in sentence case read as a table of contents; lists carry parallel items introduced by a full sentence; tables have header rows; notices are rare and mean something.

Key insights:

  • Task headings are bare imperatives ("Create an instance"); concept headings are noun phrases ("Instance lifecycle"); no "-ing" headings
  • A list needs an introductory sentence ending in a colon, and every item in the same grammatical form; numbered only when order matters
  • Description lists (term → definition) beat two-column tables for paired data
  • Tables: header row, an intro sentence, no merged or empty cells — screen readers depend on it
  • Note = useful but optional; Caution = proceed carefully; Warning = harm or irreversible loss. Don't stack them; one per section is a practical ceiling (inferred)
  • Cross-references say "see", never "above" or "below" — pages reflow and get translated
  • Link text names the target ("see Configure a custom domain"), never "click here"
  • Alt text states the image's purpose; information must never live only in a picture

Applications:

ContextApplicationExample
Wall-of-text pageInsert a task heading wherever the task changes"Install", "Configure", "Verify"
Three stacked notesFold two into body text; keep the one that changes behaviorOne Caution about data loss
Options tableHeader row + intro sentence + parallel cell phrasing"The following flags control output:"

See references/structure-and-formatting.md when fixing page structure — heading, list, table, notice, cross-reference, link-text, image, number, and date rules with before/after pairs.

5. Procedures and Code

Core concept: A procedure is a numbered list of single imperative actions, each stating where to act and what to expect. Code is set in code font, introduced by a sentence ending in a colon, and uses placeholders the reader can't mistake for literals.

Key insights:

  • One action per step; "Optional:" prefix for optional steps; a single step is a bullet, not "1."
  • Sub-steps run a, b, c; document the shortest path, not every alternative
  • UI element names in bold, matching on-screen casing; click for a mouse, tap for touch, select when device-agnostic
  • Code font for filenames, paths, commands, flags, parameters, and values — not for product names
  • Placeholders are ALL_CAPS_WITH_UNDERSCORES, never <your-key> or YOUR_API_KEY, and are explained right after the sample ("Replace PROJECT_ID with…")
  • Command syntax: [optional], {a|b} for exclusive choices, ... for repeatable arguments
  • Samples are runnable, minimal, wrapped at 80 characters, and show the expected output

Before → after:

  • "Run the command below with your key: shipit deploy --key=<your-key>" → "To deploy, run the following command:" → fenced shipit deploy --key=API_KEY → "Replace API_KEY with the key from the Settings page."
  • "1. You should now click on the Deploy button to deploy." → "1. Click Deploy. The status changes to Deploying."

See references/procedures-and-code.md when writing steps or samples — the full procedure rules, UI-element and device verbs, code-in-text, placeholder, command-line syntax, and the sample-code quality checklist.

6. Reference Docs: API, Docstrings, CLI Help

Core concept: Reference text is descriptive, complete, and formulaic on purpose — readers look things up, so every entry must exist and read the same way.

Key insights:

  • Document every public class, method, field, constant, and enum value; a missing entry reads as "unsupported"
  • Open method descriptions with the category verb: "Gets the…", "Sets the…", "Checks whether…", "Creates a…", "Returns…" — never "This method…"
  • Non-boolean parameters start "The…" or "A…"; booleans read "If true, … If false, …" (action) or "True if …; false otherwise" (state)
  • Document return values and exceptions ("Thrown when…") for every method that has them
  • A deprecated element names its replacement in the first sentence
  • CLI --help (convention — Google has no --help page): usage line in [optional] syntax, one-line synopsis, every flag described with the same placeholder style

Before → after:

  • "This method is used for getting the customer." → "Gets the customer for the given customerId. Throws NotFoundError when no customer exists."
  • "@param force - force flag" → "@param force If true, deletes the bucket even if it contains objects. If false, fails when the bucket isn't empty."

See references/api-reference.md when writing or auditing reference material — the verb-by-category table, parameter, return, and exception patterns, one complete JSDoc example, and CLI help conventions.

Show full SKILL.md (1,113 more words)Show less
7. Release Notes, Changelogs, Migration Guides

Core concept: A changelog is documentation for the reader who is about to upgrade. Each entry states what changed, what it means for them, and what to do — in the structure of Keep a Changelog, in the voice of the rest of the docs.

Key insights:

  • Newest version first, an Unreleased section on top, ISO dates in version headings, version headings linked to diffs (Keep a Changelog)
  • Group entries under Added / Changed / Deprecated / Removed / Fixed / Security; never paste commit messages
  • Breaking changes go first in the version, with a link to migration steps (convention)
  • A deprecation entry names the replacement and the removal version or date
  • A migration guide is a procedure: "Before you begin" (versions, backups), numbered steps with before/after snippets, "Verify the migration", rollback
  • Apply the Google layer to every entry: second person for actions, no "currently/new", code font for flags and APIs, one tense used consistently

Before → after:

  • "Various improvements to the auth module (#412)" → "Changed: login() now returns a Session instead of a token string. Update callers that read .token — see Migrate to sessions."

See references/release-notes.md when writing release notes or a migration guide — the Keep a Changelog skeleton, entry patterns per category, deprecation wording, and the migration-guide procedure.

8. Running the Audit, Rewrite, or Write

Core concept: Three modes, one discipline: intake → local conventions → read as the reader → verify facts → apply rules by severity → output in a fixed shape.

Protocol:

  1. Intake. Confirm the mode (audit, improve, or write), document type, reader and level, and language. For write, the reader's task and the fact sources (code paths, existing docs) are required — don't start without them.
  2. Local style guide. Look for CONTRIBUTING.md, STYLE.md, docs/style-guide.md, .vale.ini, and the conventions existing docs already follow (for example, "log in" everywhere). They win over Google. Vale with the Google package automates the [EN] word and punctuation layer if the project wants a linter.
  3. Read references/audit-checklist.md before any audit or improve pass — the rule IDs cited in findings live there; never cite an ID you haven't read.
  4. Read the doc cold as the target reader, then check every command, flag, parameter, and behavior against the code before judging style. A stylish wrong doc is worse than an ugly right one.
  5. Apply rules in severity order: Blocking → High (structure, accessibility, missing reference entries) → Medium (voice, notices, intro sentences) → Low (word list, punctuation [EN]).
  6. Output. A finding's location is one the reader can find: the heading path, plus the line number when auditing a file. Improve = a one-line Score before → after, the full rewritten document, then a ## Change log table (Change | Rule ID + name | Why). Facts stay untouched — a fact stated in the source document counts as received from the user, so keep it (with TODO(verify): … when no code confirms it) rather than deleting it. Write = the document, with TODO(verify) for every gap. Never include a command, flag, or parameter you didn't see in code or receive from the user.

ALWAYS output audits in this format:

# Documentation Audit: [path or title]
**Score:** X/10 — [band]   **Shippable:** yes | no (blocking findings below)
**Diagnostic:** N/10 — failed rows: [row numbers + one-line reason each]
**Doc type / reader:** [type] for [audience, level]   **Language:** [en | xx — [EN] rules skipped]
**Local style guide:** [file found and honored | none — Google applies]
**Blocking:** [wrong/unverifiable facts, unfollowable steps, image-only information — or "none"]
**Findings:**
| # | Location | Rule (ID + name) | Before | After | Severity |
**Rewrite plan:** [ordered: structure → voice → words; what to do first to reach 10/10]

See references/audit-checklist.md when running any audit or rewrite — the full rule table with IDs and severities, the severity rubric, non-English handling, a Vale configuration, and a worked mini-audit.

Common Mistakes

MistakeWhy It FailsFix
Organizing by feature instead of reader taskReaders hunt across sections for one workflowName the reader's task; pick the doc type; one task per page
Fixing style before verifying factsPolished wrong instructions are trusted longerCheck every command and parameter against code first
"Click here" and "see below"Meaningless out of context, to screen readers, and after reflowLink text names the target; cross-refs say "see"
Steps buried in paragraphs, passive and future tenseReader can't tell who does what, or in what orderNumbered imperative steps, condition first, present tense
Stacked Note/Warning boxesEverything shouted, nothing heardOne notice per section; the rest becomes body text
<your-key> or YOUR_API_KEY placeholdersReader types the brackets or reads the prefix as a literalAPI_KEY in caps, explained after the sample
Rewriting the meaning while "fixing style"Reviewer approves prose, ships wrong behaviorFacts unchanged; unknowns become TODO(verify)

Quick Diagnostic

QuestionIf NoAction
Does the first paragraph say who the doc is for and what they'll be able to do?Readers can't tell if they're on the right pageAdd audience, outcome, and non-scope statements
Does the doc type match the reader's task (tutorial · how-to · concept · reference · README)?Concept and steps interleave; nothing is findableSplit by type; link between pages
Is every command, flag, parameter, and behavior verified against code or the user?The doc teaches something falseVerify or mark TODO(verify); not shippable until fixed
Do headings read as a sentence-case table of contents (tasks imperative, concepts noun phrases)?Scanning fails; "-ing" headings hide the actionRewrite headings; add one where each new task starts
Are all sequences numbered steps, one imperative action each, condition first?Readers miss steps or act before checkingConvert paragraphs to steps; move conditions forward
Is every code sample introduced by a colon sentence, with ALL_CAPS placeholders explained?Readers paste literals or don't know what the sample doesAdd intro sentences; fix and explain placeholders
Is the text in second person, active voice, present tense, with no please/simply/just and no anthropomorphism?Instructions read as narrationRewrite sentence by sentence; cut filler
Are links descriptive, cross-refs "see"-based, images alt-texted, tables headed?Screen readers and reflow break the pageFix each; move image-only information into text
Is it timeless — no "currently/new/soon", no pre-announced features?The doc rots the day it shipsRemove time words; describe only shipped behavior
[EN] Does it follow the word list, serial comma, contractions, and American spelling — or the local guide?Small inconsistencies erode trustApply the word list; run Vale if configured

About the Source

Google's Developer Documentation Style Guide is the public house style that Google's technical writers maintain for developers.google.com, Android, and Google Cloud documentation; the companion Technical Writing One and Two courses are Google's internal engineer training, released publicly. This skill adapts both under CC BY 4.0 (per Google's site policies) and adds Keep a Changelog for release notes; it is an independent adaptation, not endorsed by Google.

Further Reading

© wondelai, 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 7 other files (references) in technical-documentation of wondelai/skills.

  • SKILL.md
  • references/api-reference.md
  • references/audit-checklist.md
  • references/document-types.md
  • references/procedures-and-code.md
  • references/release-notes.md
  • references/structure-and-formatting.md
  • references/voice-and-words.md

Open the folder on GitHubat commit c172996

Compare with similar skills

Technical Documentation 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 Documentation compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Technical Documentation this skillwondelai/skills2.4k—~5.4kAutomated safety check: PassMIT
Simple Englishmoeru-ai/airi50k2 repos~4.6kAutomated safety check: PassMIT
Ccb GitHubSeemSeam/claude_codex_bridge3.6k—~4.9kAutomated safety check: PassCustom licence
Golang Documentationunxed/f42413 repos~3.5kAutomated safety check: PassMIT
Simple Englishropensci/ckanr1043 repos~2kAutomated safety check: PassMIT
Opik Documentation Patternscomet-ml/opik22k—~1.3kAutomated safety check: PassApache-2.0

Similar skills

  • Simple English

    moeru-ai/airi

    Write or rewrite technical text with the rules of ASD-STE100 Simplified Technical English so it is clear, unambiguous, and free of AI slop.

    50k GitHub starsUsed in 2 repos~4.6k tokens
    DevelopmentAuto-check passed
  • Ccb GitHub

    SeemSeam/claude_codex_bridge

    Maintain this CCB project's GitHub-facing release and npm publication surface.

    3.6k GitHub stars~4.9k tokensUpdated today
    DevelopmentAuto-check passed
  • Comprehensive documentation guide for Golang projects, covering godoc comments, README, CONTRIBUTING, CHANGELOG, Go Playground, Example tests, API docs, and llms.txt.

    241 GitHub starsUsed in 3 repos~3.5k tokens
    DevelopmentAuto-check passed
  • Simple English

    ropensci/ckanr

    Write or rewrite text in plain, layman-readable English in the spirit of ASD-STE100 Simplified Technical English: short sentences, active voice, simple tenses, one word one meaning, condition before…

    104 GitHub starsUsed in 3 repos~2k tokens
    DevelopmentAuto-check passed
  • Rules for writing PR descriptions, changelog entries and feature documentation in the Opik repository, including the exact headings that CI requires.

    22k GitHub stars~1.3k tokensUpdated today
    DevelopmentAuto-check passed
  • Release

    jrswab/axe

    Prepare code for release (version bumps, changelog, README updates) and create an annotated tag to trigger the GoReleaser workflow.

    895 GitHub stars~1.4k tokensUpdated 3 days ago
    DevelopmentAuto-check passed

More from wondelai/skills

All 61 skills in this repo
  • Crossing The Chasm

    wondelai/skills

    Navigate the technology adoption lifecycle from early adopters to mainstream market.

    2.4k GitHub stars~3.6k tokensUpdated 27 days ago
    Auto-check passed
  • Design Everyday Things

    wondelai/skills

    Apply foundational design principles: affordances, signifiers, constraints, feedback, and conceptual models.

    2.4k GitHub stars~4k tokensUpdated 27 days ago
    Auto-check passed
  • Design Sprint

    wondelai/skills

    Run a structured 5-day process to prototype, test, and validate product ideas with real users.

    2.4k GitHub stars~3.8k tokensUpdated 27 days ago
    Auto-check passed
  • Hooked UX

    wondelai/skills

    Design habit-forming product loops using the Hook Model (Trigger, Action, Variable Reward, Investment).

    2.4k GitHub stars~3.5k tokensUpdated 27 days ago
    Auto-check passed
  • Improve Retention

    wondelai/skills

    Diagnose and fix retention problems using behavior design (B=MAP).

    2.4k GitHub stars~3.8k tokensUpdated 27 days ago
    Auto-check passed
  • Monetizing Innovation

    wondelai/skills

    Design products and pricing around validated willingness to pay, from Ramanujam & Tacke's "Monetizing Innovation".

    2.4k GitHub stars~5.2k tokensUpdated 27 days ago
    Auto-check passed

Categories

Questions about Technical Documentation

What does Technical Documentation do?

Audit, write, and improve developer documentation using Google's Developer Documentation Style Guide and Technical Writing courses. Technical Documentation is an agent skill from wondelai/skills. Audit, write, and improve developer documentation using Google's Developer Documentation Style Guide and Technical Writing courses.

When should I use Technical Documentation?

Technical Documentation fits situations like: any documentation work; even when the user names no style guide: audit our docs; review this README; getting started guide.

How do I install Technical Documentation in Claude Code?

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

How do I install Technical Documentation in Codex?

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

Can I use Technical Documentation 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 wondelai/skills --skill technical-documentation -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-documentation, .gemini/skills/technical-documentation, .github/skills/technical-documentation and .opencode/skills/technical-documentation in your project.

What does Technical Documentation need to run?

Going by SKILL.md and its folder, Technical Documentation needs credentials named API_KEY. Our summary lists: A credential in YOUR_API_KEY; A credential in API_KEY.

Does Technical Documentation access the network?

SKILL.md names 4 domains. As links in the text: developers.google.com, amazon.com, creativecommons.org and keepachangelog.com. This is read from the text; nothing was executed.

Is Technical Documentation 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 Documentation use?

Technical Documentation is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Technical Documentation use?

About 5.4k tokens (SKILL.md is roughly 22k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 29k tokens, read only when the agent opens those files.

What are the alternatives to Technical Documentation?

Skills that share tags, products or a category with Technical Documentation: Simple English (moeru-ai/airi, 50k stars), Ccb GitHub (SeemSeam/claude_codex_bridge, 3.6k stars), Golang Documentation (unxed/f4, 241 stars) and Simple English (ropensci/ckanr, 104 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Technical Documentation?

wondelai (a GitHub organization) maintains it in wondelai/skills, which has 2,356 GitHub stars. The repository holds 61 skills in this directory. The repository was last updated on September 10, 2026.

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