Your team can write the code.The docs are the part nobody does.
Six skills that read your codebase and write the documentation around it — README, API reference, ADRs, onboarding, changelogs — structured by Diátaxis, the framework that separates docs that work from docs that confuse. Plus a real script that returns DOCUMENTED or GAPS so you know what’s actually covered.
Documentation is the debt every team carries.
Every team admits it: the README is stale, the API is undocumented, nobody wrote down why the architecture is the way it is, and onboarding a new dev means a senior loses a day to setup questions. Docs are the work that’s always important and never urgent — so it never happens.
And when teams do generate docs with AI, they usually get worse than nothing: a wall of text that mixes a tutorial, a reference, and an explanation into something no reader can use — or, worse, docs that confidently describe features the code doesn’t have.
Documentation is always important and never urgent, so it never happens. The README goes stale, the API stays undocumented, and the reason the architecture is the way it is lives only in one senior's head.
AI-generated docs usually blur tutorial, reference, and explanation into a wall no reader can navigate — or confidently describe features the code doesn't have. Structure and accuracy are the whole game.
Every new hire costs a senior a day of setup questions because the first-day path was never written down. The tribal knowledge stays tribal until someone captures it from the repo.
Clear about the lane. No inflated promises.
- Six production-grade SKILL.md skills with NEVER/ALWAYS guardrails and worked examples.
- A real, runnable docs-coverage-auditor.py — stdlib, DOCUMENTED/GAPS, coverage %, non-zero CI exit.
- A hybrid: Codex reads the code for accuracy; the Claude skills shape the prose to Diátaxis.
- Format fidelity — Nygard & MADR for ADRs, Keep a Changelog for changelogs — plus a Diátaxis primer.
- An AGENTS.md companion and cross-tool install (Codex, Claude Code, Cursor, Gemini, Copilot).
- No invented features — the skills document what the code does, never aspirational behavior.
- No overwriting — skills propose, the auditor reads only, you place the output.
- Not a docs hosting / site generator — it writes the content; pair with your MkDocs/Docusaurus.
- No editing of accepted ADRs — supersede, don't rewrite (immutability respected).
- No SaaS, no monthly fee, no telemetry — your code never leaves your environment.
Six skills + an auditor that runs.
The front door, the reference, the decisions, the first day, the release — then proof of coverage. Every skill is single-purpose and composes with the others.
“write a README,” “improve our README,” “document this project”
Builds the project front door from the real repo, structured by Diátaxis — quickstart as tutorial, key how-tos, links out to reference. Describes what exists, never aspirational features.
“document this API,” “write the API reference,” “document these functions”
Drafts neutral, precise reference from actual signatures — params, types, returns, errors, real examples. Marks inferred behavior as inferred; never invents a parameter the code doesn't have.
“write an ADR,” “record this decision,” “document why we chose”
Captures decisions in Nygard or MADR format with honest consequences. Respects ADR immutability — supersedes rather than edits, and updates both records. Names an owner, not 'the team.'
“write an onboarding guide,” “help new devs get started,” “ramp-up doc”
Builds the first-day path from the repo — exact prerequisites, verified setup, codebase tour, a real first task. Captures the tribal knowledge that usually lives only in a senior's head.
“write the changelog,” “generate release notes,” “what changed this release”
Turns commits into human release notes in Keep a Changelog format — grouped, meaningful, breaking changes surfaced. Translates implementation detail to user impact, not a git-log dump.
“what's undocumented,” “are the docs up to date,” runs in CI
A real, runnable script that scans the repo and returns DOCUMENTED or GAPS with a coverage % and locations — undocumented symbols, missing README, drift. Exits non-zero so it gates CI.
Built on Diátaxis — why the docs are actually usable.
Most AI-generated docs fail because they blur the four documentation needs into mush. Diátaxis — by Daniele Procida, the framework behind Cloudflare, Canonical, and Django docs — keeps them distinct. Every skill in this pack writes to the right quadrant. It’s a hybrid: Codex reads the code for accuracy, the Claude skills shape it to structure.
A lesson that takes a newcomer to a first success, on rails. The README quickstart and the onboarding guide live here.
A recipe for someone who already knows what they want. The 'how to deploy' and usage sections.
Neutral, precise facts about the machinery. The API reference drafter writes only this — no teaching, no selling.
The mental model and the reasoning. ADRs live here — why the architecture is the way it is.
The pack ships a Diátaxis primer, but you never have to learn it — the skills apply it for you. That’s the difference between text that looks like docs and documentation a developer can actually navigate.
The auditor actually runs. Here’s real output.
This is docs-coverage-auditor.py against a repo with undocumented exports, no README, and a drifted doc — not a screenshot of a promise. It measured coverage, found the gaps, caught the drift, and exited non-zero. Coverage you can prove, not assume.
$ python scripts/docs-coverage-auditor.py .
GAPS doc coverage: 1/3 symbols (33%) critical=3 warning=2
------------------------------------------------------------------------
GAPS (undocumented public surface / missing README) (3)
• [undocumented-export] src/api.ts:1
Exported/public symbol 'createUser' has no doc comment.
• [undocumented-export] src/api.ts:2
Exported/public symbol 'PaymentProcessor' has no doc comment.
• [missing-readme] .
No README found at the project root.
WARNINGS (thin docs / drift / endpoints) (2)
• [undocumented-endpoint] src/api.ts:9
API route/handler has no doc comment describing it.
• [doc-drift] docs/guide.md:3
Doc references `legacyMigrate()` which is not a defined symbol
in the codebase (possible drift).
Verdict: GAPS. Document the public surface above, then re-run.
$ echo $?
1Stdlib Python, no install. Reports a coverage %, finds undocumented symbols and endpoints, and catches drift — docs referencing code that no longer exists. JSON mode for CI.
The skills chain into complete documentation jobs.
A generic AI tool is a one-shot. A skill is a step in a workflow. Generation skills write; the auditor proves. Here’s how they run together.
Coverage proven, not assumed — find the gaps, fill them, then re-run to confirm.
Scans the repo and returns the gaps: undocumented public symbols, a missing README, drifted docs — with a coverage % to start from.
Builds the front door from the real repo, structured by Diátaxis — quickstart, key how-tos, links out to reference.
Documents the public surface from actual signatures, then a re-audit confirms DOCUMENTED. Coverage you can prove.
Users learn what changed; the team remembers why.
Turns the release's commits into human release notes in Keep a Changelog format — grouped, meaningful, breaking changes surfaced.
Records any significant decision the release embodies in Nygard/MADR format, with an owner and honest consequences — superseding, never editing.
Day one ends in a running app, not a Slack thread of setup questions.
Writes the verified first-day path from the repo — exact prerequisites, tested setup, a codebase tour, and a real first task.
Confirms the public surface a newcomer will hit is actually documented — so the guide doesn't dead-end at an undocumented function.
This pack documents the codebase. Two siblings cover the rest.
Exactly what you get for $99, and what you don’t: six skills and an auditor that document a codebase and prove coverage — not a tool that fixes the old code or guards the new. Three Codex packs cover the lifecycle: fix old code, guard new code, document all of it.
Codex Migration & Refactor Pack
$99Framework upgrades, dependency sweeps, monolith extraction, dead-code removal — with a runnable migration verifier. Fix the old code.
Codex Code-Review & PR-Hygiene Pack
$79PR descriptions, security smells, breaking-change detection, a runnable hygiene gate. Guard the new code on every PR.
The questions developers actually ask before installing.
Two things: structure and honesty. Structure — the skills are built on Diátaxis, the documentation framework (by Daniele Procida, used by Cloudflare, Canonical, and Django) that separates the four real documentation needs: tutorials for learning, how-to guides for a goal, reference for facts, and explanation for the why. A generic 'write my docs' prompt produces mush that mixes all four; these skills keep them distinct, which is what makes docs actually usable. Honesty — every skill documents what the code really does, never invented features, and the bundled auditor measures coverage rather than letting you assume it. It's the difference between text that looks like docs and documentation a developer can trust.
A dependency-free Python script (stdlib, no install) that scans your repo and returns DOCUMENTED or GAPS with a coverage percentage and file-and-line locations. It flags exported/public symbols with no doc comment, a missing or thin README, undocumented API endpoints, and documentation drift — markdown that references functions which no longer exist in the code. It exits non-zero on GAPS, so it drops into CI as a docs gate. It's the measurement layer: the generation skills write the docs, the auditor proves when you're actually done and catches docs that have rotted out of sync with the code.
It's a hybrid by design. The Codex side reads your codebase — real signatures, entry points, scripts, exports, commit history — which is where accurate documentation has to start. The Claude-skill side shapes that into well-structured prose that follows Diátaxis and the right format conventions (Nygard/MADR for ADRs, Keep a Changelog for changelogs). The skills follow the Agent Skills open standard, so they install in Codex, Claude Code, Cursor, Gemini CLI, and Copilot's agent mode. You get code-grounded accuracy and documentation-craft structure in one pack.
Each skill is a standard SKILL.md folder. In Codex, drop them in your skills directory (commonly ~/.agents/skills/ or ~/.codex/skills/) and Codex discovers them by description, or invoke one with /skills. In Claude Code, place them in ~/.claude/skills/. They also work in Cursor, Gemini CLI, and Copilot via the open standard. The docs-coverage-auditor ships a scripts/ folder that the agent runs natively. The pack includes an AGENTS.md companion you drop in your repo root so the documentation discipline — document only what exists, keep ADRs immutable, run the auditor before claiming done — applies on every session.
No. The skills generate and propose; you review and place the output. The auditor reads only — it never writes. Nothing is overwritten without your action. For ADRs in particular, the adr-writer respects immutability: it won't edit an accepted decision record; to change a decision it writes a new ADR that supersedes the old one and updates both records' references. Every change to your repo is explicit and yours to approve.
Diátaxis is a documentation framework that identifies four distinct kinds of docs — tutorials, how-to guides, reference, and explanation — each serving a different reader need and written differently. Mixing them is the most common cause of confusing documentation. You don't need to study it: the skills apply it for you (the README architect keeps the quickstart a tutorial and links out to reference; the API drafter writes neutral reference, not a sales pitch). A primer is included if you want the model in your head, but the value lands whether or not you read it.
They're the dev-team trio, each covering a different stage. This pack documents the codebase — README, API reference, ADRs, onboarding, changelogs — and proves coverage. The Migration & Refactor Pack ($99) fixes the old code (framework upgrades, dependency rot, dead code). The Code-Review & PR-Hygiene Pack ($79) guards the new code (PR gate, security smells, breaking changes). Fix it, guard it, document it — each ships its own runnable artifact, and all three cross-link.
Thirty days, no questions. Run the coverage auditor against a repo you think is well-documented — if it comes back DOCUMENTED, you've confirmed it for free; if it returns GAPS with a list of undocumented public functions and a drifted doc or two, the pack just earned its price. If it doesn't save your team real documentation time in the first 30 days, email us and we refund in full.
Clear the doc debt.
Prove it’s gone.
Run the auditor against a repo you think is well-documented. If it says DOCUMENTED, you’ve confirmed it free. If it returns GAPS with a list of undocumented functions, the pack just paid for itself. Thirty-day refund either way.
Sold by RedHub AI LLC · Secured by Stripe · redhub.ai