Generated banner for Wiki Page Writer
Generated logo for Wiki Page Writer

Wiki Page Writer

MicrosoftOfficialCreated by Microsoft

  • Skill
  • Content generator
  • Documents and content
  • MIT
  • No issues found

From the author

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.
— the description by Microsoft

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Wiki Page Writer is a documentation tool designed to create structured, evidence-based technical pages. It focuses on first-principles explanations, requiring the agent to analyze actual source code to generate content. The tool enforces specific formatting standards, including VitePress frontmatter, dark-mode Mermaid diagrams, and rigorous citation of code paths to ensure documentation remains grounded in the implementation.

What it does

  • Generates structured Markdown documentation with a focus on architecture and data flow
  • Creates dark-mode Mermaid diagrams including sequence, class, and flowchart types
  • Links documentation claims directly to source code files and line numbers
  • Organizes technical information into tables for APIs, configurations, and components
  • Ensures cross-referencing between related documentation pages
  • Requires source repository context to provide accurate file-based citations

When to use it

  • When documenting a specific software component, system, or feature
  • When creating technical deep-dives that require visual diagrams
  • When populating or updating a wiki catalogue section
  • When you need to ensure documentation is strictly mapped to existing code paths

Advantages

  • Maintains consistency through mandatory VitePress frontmatter and structure
  • Reduces ambiguity by requiring direct source code citations for claims
  • Improves readability by prioritizing tables for structured data
  • Ensures visual diagrams follow a consistent dark-mode aesthetic
  • Promotes a connected knowledge base through mandatory cross-referencing

Usage examples

“Document the authentication module in this repository.”
The agent analyzes the authentication source files, creates a sequence diagram of the login flow, and generates a Markdown page with tables detailing API endpoints and code citations.
“Create a technical deep-dive for the data processing pipeline.”
The agent reads the pipeline implementation, generates a flowchart and architecture diagram, and writes a document explaining the system's first principles with links to the relevant code.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/microsoft/wiki-page-writer/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip wiki-page-writer.zip -d .agents/skills

Documentation by Microsoft

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:

    ## 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

Files

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Node.js

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Microsoft
Publisher
Microsoft (Official)
Source
microsoft/skills · .github/plugins/deep-wiki/skills/wiki-page-writer · commit 0696600
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download wiki-page-writer.zip