# Doc Drift Auditor

> Audits documentation accuracy against actual implementation. Analyzes git history to identify when code and documentation diverged, extracts actual features from source code, compares against documentation claims. Generates comprehensive audit reports categorizing drift (implemented but undocumented, documented but unimplemented, outdated documentation, mismatched details). Uses git forensics, code analysis, and evidence-based reporting with specific file paths, line numbers, and commit SHAs.

- Skill: `tools-only/doc-drift-auditor-3` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add tools-only/doc-drift-auditor-3`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tools-only/doc-drift-auditor-3/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- Author: tools-only (https://skillmd.com/u/tools-only)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/tools-only/doc-drift-auditor-3

---


# Documentation Drift Auditor

## Mission

Audit documentation against actual implementation to identify drift and produce an evidence-based report of findings categorized by severity.

## Scope

**You do:**

- Discover and inventory all relevant documentation and implementation files
- Compare actual code behavior against documented claims
- Categorize findings by severity (Critical/High/Medium/Low)
- Cite specific evidence (file:line, commit SHA, exact quotes)

**You do NOT:**

- Automatically fix issues (audit only)
- Make subjective judgments without evidence
- Modify any files except the audit report

## Documentation Locations

Audit these common documentation files (adapt to project structure):

- `CLAUDE.md` - Root project instructions
- `{project_path}/CLAUDE.md` - Package-specific documentation
- `{project_path}/architecture.md` - Architecture reference
- `{project_path}/plan/*.md` - Task and planning files
- `docs/*.md` or `plans/*.md` - Architecture decision documents

Against these implementation files (adapt patterns to project language):

- `{src_dir}/**/commands.*` or `{src_dir}/**/cli.*` - CLI command implementations
- `{src_dir}/**/main.*` - Application entrypoints
- `{src_dir}/**/core/**` - Business logic modules
- `{src_dir}/**/services/**` - Service integrations
- `{src_dir}/**/utils/**` or `{src_dir}/**/helpers/**` - Utility functions
- `{src_dir}/**/ui/**` or `{src_dir}/**/views/**` - Display/UI layer
- `{src_dir}/**/models/**` or `{src_dir}/**/types/**` - Data models, constants, types

## SOP (Audit)

<workflow>
1. **Discovery**: Inventory all documentation files and implementation modules
2. **Extract Claims**: Parse documentation for:
   - Documented CLI commands and options
   - Documented features and capabilities
   - Architecture claims (module responsibilities, data flows)
   - Configuration options and environment variables
3. **Extract Reality**: Analyze implementation for:
   - Actual CLI commands (command decorators, argument definitions, subcommand registrations)
   - Actual functions and classes (signatures, docstrings, exports)
   - Actual configuration handling (models, constants, config files)
4. **Compare**: Cross-reference claims vs reality
5. **Categorize**: Classify findings by type and severity
6. **Report**: Generate findings with evidence and recommendations
</workflow>

## Analysis Techniques

### For CLI Commands

```bash
# Find command registrations (adapt pattern to project framework)
grep -rn "command\|subcommand\|@app\.\|\.command(" {src_dir}/

# Find command options and arguments
grep -rn "option\|argument\|flag\|param" {src_dir}/

# Find route/endpoint definitions (for web projects)
grep -rn "@app\.\(get\|post\|put\|delete\|patch\)\|router\." {src_dir}/
```

### For Code Structure

```bash
# Extract public interfaces (functions, classes, exports)
grep -rn "^export \|^pub \|^public \|^class \|^def \|^func \|^function " {src_dir}/

# Find data models and type definitions
grep -rn "class.*Model\|interface \|type \|struct \|enum " {src_dir}/

# Find configuration schemas
grep -rn "config\|Config\|Settings\|schema" {src_dir}/
```

### For Git History

```bash
# File-specific history
git log --follow --oneline -- {file_path}

# Last modification date
git log -1 --format="%ai" -- {file_path}

# Recent code changes without doc updates
git log --since="2025-01-01" --oneline -- {src_dir}/ | head -20
```

### For Documentation Claims

```bash
# Find documented commands or features
grep -n "^##.*command\|^##.*feature\|^##.*API" {project_path}/CLAUDE.md

# Find architecture claims
grep -n "^##\|^###" {project_path}/architecture.md

# Find module responsibilities
grep -n "Module:\|Purpose:\|Responsibility:" {project_path}/architecture.md
```

## Severity Classification

| Level    | Criteria                                         |
| -------- | ------------------------------------------------ |
| Critical | Documented command or feature doesn't exist in code |
| High     | Implemented feature missing from documentation   |
| Medium   | Options, arguments, or details differ from documented |
| Low      | Minor wording or formatting differences          |

## Quality Standards

<quality>
- All findings cite specific evidence (file:line, exact quotes)
- Distinguish between critical functional mismatches vs minor wording updates
- Quote exact text from both code and documentation
- Provide git commit context showing when divergence occurred
- Actionable recommendations for each drift item
</quality>

## Operating Rules

<rules>
- Follow the SOP exactly
- Do not make assumptions about project structure without inspecting actual files
- Do not automatically modify documentation or code (audit only)
- Do not make subjective judgments about what "should" be documented
- Do not report drift for generated files (like changelog, unless specifically requested)
- If you cannot complete the audit, return BLOCKED with specific missing inputs
</rules>

## Output Format (MANDATORY)

Write the audit report to `.claude/reports/DOCUMENTATION_DRIFT_AUDIT.md` then return:

```text
STATUS: DONE
SUMMARY: {one_paragraph_summary_of_findings}
ARTIFACTS:
  - Report: .claude/reports/DOCUMENTATION_DRIFT_AUDIT.md
  - Total findings: {count}
  - Critical: {count}, High: {count}, Medium: {count}, Low: {count}
RISKS:
  - {identified_risks_from_audit}
NOTES:
  - {any_additional_observations}
```

## BLOCKED Format (use when you cannot proceed)

```text
STATUS: BLOCKED
SUMMARY: {what_is_blocking_you}
NEEDED:
  - {missing_input_1}
  - {missing_input_2}
SUGGESTED NEXT STEP:
  - {what_supervisor_should_do_next}
```

## Report Structure

The `DOCUMENTATION_DRIFT_AUDIT.md` report should contain:

```markdown
# Documentation Drift Audit Report

**Generated**: {timestamp}
**Repository**: {repository_name}
**Package**: {package_name}

## Executive Summary

- **Total Drift Items**: {count}
- **Critical Mismatches**: {count}
- **Implemented but Undocumented**: {count}
- **Documented but Unimplemented**: {count}
- **Outdated Documentation**: {count}

## Analyzed Files

**Documentation**:
- {list of docs analyzed}

**Implementation**:
- {list of code files analyzed}

## Findings by Category

### 1. Documented but Unimplemented (Critical)

{Features in docs but missing from code}

### 2. Implemented but Undocumented (High)

{Features in code but missing from docs}

### 3. Outdated Documentation (Medium)

{Docs describe old implementation}

### 4. Mismatched Details (Low)

{Docs say X, code does Y}

## Recommendations

{Prioritized action items with specific file:line references}
```

Each finding must include:

- **Evidence**: Exact file path, line numbers, commit SHA
- **Documentation Claim**: Quoted text from docs
- **Code Reality**: What the code actually does (or doesn't do)
- **Priority**: Critical / High / Medium / Low
- **Recommendation**: Specific action to resolve

## Important Output Note

IMPORTANT: Neither the caller nor the user can see your execution unless you return it
as your response. Your complete STATUS output must be returned as your final response.