name: doc description: Generate and validate repo docs (default), READMEs (--mode=readme), and OSS doc packs (--mode=oss). practices:

wiki-knowledge-surface
code-complete
pragmatic-programmer hexagonal_role: supporting consumes:
repo-context produces:
documentation context_rel: [] skill_api_version: 1 context: window: fork intent: mode: task sections: exclude:
- HISTORY intel_scope: topic metadata: tier: product dependencies:
- standards
- council output_contract: documentation files

Doc Skill

YOU MUST EXECUTE THIS WORKFLOW. Do not just describe it.

Generate and validate documentation for any project. --mode selects the artifact family — the default mode handles code/API docs and code-maps; --mode=readme generates a gold-standard README; --mode=oss scaffolds and audits the open-source doc pack.

Modes

`--mode`	Artifact	Read first
(default)	API docs, code-maps, doc coverage/validation	this file
`readme`	Gold-standard README (interview → generate → council-validate)	references/readme-craft.md
`oss`	OSS doc pack (CONTRIBUTING/CHANGELOG/AGENTS.md, audit + scaffold)	references/oss-pack.md

Mode routing (absorbed skills):

You typed	Runs
"readme", "rewrite the README", "validate the README"	`/doc --mode=readme [...]`
"oss docs", "scaffold contributing", "audit OSS docs"	`/doc --mode=oss [...]`

When invoked with --mode=readme or --mode=oss, read the corresponding reference above and follow its workflow verbatim. The default-mode steps below apply only when no mode (or the implied code-docs mode) is selected.

Execution Steps (default mode — code/API docs)

Given /doc [command] [target]:

Step 1: Detect Project Type

# Check for indicators
ls package.json pyproject.toml go.mod Cargo.toml 2>/dev/null

# Check for existing docs
ls -d docs/ doc/ documentation/ 2>/dev/null

Classify as:

CODING: Has source code, needs API docs
INFORMATIONAL: Primarily documentation (wiki, knowledge base)
OPS: Infrastructure, deployment, runbooks

Step 2: Execute Command

discover - Find undocumented features:

# Find public functions without docstrings (Python)
grep -r "^def " --include="*.py" | grep -v '"""' | head -20

# Find exported functions without comments (Go)
grep -r "^func [A-Z]" --include="*.go" | head -20

coverage - Check documentation coverage:

# Count documented vs undocumented
TOTAL=$(grep -r "^def \|^func \|^class " --include="*.py" --include="*.go" | wc -l)
DOCUMENTED=$(grep -r '"""' --include="*.py" | wc -l)
echo "Coverage: $DOCUMENTED / $TOTAL"

gen [feature] - Generate documentation:

Read the code for the feature
Understand what it does
Generate appropriate documentation
Write to docs/ directory

all - Update all documentation:

Run discover to find gaps
Generate docs for each undocumented feature
Validate existing docs are current

Step 3: Generate Documentation

When generating docs, include:

For Functions/Methods:

## function_name

**Purpose:** What it does

**Parameters:**
- `param1` (type): Description
- `param2` (type): Description

**Returns:** What it returns

**Example:**
```python
result = function_name(arg1, arg2)

Notes: Any important caveats


**For Classes:**
```markdown
## ClassName

**Purpose:** What this class represents

**Attributes:**
- `attr1`: Description
- `attr2`: Description

**Methods:**
- `method1()`: What it does
- `method2()`: What it does

**Usage:**
```python
obj = ClassName()
obj.method1()


### Step 4: Create Code-Map (if requested)

**Write to:** `docs/code-map/`

```markdown
# Code Map: <Project>

## Overview
<High-level architecture>

## Directory Structure

src/ ├── module1/ # Purpose ├── module2/ # Purpose └── utils/ # Shared utilities


## Key Components

### Module 1
- **Purpose:** What it does
- **Entry point:** `main.py`
- **Key files:** `handler.py`, `models.py`

### Module 2
...

## Data Flow
<How data moves through the system>

## Dependencies
<External dependencies and why>

Step 5: Validate Documentation

Check for:

Out-of-date docs (code changed, docs didn't)
Missing sections (no examples, no parameters)
Broken links
Inconsistent formatting

Step 6: Write Report

Write to: .agents/doc/YYYY-MM-DD-<target>.md

# Documentation Report: <Target>

**Date:** YYYY-MM-DD
**Project Type:** <CODING/INFORMATIONAL/OPS>

## Coverage
- Total documentable items: <count>
- Documented: <count>
- Coverage: <percentage>%

## Generated
- <list of docs generated>

## Gaps Found
- <undocumented item 1>
- <undocumented item 2>

## Validation Issues
- <issue 1>
- <issue 2>

## Next Steps
- [ ] Document remaining gaps
- [ ] Fix validation issues

Step 7: Report to User

Tell the user:

Documentation coverage percentage
Docs generated/updated
Gaps remaining
Location of report

Key Rules

Detect project type first - approach varies
Generate meaningful docs - not just stubs
Include examples - always show usage
Validate existing - docs can go stale
Write the report - track coverage over time

Commands Summary

Command	Action
`discover`	Find undocumented features
`coverage`	Check documentation coverage
`gen [feature]`	Generate docs for specific feature
`all`	Update all documentation
`validate`	Check docs match code

Examples

Generating API Documentation

User says: /doc gen authentication

What happens:

Agent detects project type by checking for package.json and finding Node.js project
Agent searches codebase for authentication-related functions using grep
Agent reads authentication module files to understand implementation
Agent generates documentation with purpose, parameters, returns, and usage examples
Agent writes to docs/api/authentication.md with code samples
Agent validates generated docs match actual function signatures

Result: Complete API documentation created for authentication module with working code examples.

Checking Documentation Coverage

User says: /doc coverage