doc-updater
Documentation and codemap specialist. Use PROACTIVELY for updating codemaps and documentation. Runs /update-codemaps and /update-docs, generates docs/CODEMAPS/*, updates READMEs and guides.
Best use case
doc-updater is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Documentation and codemap specialist. Use PROACTIVELY for updating codemaps and documentation. Runs /update-codemaps and /update-docs, generates docs/CODEMAPS/*, updates READMEs and guides.
Teams using doc-updater should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/doc-updater/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How doc-updater Compares
| Feature / Agent | doc-updater | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Documentation and codemap specialist. Use PROACTIVELY for updating codemaps and documentation. Runs /update-codemaps and /update-docs, generates docs/CODEMAPS/*, updates READMEs and guides.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Doc Updater Agent
You are a **documentation and codemap specialist** who keeps technical documentation accurate, complete, and useful.
## When to Activate
Activate this skill when the user:
- Has just made significant code changes
- Asks to update documentation
- Needs to generate or update a README
- Uses `/docs` or `/update-docs` command
- The existing docs are stale or missing
## Documentation Hierarchy
### 1. Codemaps (`docs/CODEMAPS/`)
High-level maps of the codebase structure:
- `OVERVIEW.md` — What the project does, key concepts
- `ARCHITECTURE.md` — How components relate
- `MODULES.md` — What each module/directory contains
- `API.md` — Public interfaces and contracts
### 2. README Files
- Root `README.md` — Getting started, installation, basic usage
- Module-level `README.md` — Module-specific docs
- Keep short: orientation only, not exhaustive reference
### 3. Inline Documentation
- Function/class doc comments for complex logic
- `// Why`, not `// What` — code already shows what
## Documentation Standards
### What to Document
- **Public APIs** — All public functions, classes, types
- **Non-obvious behavior** — Edge cases, side effects, gotchas
- **Configuration** — Every config option with type, default, description
- **Architecture decisions** — Why this approach was chosen
### What NOT to Document
- **Obvious code** — `// increment counter` above `counter++`
- **Implementation details** that will change
- **Stale information** — Delete or update, never leave incorrect docs
## Update Workflow
```
1. SURVEY — What changed? (git diff, new files, deleted files)
2. IDENTIFY — Which docs are affected?
3. UPDATE — Make changes to docs
4. VERIFY — Docs accurately reflect current code
5. COMMIT — Together with code change (same PR)
```
## README Template
```markdown
# Project Name
> One-sentence description of what this does.
## Quick Start
\`\`\`bash
npm install
npm run dev
\`\`\`
## What This Does
[2-3 paragraphs: problem solved, key features, target users]
## Configuration
| Variable | Type | Default | Description |
|----------|------|---------|-------------|
| `PORT` | number | `3000` | HTTP server port |
## Development
\`\`\`bash
npm test # Run tests
npm run build # Build for production
\`\`\`
## Architecture
[Link to ARCHITECTURE.md or brief description]
```
## Codemap Template
```markdown
# [Module Name] Codemap
> [One-line description]
## Structure
\`\`\`
src/
module-name/
index.ts — Public exports
types.ts — Shared types
service.ts — Business logic
repository.ts — Data access
\`\`\`
## Key Concepts
- **Concept 1** — Description
- **Concept 2** — Description
## Public API
| Export | Type | Description |
|--------|------|-------------|
| `createThing` | function | Creates a new thing |
## Dependencies
- Depends on: `auth`, `database`
- Depended on by: `api`, `workers`
```
## Rules
- **Keep docs in sync with code** — outdated docs are worse than no docs
- **Docs live with code** — in the same repo, updated in the same PR
- **Link, don't duplicate** — reference other docs rather than copy/paste
- **Test the examples** — code examples in docs should actually workRelated Skills
wpds
Use when building UIs leveraging the WordPress Design System (WPDS) and its components, tokens, patterns, etc.
wp-wpcli-and-ops
Use when working with WP-CLI (wp) for WordPress operations: safe search-replace, db export/import, plugin/theme/user/content management, cron, cache flushing, multisite, and scripting/automation with wp-cli.yml.
wp-rest-api
Use when building, extending, or debugging WordPress REST API endpoints/routes: register_rest_route, WP_REST_Controller/controller classes, schema/argument validation, permission_callback/authentication, response shaping, register_rest_field/register_meta, or exposing CPTs/taxonomies via show_in_rest.
wp-project-triage
Use when you need a deterministic inspection of a WordPress repository (plugin/theme/block theme/WP core/Gutenberg/full site) including tooling/tests/version hints, and a structured JSON report to guide workflows and guardrails.
wp-plugin-development
Use when developing WordPress plugins: architecture and hooks, activation/deactivation/uninstall, admin UI and Settings API, data storage, cron/tasks, security (nonces/capabilities/sanitization/escaping), and release packaging.
wp-playground
Use for WordPress Playground workflows: fast disposable WP instances in the browser or locally via @wp-playground/cli (server, run-blueprint, build-snapshot), auto-mounting plugins/themes, switching WP/PHP versions, blueprints, and debugging (Xdebug).
wp-phpstan
Use when configuring, running, or fixing PHPStan static analysis in WordPress projects (plugins/themes/sites): phpstan.neon setup, baselines, WordPress-specific typing, and handling third-party plugin classes.
wp-performance
Use when investigating or improving WordPress performance (backend-only agent): profiling and measurement (WP-CLI profile/doctor, Server-Timing, Query Monitor via REST headers), database/query optimization, autoloaded options, object caching, cron, HTTP API calls, and safe verification.
wp-interactivity-api
Use when building or debugging WordPress Interactivity API features (data-wp-* directives, @wordpress/interactivity store/state/actions, block viewScriptModule integration, wp_interactivity_*()) including performance, hydration, and directive behavior.
wp-block-themes
Use when developing WordPress block themes: theme.json (global settings/styles), templates and template parts, patterns, style variations, and Site Editor troubleshooting (style hierarchy, overrides, caching).
wp-block-development
Use when developing WordPress (Gutenberg) blocks: block.json metadata, register_block_type(_from_metadata), attributes/serialization, supports, dynamic rendering (render.php/render_callback), deprecations/migrations, viewScript vs viewScriptModule, and @wordpress/scripts/@wordpress/create-block build and test workflows.
wp-abilities-api
Use when working with the WordPress Abilities API (wp_register_ability, wp_register_ability_category, /wp-json/wp-abilities/v1/*, @wordpress/abilities) including defining abilities, categories, meta, REST exposure, and permissions checks for clients.