techdoc-writer

Converts engineering debugging sessions and git history into formal Rockchip-style technical documents.

Updated May 28, 2026
One-click install
npx skills add https://github.com/changfengpro/agent-skills --skill techdoc-writer-changfengpro
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: techdoc-writer
Source: https://github.com/changfengpro/agent-skills/tree/main/skills/techdoc-writer
Command: npx skills add https://github.com/changfengpro/agent-skills --skill techdoc-writer-changfengpro

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve? Engineering knowledge from debugging sessions, bring-up work, and deployment processes lives scattered across chat logs, git commits, and terminal output, making it hard for other engineers to reproduce the work. This Skill organizes that raw material into formal, official-style technical documents that readers can follow and verify on their own. ## Core Features & Use Cases - Document type classification: Distinguishes troubleshooting retrospectives (with a five-part fault analysis chapter) from guides/design documents (no fault chapter), preventing fabricated failure narratives. - Verifiable content: Solutions cite real git diffs split by hunk, logs are quoted verbatim, and every command consuming an input artifact documents its source, placement, and persistence across reflashes. - Rockchip Developer Guide skeleton: Preface, Chapter-N numbering, glossary with full term expansions, fault quick-reference tables, and revision history. - Dual output targets: Writes to Feishu (Lark) cloud docs via lark-doc/lark-whiteboard skills or local Markdown, with lint scripts enforcing format and phrasing rules. - Use Case: After fixing a UART DMA receive timeout on an embedded board, ask the Skill to turn the git commits and debug log into a formal troubleshooting document with fault analysis, real diffs, and a glossary. ## Quick Start Organize the debugging process from this repo's git history and debug.log into a formal Rockchip-style technical document and output it as a Markdown file.

Frequently Asked Questions about techdoc-writer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I turn a debugging session into a formal technical document?

Provide the git repository, debug logs, and session context, then request a formal document. The Skill collects commits and logs, classifies the document type, drafts a chapter outline for your confirmation, and writes the full document with real diffs and verbatim log quotes.

How to write a Rockchip Developer Guide style document?

The Skill applies the Rockchip skeleton by default: preface with revision history, Chapter-N numbered body, and appendix with glossary and references. You can also supply a reference PDF whose structure and tone it will extract and follow instead.

Can the generated document be published to Feishu (Lark) docs?

Yes. When given a Feishu link or asked to write to Feishu, it operates through the lark-doc skill and creates diagrams as Feishu whiteboards via lark-whiteboard. Without a Feishu target, it writes a local Markdown file using standard Markdown syntax.

When does the document include a troubleshooting chapter?

A fault diagnosis chapter appears only for debugging retrospectives or qualified mixed documents where fixes actually landed. Design docs, architecture proposals, and unimplemented guides never get a fault chapter, and trivial code typos are excluded from it.

Why does the document require real git diffs instead of rewritten code?

Solutions must be verifiable, so code changes are extracted from actual commits via git show and split by hunk into the relevant sections. Rewritten-from-memory code cannot be cross-checked by readers and is not accepted.

What quality checks run before the document is delivered?

Three lint scripts check phrasing rules, format mixing between Feishu and Markdown, and inline code wrapping of technical identifiers. After scripts pass, the AI still reads the full draft to catch duplication, broken references, and numbering gaps that scripts cannot detect.