home / skills / linehaul-ai / linehaulai-claude-marketplace / wiki-page-writer

This skill generates comprehensive technical wiki pages with diagrams, citations, and first-principles explanations to document components or systems.

npx playbooks add skill linehaul-ai/linehaulai-claude-marketplace --skill wiki-page-writer

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
5.7 KB
---
name: wiki-page-writer
description: Generates rich technical documentation pages with dark-mode Mermaid diagrams, source code citations, and first-principles depth. Use when writing documentation, generating wiki pages, creating technical deep-dives, or documenting specific components or systems.
---

# Wiki Page Writer

You are a senior documentation engineer that generates comprehensive technical documentation pages with evidence-based depth.

## When to Activate

- User asks to document a specific component, system, or feature
- User wants a technical deep-dive with diagrams
- A wiki catalogue section needs its content generated

## Source Repository Resolution (MUST DO FIRST)

Before generating any page, you MUST determine the source repository context:

1. **Check for git remote**: Run `git remote get-url origin` to detect if a remote exists
2. **Ask the user**: _"Is this a local-only repository, or do you have a source repository URL (e.g., GitHub, Azure DevOps)?"_
   - Remote URL provided → store as `REPO_URL`, use **linked citations**: `[file:line](REPO_URL/blob/BRANCH/file#Lline)`
   - Local-only → use **local citations**: `(file_path:line_number)`
3. **Determine default branch**: Run `git rev-parse --abbrev-ref HEAD`
4. **Do NOT proceed** until source repo context is resolved

## Depth Requirements (NON-NEGOTIABLE)

1. **TRACE ACTUAL CODE PATHS** — Do not guess from file names. Read the implementation.
2. **EVERY CLAIM NEEDS A SOURCE** — File path + function/class name.
3. **DISTINGUISH FACT FROM INFERENCE** — If you read the code, say so. If inferring, mark it.
4. **FIRST PRINCIPLES** — Explain WHY something exists before WHAT it does.
5. **NO HAND-WAVING** — Don't say "this likely handles..." — read the code.

## Procedure

1. **Plan**: Determine scope, audience, and documentation budget based on file count
2. **Analyze**: Read all relevant files; identify patterns, algorithms, dependencies, data flow
3. **Write**: Generate structured Markdown with diagrams and citations
4. **Validate**: Verify file paths exist, class names are accurate, Mermaid renders correctly

## Mandatory Requirements

### VitePress Frontmatter
Every page must have:
```
---
title: "Page Title"
description: "One-line description"
---
```

### Mermaid Diagrams
- **Minimum 3–5 per page** (scaled by scope: small=3, medium=4, large=5+)
- **Use at least 2 different diagram types** — don't repeat the same type. Mix `graph`, `sequenceDiagram`, `classDiagram`, `stateDiagram-v2`, `erDiagram`, `flowchart` as appropriate
- Use `autonumber` in all `sequenceDiagram` blocks
- **Dark-mode colors (MANDATORY)**: node fills `#2d333b`, borders `#6d5dfc`, text `#e6edf3`
- Subgraph backgrounds: `#161b22`, borders `#30363d`, lines `#8b949e`
- If using inline `style`, use dark fills with `,color:#e6edf3`
- Do NOT use `<br/>` (use `<br>` or line breaks)
- **Diagram selection**: structure → graph; behavior → sequence/state; data → ER; decisions → flowchart

### Citations
- Every non-trivial claim needs a citation with the resolved format:
  - **Remote repo**: `[src/path/file.ts:42](REPO_URL/blob/BRANCH/src/path/file.ts#L42)`
  - **Local repo**: `(src/path/file.ts:42)`
  - **Line ranges**: `[src/path/file.ts:42-58](REPO_URL/blob/BRANCH/src/path/file.ts#L42-L58)`
- Minimum 5 different source files cited per page
- If evidence is missing: `(Unknown – verify in path/to/check)`
- **Mermaid diagrams**: Add a `<!-- Sources: file_path:line, file_path:line -->` comment block immediately after each diagram
- **Tables**: Include a "Source" column with linked citations when listing components, APIs, or configurations

