| name | documentation |
| description | Documentation standards and best practices for code changes. Use when writing or reviewing documentation, adding public APIs, making user-facing changes, or checking documentation quality. Triggers on: 'use documentation mode', 'document', 'documentation', 'docstring', 'add docs', 'update docs', 'documentation review', 'API documentation', 'README update'. Full access mode - can write documentation and update code comments. |
| allowed-tools | ["Read","Edit","Write","Bash","Grep","Glob","LSP"] |
Documentation Standards
Write documentation that serves humans and AI agents. Keep it accurate, layered, and close to the code.
"Documentation is a love letter that you write to your future self." — Damian Conway
Documentation Hierarchy
Documentation lives in layers. Each layer has a distinct audience, scope, and update cadence.
| Layer | Audience | Scope | Update Frequency |
|---|
| Code comments | Maintainers, AI agents | Single block / decision | Every code change |
| Docstrings | Consumers, AI agents | Function / class contract | Every signature change |
| Module docs | Team members, onboarding | File / package purpose | When module role changes |
| Project docs (README, guides) | All stakeholders | System / feature | Every user-facing change |
| Architecture docs (ADRs) | Maintainers, future devs | Design decisions | When decisions are made |
Audience Matrix
| Audience | What They Need | Key Layers |
|---|
| Internal maintainers | Intent, trade-offs, edge cases | Comments, docstrings, ADRs |
| New team members | Orientation, key concepts, how things connect | Module docs, README, architecture |
| External users / consumers | How to use it, API contracts | README, API reference, how-to guides |
| AI agents | Purpose, contracts, intent behind decisions | Docstrings, architecture docs, comments |
Layer Rules
Code Comments
- Explain why, never what — the code already says what
- Mark non-obvious decisions, trade-offs, and workarounds
- Reference issue/ticket numbers for context:
// Workaround for #1234
- Delete rather than comment out dead code (use version control)
- Keep comments adjacent to the code they describe
Docstrings
- Public APIs: Complete — params, returns, raises/throws, brief description
- Internal/private: Concise — one-line purpose; skip if trivially obvious
- Skip entirely: Simple getters/setters, constructors with no logic, obvious wrappers
- Describe the contract (what), not the implementation (how)
- Include a usage example for non-trivial public APIs
Module / Package Docs
- Top-of-file docstring or comment: one paragraph explaining purpose
- List key classes/functions and their roles
- Describe usage patterns and entry points
- Update when the module's responsibility changes
Project Docs
Follow the Diátaxis framework (see below). Keep docs in the repo, close to what they describe.
- README: Project purpose, quickstart, key links — the front door
- CHANGELOG: User-facing changes per release
- Architecture docs: Design decisions, system structure, component relationships
- API reference: Generated or maintained per public surface
Diátaxis Quick Reference
Four types of documentation, each serving a different user need:
| Type | Orientation | Answers | Structure |
|---|
| Tutorial | Learning | "Follow these steps to learn X" | Step-by-step, hands-on, minimal explanation |
| How-to Guide | Task | "How to accomplish X" | Goal-oriented steps, assumes knowledge |
| Reference | Information | "Specification of X" | Precise, complete, consistent structure |
| Explanation | Understanding | "Why X works this way" | Conceptual, discursive, gives context |
Common mistakes:
- Mixing tutorial steps with reference details
- Writing a how-to guide as a tutorial (too many basics)
- Putting explanations in reference docs (keep them factual)
- Missing how-to guides (users know what they want to do, not where to look)
Quality Checklist
- [ ] Public APIs have complete docstrings (params, returns, raises)
- [ ] Code comments explain "why", not "what"
- [ ] No stale documentation (matches current behavior)
- [ ] User-facing changes reflected in README or relevant guides
- [ ] New modules have a brief purpose description at top of file
- [ ] Architecture-significant decisions documented (ADR or equivalent)
- [ ] Examples are runnable and up-to-date
- [ ] CHANGELOG updated for user-visible changes
Anti-Patterns
| Anti-Pattern | Problem | Correction |
|---|
| Comment restates the code | Noise, drifts out of sync | Delete or explain the why |
| Docstring describes implementation | Couples docs to internals | Focus on the contract (what, not how) |
| README lists features that don't exist | Misleading, erodes trust | Audit docs against actual behavior |
| Docs live only in PR/commit messages | Invisible to future readers | Move to permanent location in repo |
| Over-documenting trivial code | Clutter, maintenance burden | Skip obvious getters/setters/constructors |
| Copy-pasting docstrings across overloads | Drift between copies | Document the base, reference it from overloads |
| Huge top-of-file comment blocks | Nobody reads them | Keep to one paragraph; link to detailed docs |
Docstring Standards
Follow the standard specified by each language's instruction file. Do not invent custom formats.
| Language | Standard | Reference |
|---|
| Python | Google style | python.instructions.md — Documentation section |
| TypeScript | TSDoc | TSDoc conventions |
| JavaScript | JSDoc | JSDoc conventions |
When a language-specific instruction file doesn't cover documentation, apply these defaults:
- Public functions: brief description +
@param + @returns + @throws
- Classes: brief description + constructor params
- Interfaces/types: brief description of purpose and usage context
Agent-Specific Guidance
AI agents consume documentation differently than humans. Optimize for both.
What helps agents most:
| Documentation Element | Agent Benefit |
|---|
| Docstrings with typed params | Navigation, correct usage, type inference |
| Module-level purpose comments | Understanding component responsibility |
| Architecture docs | High-level context for cross-cutting changes |
| "Why" comments | Making correct decisions about modifications |
| Explicit contracts (pre/post conditions) | Safe refactoring boundaries |
Principles:
- Keep docs close to code — agents search files, not wikis
- Structured formats (tables, lists) are easier to parse than prose
- Be explicit about edge cases and invariants in docstrings
- Name things well — good names reduce the documentation needed
- When docs and code disagree, the code is right — fix the docs
