Documentation
READMEs, API references, code comments, changelogs and developer guides.
Download all 89
- Document a public API
Writes reference docs for a module's exported functions, classes or endpoints in the native doc-comment format, covering real behaviour, errors and edge cases. Use before a release.
- Write a changelog entry
Turns the commits and pull requests in a release range into a user-facing changelog entry in Keep a Changelog format, with breaking changes first. Use when cutting a release.
- Write a migration guide
Writes an upgrade guide for a breaking release that lists each breaking change with how to find affected code, before-and-after examples and a way to verify. Use when shipping a major version.
- Write a README
Writes or improves a project README from what the code actually does, with an install and quick start that work when copied. Use for a new project or a README that has drifted.
- Annotate a config file
Adds comments to a config file such as Kubernetes YAML, nginx, tsconfig or a CI pipeline, explaining each non-default setting, its default and why it is set.
- Audit a documentation set
Audits documentation for accuracy against the code, gaps in the user journey, stale pages, duplication and findability, and returns a prioritised fix list. Use before a docs overhaul or release.
- Audit a README for conversion
Audits an open-source README or landing page as a funnel from first glance to first successful run, and returns ranked fixes with rewritten sections. Use before a launch.
- Build an SDK example app
Builds a small runnable example app for one framework that shows an SDK's main flows end to end, with a README, pinned versions, env-based config and a CI check that it still runs.
- Code comment rules
Standing rules for the comments and docstrings an assistant writes - explain why not what, document public APIs fully, no commented-out code, owned TODOs, and keep comments true when code changes.
- Comment complex code
Adds why-comments to tricky code, such as non-obvious logic, workarounds, invariants and ordering constraints, without restating what the code already says.
- Convert a diagram image to Mermaid
Turns a whiteboard photo, screenshot or exported diagram into editable Mermaid or PlantUML of the right diagram type, listing every label or arrow it could not read instead of guessing.
- Deduplicate docs with reusable snippets
Finds content repeated across docs pages, such as install steps, version requirements and warnings, and replaces it with shared snippets or includes so a change is made once.
- Docs site overhaul track
Overhauls developer docs in gated steps, from inventory and reader journeys to a new structure with redirects, rewritten top pages, tested code samples and a process that keeps docs current.
- Document API conventions
Writes the API fundamentals page covering pagination, errors, rate limits, idempotency, versioning, timestamps and IDs, checked against how the real endpoints behave.
- Document configuration options
Writes a configuration reference from code or a schema, with every option and env var, its type, default, allowed values, precedence, restart needs and old names, kept in sync by generation.
- Document a data pipeline
Documents a batch or streaming data pipeline with its sources and sinks, schedule, lineage, owners, failure handling, backfill and rerun instructions, checked against the orchestration code.
- Document dbt models
Writes dbt model and column descriptions in YAML with reusable doc blocks, stated grain, keys and tests, checked against the SQL, so the generated docs site answers analysts' questions.
- Document error codes
Turns the error codes and messages in a codebase or API into an error catalog with cause, fix, retry safety and a stable URL per error that the message can link to. Use for APIs, SDKs and CLIs.
- Document a firmware hardware interface
Writes the hardware interface document for a board and its firmware, with pinout, buses and addresses, power and reset, timing limits, debug connectors and the board revision it applies to.
- Document a reusable GitHub Action
Writes the README and action.yml descriptions for a reusable GitHub Action, with inputs, outputs, token permissions, runner support, versioning and copy-ready examples taken from the code.
- Document a GraphQL schema
Writes descriptions for every GraphQL type, field, argument and enum value, with deprecation reasons, nullability meaning and example queries that run against the real schema.
- Document a Helm chart
Documents a Helm chart's values with descriptions, types, defaults and examples, and writes a README covering install, common setups, upgrades and uninstall, checked against the templates.
- Document cloud infrastructure
Documents cloud infrastructure from Terraform and notes, with a resource inventory per environment, network diagram, access paths, environment differences and what code does not manage.
- Document a Jupyter notebook
Adds a summary, section headings, explanations, stated assumptions and conclusions to a Jupyter notebook so a colleague can follow its reasoning and rerun it top to bottom.
- Document message topics and queues
Writes a catalog of Kafka topics or message queues with owners, producers, consumers, schemas, keys, ordering, retention and dead-letter handling for internal teams.
- Document a permissions matrix
Reads a product's authorization checks and documents what each role can do as a reference table for admins and support, with every cell traced to code.
- Document a repo's task scripts
Documents a repo's existing Makefile targets, npm scripts, justfile recipes or scripts folder with grouped descriptions, a help command and a developer commands section, without changing behaviour.
- Document a Protobuf and gRPC API
Documents gRPC services and Protobuf messages with comments on every service, RPC, message, field and enum, the status codes each RPC returns, and generated reference pages.
- Document scheduled jobs
Finds every cron job, scheduled task and recurring worker across code and infrastructure config, and documents schedule, time zone, purpose, failure impact and rerun steps.
- Document a shell script
Adds a usage header, a --help option, examples, environment variables, dependencies and exit codes to a shell script so someone else can run it safely, without changing what it does.
- Document a Terraform module
Writes the README for an existing Terraform module with purpose, requirements, inputs, outputs, usage examples and upgrade notes, and sets up terraform-docs markers so the tables stay current.
- Document an undocumented module from its code
Reads an undocumented module and writes the missing developer doc - purpose, entry points, data flow, side effects, configuration and traps - with every claim tied to code and unknowns listed.
- Document webhook events
Writes the webhook reference for an API, with an event catalog and example payloads, delivery and retry rules, ordering and duplicates, signature verification, endpoint requirements and testing.
- Document a WebSocket or SSE API
Documents a WebSocket or Server-Sent Events API with connection and auth, every message type in both directions, event sequences, heartbeats, reconnection and error handling.
- Draw a database ER diagram
Draws entity-relationship diagrams in Mermaid or DBML from a schema or ORM models, grouped by domain, with keys, cardinality from real constraints and relationships that exist only in code.
- Draw a state diagram from the code
Finds every place a status field is written and draws the real state diagram, flagging states that cannot be reached or left, unguarded transitions and transitions the docs promise but code lacks.
- Edit a technical documentation draft
Edits a developer docs draft in three passes - accuracy questions for the author, structure for the page type, then sentence clarity - with traceable edits, not a silent rewrite.
- Find and fix broken links in documentation
Checks a documentation folder or site source for broken internal links, anchors and images, fixes the internal ones, and lists external replacements for a person to confirm. Use before a docs release.
- Fix stale code comments
Finds comments and docstrings that no longer match the code beside them, such as wrong parameters, old behaviour or dead TODOs, and fixes or deletes each one.
- Generate a third-party notices file
Generates a third-party notices file listing every shipped dependency with its licence text and copyright lines, from the lockfile and installed packages, ready to bundle.
- Improve error messages in code
Rewrites error messages in a module, CLI or API to say what happened, why and how to fix it, in a consistent voice, without leaking internals or breaking callers.
- Improve OpenAPI descriptions
Enriches a thin OpenAPI spec with operation summaries, parameter and field descriptions, examples and missing error responses so the generated reference is actually useful.
- Migrate a wiki to docs as code
Moves pages exported from Confluence, Notion, Google Docs or Word into Markdown in a repository, with triage, a clean structure, converted macros, fixed links and images, owners and redirects.
- Reorganise docs by Diátaxis
Sorts every page of a docs tree into tutorial, how-to, reference or explanation, finds pages that mix modes, and proposes a new navigation with splits, merges and redirects.
- Review developer docs for translation
Reviews docs-as-code source for translation blockers like text in images, built sentences, code mixed into prose and unstable anchors, and returns fixes, a do-not-translate list and page priorities.
- Set up generated API reference docs
Sets up API reference generated from doc comments with TypeDoc, Sphinx autodoc, rustdoc, Javadoc or similar, limited to the public surface, checked in CI and published per release version.
- Set up docs linting in CI
Adds docs checks to CI with Vale, markdownlint and link checking, tuned to the project's own style and current pages so the checks catch real problems without a flood of false alarms.
- Set up a docs site
Sets up a documentation site with Docusaurus, MkDocs Material, Sphinx or Starlight from existing Markdown, with navigation, search, optional versioning, broken-link checks and deploy on merge.
- Update the docs a code change made stale
Finds the documentation a code change affects, such as READMEs, API docs, guides and examples, updates it to match, and runs the code snippets to prove they still work. Use before merging a change.
- Technical writer
Writes and edits developer documentation that is accurate to the code, task-oriented and easy to scan. Use as the voice for READMEs, API references, guides and changelogs.
- Test the code in docs
Makes the code samples in docs and READMEs run in CI with doctests, extracted snippets or compiled example files, plus fixtures for secrets and network, so broken samples fail the build.
- Translate code comments to English
Translates comments, docstrings and developer log messages in a codebase into clear English, without touching code, identifiers or strings that users see.
- Triage docs feedback
Clusters docs feedback, page ratings, support tickets and failed searches into ranked fixes, each naming the page to change and what to change on it.
- Turn a discussion into a docs page
Turns a Slack thread, issue discussion or meeting transcript into an accurate docs page, keeping only what was settled and flagging the points still open.
- Write an API authentication guide
Writes the authentication page for an API covering API keys or OAuth 2.0 flows, scopes, token lifetime and refresh, auth errors and safe secret storage, with working examples.
- Write an API quickstart
Writes an API quickstart that gets a developer to a first successful call in minutes, with credentials, one request, the expected response and common errors. Use for a new or hard-to-adopt API.
- Write a CLI reference
Writes the help text, man page and web reference for a command-line tool from its argument parser, with synopsis, options grouped by task, exit codes, environment variables and real examples.
- Write code samples for an SDK or API
Writes runnable code samples for SDK or API operations across languages, with one shared structure, idiomatic error handling and expected output. Use when docs need multi-language samples.
- Write a step-by-step code tutorial
Writes a technical tutorial a reader can follow end to end, with pinned prerequisites, complete runnable snippets and a checkpoint after every step. Use for docs, blog tutorials or workshop material.
- Write a supported versions and compatibility page
Writes the supported platforms and versions page for a library, SDK or product, separating what is tested, supported and best-effort, with end-of-support dates and how the policy is applied.
- Write dataset documentation
Documents a maintained dataset that a data team publishes for other teams or partners, with grain, schema and units, freshness, known gaps, privacy, change policy and an example query.
- Write a developer cheat sheet
Writes a one-page cheat sheet of the commands, patterns and gotchas for a tool, framework or repository, checked against the installed version or the repo itself.
- Write a documentation home page
Writes the home page of a documentation site that routes each kind of reader to the right first page in one click, built from top tasks and search data rather than the product's org chart.
- Write a docs style guide
Writes a short style guide for developer docs from existing pages, covering voice, terms, headings, code samples, admonitions, screenshots and versioning, plus lint rules to enforce it.
- Write an embed installation guide
Writes install instructions for a JavaScript widget or snippet across plain HTML, React, Next.js, WordPress and Shopify, with verification, consent and Content Security Policy notes.
- Write a concept explanation page
Writes a docs explanation page that builds a mental model of one concept in a system - why it exists, how it works, trade-offs and common misreadings - with no step-by-step instructions.
- Write a how-to guide for one task
Writes a how-to guide for a reader who knows the basics, with a goal-named title, prerequisites, numbered steps with expected results, a verification step and links instead of tangents.
- Write a multi-platform installation guide
Writes the installation page for a library or command-line tool across operating systems and package managers, with prerequisites, verification steps and fixes for common install failures.
- Write a JSON Schema for a config file
Writes a JSON Schema with descriptions, defaults and examples for a tool's YAML, JSON or TOML config file, so editors validate and autocomplete it, matched to what the code accepts.
- Write llms.txt for a docs site
Writes an llms.txt file and plain Markdown versions of key docs pages so AI assistants and coding agents can read a project's current docs accurately, kept in sync by the docs build.
- Write an MCP server README
Writes the README for a Model Context Protocol server, with its tool and resource catalogue, install snippets for each client, required credentials, permissions and safety notes.
- Write a mobile SDK integration guide
Writes the install and setup guide for an iOS and Android SDK, with package manager steps, permissions and manifest entries, initialisation, privacy declarations and platform pitfalls.
- Write a modding guide
Writes a modding guide for a game's players, covering file layout, data formats, the scripting API, a first working mod in 15 minutes, load order, compatibility and what is unsupported.
- Write a developer onboarding guide
Writes an onboarding guide for a repository covering setup, an architecture map, first tasks and known gotchas, with every command checked against the repo. Use for new hires or contributors.
- Write an OpenAPI spec from code
Writes an OpenAPI 3 spec for an existing REST API from its routes, handlers and models, with schemas, errors, auth and examples checked against what the code really does.
- Write an ownership handover doc
Writes the handover for a system whose owner is leaving or changing team, with what it does, where it runs, deploy and rollback, known issues, jobs, where secrets live and a first-week checklist.
- Write a partner integration guide
Writes an end-to-end integration guide for partners building on your API, from sandbox access through required flows, edge cases and a test checklist to go-live and support.
- Write a plugin developer guide
Writes the guide for third parties building plugins or extensions for your product, covering the plugin lifecycle, APIs and permissions, a first working plugin, testing and publishing.
- Write a glossary for a project's docs
Builds a glossary of a project's domain and internal terms from its docs and code, with one meaning per term, the code name beside the user-facing name, conflicts flagged and terms to retire.
- Write release notes
Turns merged pull requests or commits into release notes for a chosen audience, grouped by impact and written as outcomes without internal jargon. Use when shipping a version.
- Write the release process doc
Writes RELEASING.md from a repository's real release setup, with preconditions, versioning, exact commands, what CI does, checks after publishing, rollback, hotfixes and who can release.
- Write a reproducibility README
Writes the README for a research or machine learning repo that lets others reproduce its results, with environment, data access, exact commands, compute needs, seeds and expected outputs.
- Write a self-hosting guide
Writes the self-hosting guide for a server application, covering requirements, install with Docker or packages, configuration, TLS, upgrades, backups and restore, and monitoring.
- Write an internal service README
Writes the README for an internal service with owners, purpose, upstream and downstream dependencies, dashboards, runbooks, SLOs, deploy steps and how to run it locally.
- Write an SSO setup guide for customer admins
Writes the customer-facing guide for configuring SAML or OIDC single sign-on with Okta, Microsoft Entra ID and Google Workspace, with field mappings, testing and troubleshooting.
- Write Storybook docs for a component
Writes Storybook docs for a UI component with documented props, one story per meaningful state, usage guidance, do and don't examples and accessibility notes, in the repo's Storybook style.
- Write a support enablement doc
Writes the internal doc that teaches support how a feature works, its limits, settings, likely problems, how to diagnose them and when to escalate, from code and specs.
- Write a repository testing guide
Writes a repository's testing guide covering how to run each suite or a single test, required services, where new tests go, fixtures and mocking conventions, snapshots and debugging failures.
- Write a troubleshooting guide
Writes a troubleshooting guide organised by symptom, with likely causes in order, diagnostic commands, fixes and when to escalate, from support tickets or issue threads.
Not: non-technical writing (writing-communication domain); ADRs (architecture).