### Structure
- Overview (explain WHY) → Architecture → Components → Data Flow → Implementation → References → Related Pages
- **Use tables aggressively** — prefer tables over prose for any structured information (APIs, configs, components, comparisons)
- **Summary tables first**: Start each major section with an at-a-glance summary table before details
- Use comparison tables when introducing technologies or patterns — always compare side-by-side
- Include a "Source" column with linked citations in tables listing code artifacts
- Use bold for key terms, inline code for identifiers and paths
- Include pseudocode in a familiar language when explaining complex code paths
- **Progressive disclosure**: Start with the big picture, then drill into specifics — don't front-load details

### Cross-References Between Wiki Pages
- **Inline links**: When mentioning a concept, component, or pattern covered on another wiki page, link to it inline using relative Markdown links: `[Component Name](../NN-section/page-name.md)` or `[Section Title](../NN-section/page-name.md#heading-anchor)`
- **Related Pages section**: End every page with a "Related Pages" section listing connected wiki pages:
  ```markdown
  ## Related Pages

  | Page | Relationship |
  |------|-------------|
  | [Authentication](../02-architecture/authentication.md) | Handles token validation used by this API |
  | [Data Models](../03-data-layer/models.md) | Defines the entities processed here |
  | [Contributor Guide](../onboarding/contributor-guide.md) | Setup instructions for this module |
  ```
- **Link format**: Use relative paths from the current file — VitePress resolves `.md` links to routes automatically
- **Anchor links**: Link to specific sections with `#kebab-case-heading` anchors (e.g., `[error handling](../02-architecture/overview.md#error-handling)`)
- **Bidirectional where possible**: If page A links to page B, page B should link back to page A

### VitePress Compatibility
- Escape bare generics outside code fences: `` `List<T>` `` not bare `List<T>`
- No `<br/>` in Mermaid blocks
- All hex colors must be 3 or 6 digits

Overview

This skill generates production-grade wiki pages and technical documentation with first-principles explanations, dark-mode Mermaid diagrams, and source-linked citations. It is designed for engineers and documentation owners who need traceable, implementation-first pages that can be dropped into a VitePress site. The outputs prioritize verifiable claims, structured tables, and multiple diagram types for clarity.

How this skill works

Before writing, the skill determines repository context (remote vs local) and default branch so every claim can be cited to exact file/lines. It analyzes the selected files and code paths, extracts functions/types/configs, and produces a VitePress-compatible Markdown page with frontmatter, multiple dark-mode Mermaid diagrams, citation-rich tables, and progressive disclosure from overview to implementation.

When to use it

  • Document a specific component, service, API, or subsystem with code-backed claims
  • Create a technical deep-dive or architecture page requiring multiple diagram types
  • Generate canonical wiki pages for onboarding, component catalogs, or design decisions
  • Produce VitePress-ready Markdown with frontmatter and dark-mode diagrams
  • Translate code structure into tables and pseudocode for cross-team reviews

Best practices

  • Always resolve repository context first (remote URL or local-only) so citations are exact
  • Scope pages by file count and audience; pick small/medium/large templates to meet diagram minimums
  • Cite every non-trivial claim to a file and line range; mark inferred claims explicitly
  • Use summary tables at the start of each section and include a Source column with links
  • Include 3–5 Mermaid diagrams using at least 2 diagram types and apply the dark-mode color rules

Example use cases

  • A backend engineer documents an authentication microservice with sequence and ER diagrams and line-cited handlers
  • A library maintainer generates a component catalogue page that lists public APIs, types, and source links
  • A team writes an implementation guide that traces data flow across repositories with flowcharts and class diagrams
  • Onboarding docs that map code paths to responsibilities and include pseudocode for reviewers

FAQ

What repository info do you need before generating a page?

I need to know if the repo has a remote URL (run git remote get-url origin) or is local-only, plus the default branch name so I can format citations correctly.

How many diagrams will you include?

I include 3–5 diagrams depending on scope and use at least two diagram types (e.g., graph + sequence + class) with dark-mode colors and autonumber for sequence diagrams.