Option
HeimHeim Skill Dokumentation wiki-onboarding

wiki-onboarding

microsoft/skills microsoft/skills

Erstellt vier auf die jeweilige Zielgruppe zugeschnittene Einführungsanleitungen im Ordner „onboarding/“ – für Mitwirkende, Entwicklungsingenieure, Führungskräfte und Produktmanager. Verwenden Sie diese Funktion, wenn der Benutzer Einführungsunterlagen für eine Codebasis benötigt.

...Alle erweitern
0
Zeit aktualisiert 11. September 2026

Wiki-Onboarding-Leitfaden-Generator

Erstellen Sie vier auf die jeweilige Zielgruppe zugeschnittene Onboarding-Dokumente im Ordner „onboarding/“, wobei jedes Dokument einem anderen Beteiligten genau die Informationen liefert, die er benötigt.

Festlegung des Quell-Repositorys (MUSS ZUERST ERFOLGEN)

Bevor Sie Anleitungen erstellen, MÜSSEN Sie den Kontext des Quell-Repositorys ermitteln:

  1. Auf „git remote“ prüfen: Führen Sie „git remote get-url origin“ aus, um festzustellen, ob ein Remote vorhanden ist
  2. Fragen Sie den Benutzer: „Handelt es sich um ein rein lokales Repository oder haben Sie eine URL für das Quell-Repository (z. B. GitHub, Azure DevOps)?“
    • Remote-URL angegeben → als `REPO_URL` speichern, verknüpfte Verweise verwenden: [Datei:Zeile](REPO_URL/blob/BRANCH/file#Lline)
    • Nur lokal → lokale Zitate verwenden: (Dateipfad:Zeilennummer)
  3. Standardzweig ermitteln: „git rev-parse --abbrev-ref HEAD“ ausführen
  4. Fahren Sie NICHT fort, bis der Kontext des Quell-Repositorys geklärt ist

Wann aktivieren?

  • Der Benutzer fragt nach Onboarding-Dokumenten oder Einführungsanleitungen
  • Der Benutzer führt den Befehl ` /deep-wiki:onboard ` aus
  • Der Benutzer möchte neuen Teammitgliedern helfen, eine Codebasis zu verstehen

Ausgabestruktur

Erzeuge einen Ordner „onboarding/“ mit folgenden Dateien:

onboarding/
├── index.md                    # Onboarding-Hub – Links zu allen 4 Leitfäden mit Zielgruppenbeschreibungen
├── contributor-guide.md        # Für neue Mitwirkende (setzt Python- oder JS-Kenntnisse voraus)
├── staff-engineer-guide.md     # Für Staff- und Principal-Engineers
├── executive-guide.md          # Für technische Führungskräfte auf VP-/Direktorenebene
└── product-manager-guide.md    # Für Produktmanager und nicht-technische Stakeholder

index.md — Onboarding-Hub

Eine Landingpage mit:

  • Ein Absatz mit einer Projektzusammenfassung
  • Tabelle zur Auswahl der Leitfäden:
Leitfaden Zielgruppe Was Sie lernen werden Dauer
Leitfaden für Mitwirkende Neue Mitwirkende mit Python-/JS-Erfahrung Einrichtung, erster PR, Muster in der Codebasis ~30 Min.
Leitfaden für Staff Engineers Staff- und Principal-Engineers Architektur, Designentscheidungen, Systemgrenzen ~45 Min.
Leitfaden für Führungskräfte Vizepräsidenten/Leiter der Entwicklungsabteilung Fähigkeiten, Risiken, Teamstruktur, Investitionskonzept ~20 Min.
Leitfaden für Produktmanager Produktmanager Funktionen, User Journeys, Einschränkungen, Datenmodell ~20 Min.

Spracherkennung

Das Repository wird nach Build-Dateien durchsucht, um die Hauptsprache für Code-Beispiele zu ermitteln:

  • package.json / tsconfig.json → TypeScript/JavaScript
  • *.csproj / *.sln → C# / .NET
  • Cargo.toml → Rust
  • pyproject.toml / setup.py / requirements.txt → Python
  • go.mod → Go
  • pom.xml / build.gradle → Java

Leitfaden 1: Leitfaden für Mitwirkende

Datei: onboarding/contributor-guide.md Zielgruppe: Entwickler, die dem Projekt beitreten. Setzt Kenntnisse in Python oder JavaScript sowie allgemeine Erfahrung in der Softwareentwicklung voraus. Umfang: 1000–2500 Zeilen. Aufbauend – jeder Abschnitt baut auf dem vorherigen auf.

Erforderliche Abschnitte

Teil I: Grundlagen (überspringen, wenn das Repo Python oder JS verwendet)

  1. {Primärsprache} für Python-/JS-Entwickler – Tabellen zum Syntaxvergleich, asynchrones Modell, Sammlungen, Typsystem, Paketverwaltung. Konkrete Code-Beispiele im direkten Vergleich, KEINE abstrakten Beschreibungen.
  2. Grundlagen des {Primär-Frameworks} – Vergleich mit entsprechenden Python-/JS-Frameworks (z. B. FastAPI, Express). Request-Pipeline, Routing, DI, Konfiguration.

Teil II: Diese Codebasis 3. Was dieses Projekt leistet – 2–3-sätziger Elevator Pitch 4. Projektstruktur – Kommentierter Verzeichnisbaum (was befindet sich wo und warum). Füge eine grafische Übersicht über die TB-Architektur bei. 5. Kernkonzepte – Domänenspezifische Terminologie, erklärt anhand von Code-Beispielen. Verwende ein EDIagramm für das Datenmodell. 6. Lebenszyklus einer AnfrageSequenzdiagramm (mit automatischer Nummerierung), das eine typische Anfrage von Anfang bis Ende nachverfolgt. 7. Wichtige Muster – Vorlagen nach dem Motto „Wenn du X hinzufügen möchtest, folge diesem Muster“ mit echtem Code

Teil III: Produktiv werden 8. Voraussetzungen & Einrichtung – Tabelle: Tool, Version, Installationsbefehl. Schritt-für-Schritt-Anleitung mit erwarteter Ausgabe bei jedem Schritt. 9. Ihre erste Aufgabe – Durchgängige Anleitung zum Hinzufügen einer einfachen Funktion 10. Entwicklungs-Workflow – Branch-Strategie, Commit-Konventionen, PR-Prozess. Verwendung von Flussdiagrammen. 11. Tests ausführen – Alle Tests, einzelne Datei, einzelner Test, Befehle zur Testabdeckung 12. Debugging-Leitfaden – Tabelle mit häufigen Problemen: Symptom, Ursache, Lösung 13. Häufige Fallstricke – Fehler, die jeder neue Mitwirkende macht, und wie man sie vermeidet

Anhänge

  • Glossar (über 40 Begriffe)
  • Wichtige Dateireferenz – Tabelle: Pfad, Zweck, Bedeutung, Quelle
  • Schnellreferenzkarte – Spickzettel mit den am häufigsten verwendeten Befehlen und Mustern

Regeln

  • Alle Code-Beispiele in der erkannten Hauptsprache
  • Jeder Befehl muss kopierbar und einfügbar sein und die erwartete Ausgabe enthalten
  • Mindestens 5 Mermaid-Diagramme (Architektur, ER, Sequenz, Flussdiagramm, Zustandsdiagramm)
  • Verwende Mermaid für Workflow-Diagramme (Farben im Dunkelmodus) – füge Kommentarblock nach jedem
  • Alle Aussagen müssen durch tatsächlichen Code belegt sein – zitieren Sie im verlinkten Format

Leitfaden 2: Leitfaden für Staff Engineers

Datei: onboarding/staff-engineer-guide.md Zielgruppe: Staff-/Principal-Engineers, die das „Warum“ hinter jeder Entscheidung benötigen. Umfassende Systemerfahrung, kennen möglicherweise die Sprache dieses Repos nicht. Umfang: 800–1200 Zeilen. Dicht, meinungsstark, architektonisch ausgerichtet.

Erforderliche Abschnitte

  1. Zusammenfassung – Was das System ist, in einem prägnanten Absatz. Was es selbst übernimmt und was es delegiert.
  2. Die zentrale architektonische Erkenntnis — Das EINZIGE wichtigste Konzept. Füge Pseudocode in einer ANDEREN Sprache als der des Repos ein.
  3. Systemarchitektur – Vollständiges Mermaid -TB -Diagramm. Heben Sie das „Herzstück“ des Systems hervor.
  4. DomänenmodellMermaid-ER-Diagramm der Kernentitäten. Tabelle der Dateninvarianten: Entität, Invariante, Durchgesetzt von, Quelle.
  5. Wichtige Abstraktionen und SchnittstellenKlassendiagramm, das die tragenden Abstraktionen zeigt.
  6. Anfrage-LebenszyklusSequenzdiagramm (mit automatischer Nummerierung), das eine typische Anfrage vom Eingang bis zur Antwort darstellt.
  7. Zustandsübergänge„stateDiagram-v2“ für Entitäten mit aussagekräftigen Lebenszykluszuständen.
  8. Entscheidungsprotokoll – Tabelle: Entscheidung, in Betracht gezogene Alternativen, Begründung, Quelle.
  9. Begründung der Abhängigkeiten – Tabelle: Abhängigkeit, Zweck, Was sie ersetzt hat, Quelle.
  10. Datenfluss und Zustand — Wie Daten durch das System fließen. Vergleichstabelle für Speicherorte.
  11. Fehlermodi und FehlerbehandlungFlussdiagramm für Fehlerausbreitungswege.
  12. Leistungsmerkmale – Engpässe, Skalierungsgrenzen, Hot-Paths.
  13. Sicherheitsmodell – Authentifizierung, Autorisierung, Vertrauensgrenzen, Datensensibilität.
  14. Teststrategie – Was getestet wird, was nicht, Testphilosophie.
  15. Bekannte technische Schulden – Tabelle: Problem, Risikostufe, betroffene Dateien, Quelle.
  16. Wo man tiefer einsteigen sollte – Empfohlene Lesereihenfolge der Quelldateien, Links zu Wiki-Abschnitten.

Regeln

  • Verwende Pseudocode in einer anderen Sprache, um Konzepte zu erklären
  • Verwende Vergleichstabellen, um unbekannte Konzepte abzubilden (z. B. Task = Awaitable[T])
  • Dichte Prosa mit Tabellen, KEINE oberflächlichen Aufzählungen
  • Jede Behauptung muss durch einen verlinkten Verweis untermauert sein
  • Mindestens 5 Mermaid-Diagramme (Architektur, ER, Klasse, Sequenz, Zustand, Flussdiagramm)
  • Auf jedes Diagramm folgt Kommentarblock
  • Tabellen großzügig einsetzen – Entscheidungen, Abhängigkeiten und technische Schulden sollten ALLE in Tabellen mit „Quelle“-Spalten dargestellt werden
  • Konzentrieren Sie sich darauf, WARUM Entscheidungen getroffen wurden, nicht nur darauf, WAS vorhanden ist

Leitfaden 3: Leitfaden für Führungskräfte

Datei: onboarding/executive-guide.md Zielgruppe: VP/Leiter der Entwicklungsabteilung. Benötigt einen Überblick über die Funktionen, eine Risikobewertung und den Investitionskontext – KEINE Details auf Code-Ebene. Umfang: 400–800 Zeilen. Strategisch, prägnant, entscheidungsorientiert.

Erforderliche Abschnitte

  1. Systemübersicht – Was es leistet, wer es nutzt, geschäftlicher Nutzen in 2–3 Sätzen
  2. Funktionsübersicht – Tabelle: Funktion, Status (implementiert/teilweise/geplant), Reifegrad, Abhängigkeiten. Was das System heute leisten kann und was nicht.
  3. Architektur im ÜberblickMermaid-Diagramm auf hoher Ebene (LR-Diagramm ). Dienste, Datenspeicher, externe Integrationen – KEINE internen Code-Details. Fokus auf Bereitstellungseinheiten und Teamgrenzen.
  4. Teamtopologie – Welches Team/welche Person ist für welche Komponenten verantwortlich? Tabelle: Komponente, Verantwortlicher, Kritikalität, Bus-Faktor.
  5. Technologie-Investitionskonzept – Warum diese Technologien ausgewählt wurden. Tabelle: Technologie, Zweck, in Betracht gezogene Alternativen, Risikostufe.
  6. Risikobewertung – Tabelle: Risiko, Eintrittswahrscheinlichkeit, Auswirkung, Risikominderung, Verantwortlicher. Bezieht Zuverlässigkeit, Sicherheit, Skalierbarkeit und Compliance ein.
  7. Kosten- und Skalierungsmodell – Wie skalieren die Kosten mit der Nutzung? Wo liegen die Engpässe? Wann ist die nächste Skalierungsinvestition erforderlich?
  8. AbhängigkeitskarteTB-Diagramm, das kritische externe Abhängigkeiten darstellt. Tabelle: Abhängigkeit, Typ (Dienst/Bibliothek/Plattform), Risiko bei Nichtverfügbarkeit.
  9. Wichtige Kennzahlen und Überwachbarkeit – Was gemessen wird, welche Dashboards vorhanden sind, Abdeckung durch Warnmeldungen. Tabelle: Kennzahl, aktueller Wert, Zielwert, Quelle.
  10. Abgleich der Roadmap — Zuordnung der technischen Arbeitsströme zu den geschäftlichen Prioritäten. Was ist in Arbeit, was ist geplant, was ist blockiert?
  11. Zusammenfassung der technischen Schulden – Die 5 wichtigsten Schuldenposten mit geschäftlichen Auswirkungen. Tabelle: Problem, geschäftliche Auswirkungen, Aufwand für die Behebung, Priorität.
  12. Empfehlungen – 3–5 umsetzbare Empfehlungen für das nächste Quartal, priorisiert nach Auswirkungen.

Regeln

  • KEINE Code-Schnipsel – dieser Leitfaden richtet sich an technische Führungskräfte, nicht an Programmierer
  • Diagramme auf Service-/Teamebene, nicht auf Klassen-/Funktions-Ebene
  • Jede Aussage muss durch Belege gestützt werden – zitieren Sie Wiki-Abschnitte, Architekturdokumente oder Quelldateien
  • Mindestens 3 Mermaid-Diagramme (Architekturübersicht, Abhängigkeitskarte, Funktionen/Roadmap)
  • Tabellen für jede strukturierte Erkenntnis – diese Zielgruppe liest Tabellen, keine Prosa
  • Geschäftssprache – technische Konzepte in Auswirkungen übersetzen (Zuverlässigkeit, Geschwindigkeit, Kosten, Risiko)

Leitfaden 4: Leitfaden für Produktmanager

Datei: onboarding/product-manager-guide.md Zielgruppe: Produktmanager und nicht-technische Stakeholder. Sie müssen verstehen, was das System leistet, was möglich ist und wo die Grenzen liegen – NICHT, wie es aufgebaut ist. Umfang: 400–800 Zeilen. Nutzerorientiert, funktionsfokussiert, unter Berücksichtigung von Einschränkungen.

Erforderliche Abschnitte

  1. Was dieses System leistet – 2–3-zeiliger Elevator Pitch in nutzerorientierter Sprache (ohne Fachjargon)
  2. User-Journey-Map – Mermaid -Diagramm (LR ) oder Journey -Diagramm, das die primären Nutzerabläufe durch das System darstellt
  3. Funktionsübersicht – Tabelle: Funktion, Status (Live/Beta/Geplant/Nicht möglich), benutzerseitiges Verhalten, Einschränkungen. Umfassende Übersicht darüber, was implementiert ist und was nicht.
  4. Datenmodell (Produktsicht) – Vereinfachtes Mermaid-erDiagram, das die Entitäten darstellt, mit denen Nutzer interagieren. Erläutern Sie dies in geschäftlichen Begriffen (z. B. „Ein Projekt hat viele Dokumente“ statt „FK-Beziehung“).
  5. Konfiguration & Feature-Flags — Tabelle: Flag/Konfiguration, Was es steuert, Standardwert, Wer kann es ändern. Was ohne technische Arbeit umgeschaltet werden kann.
  6. API-Funktionen – Welche Integrationen sind möglich? Tabelle: Funktion, Endpunkt/Methode, Authentifizierung, Ratenbegrenzungen. Für Integrationspartner verfasst, nicht für Entwickler.
  7. Leistung & SLAs – Antwortzeiten, Durchsatzgrenzen, Verfügbarkeitsziele. Tabelle: Vorgang, erwartete Latenz, Durchsatzgrenze, aktuelles SLA.
  8. Bekannte Einschränkungen & Grenzen – Ehrliche Auflistung dessen, was das System nicht kann oder nur schlecht beherrscht. Tabelle: Einschränkung, Auswirkungen auf den Nutzer, Workaround, geplante Behebung.
  9. Daten & Datenschutz – Welche Daten werden erfasst, wo werden sie gespeichert, Aufbewahrungsrichtlinien, Compliance-Status. Tabelle: Datentyp, Speicherort, Aufbewahrungsfrist, Compliance.
  10. Glossar – Fachbegriffe in verständlicher Sprache erklärt (kein technischer Jargon)
  11. FAQ – Über 10 häufig gestellte Fragen, die ein Projektmanager stellen würde, prägnant beantwortet

Regeln

  • KEIN Fachjargon – kein „Middleware“, „Dependency Injection“, „ORM“. Verwende einfache Sprache.
  • Nutzerorientierte Darstellung – Beschreiben Sie alles aus der Perspektive der Nutzererfahrung, nicht aus der Perspektive der Funktionsweise des Codes
  • Mindestens 3 Mermaid-Diagramme (User Journey, Datenmodell, Feature Map/Funktionsübersicht)
  • Tabellen für jede strukturierte Erkenntnis – Produktmanager überfliegen Tabellen, nicht Prosatexte
  • Wenn ein technisches Konzept erwähnt werden muss, erkläre es in einem Satz (z. B. „Feature-Flags – Schalter, mit denen wir Funktionen aktivieren/deaktivieren können, ohne Code bereitzustellen“)
  • Jede Behauptung muss durch Belege untermauert sein – zitieren Sie zur Überprüfung Wiki-Abschnitte oder Quelldateien

Regeln für Mermaid-Diagramme (ALLE Leitfäden)

ALLE Diagramme müssen Farben im Dark-Mode verwenden:

  • Knotenfüllung: #2d333b, Rahmen: #6d5dfc, Text: #e6edf3
  • Hintergründe von Teilgraphen: #161b22, Rahmen: #30363d
  • Linien: #8b949e
  • Bei Verwendung von Inline -Stil -Anweisungen dunkle Füllfarben mit `color:#e6edf3` verwenden
  • Verwende KEINE
    in Mermaid-Beschriftungen (verwenden Sie stattdessen
    oder Zeilenumbrüche)

Validierung

Überprüfen Sie nach der Erstellung jedes Leitfadens Folgendes:

  • Alle genannten Dateipfade tatsächlich im Repo vorhanden sind
  • Alle Klassen- und Methodennamen korrekt sind (keine Fantasieangaben)
  • Mermaid-Diagramme werden korrekt gerendert (keine Syntaxfehler)
  • Es gibt keine bloßen HTML-ähnlichen Tags (Generika wie „List“) außerhalb von Code-Blöcken – diese müssen in Backticks eingeschlossen werden
  • Jeder Leitfaden ist für seine Zielgruppe geeignet – kein Code in Leitfäden für Führungskräfte/Projektmanager
Auf GitHub ansehen
---
name: wiki-onboarding
description: Generates four audience-tailored onboarding guides in an onboarding/ folder — Contributor, Staff Engineer, Executive, and Product Manager. Use when the user wants onboarding documentation for a codebase.
license: MIT
---

# Wiki Onboarding Guide Generator

Generate four audience-tailored onboarding documents in an `onboarding/` folder, each giving a different stakeholder exactly the understanding they need.

## Source Repository Resolution (MUST DO FIRST)

Before generating any guides, 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

## When to Activate

- User asks for onboarding docs or getting-started guides
- User runs `/deep-wiki:onboard` command
- User wants to help new team members understand a codebase

## Output Structure

Generate an `onboarding/` folder with these files:

```
onboarding/
├── index.md                    # Onboarding hub — links to all 4 guides with audience descriptions
├── contributor-guide.md        # For new contributors (assumes Python or JS background)
├── staff-engineer-guide.md     # For staff/principal engineers
├── executive-guide.md          # For VP/director-level engineering leaders
└── product-manager-guide.md    # For product managers and non-engineering stakeholders
```

### `index.md` — Onboarding Hub

A landing page with:
- **One-paragraph project summary**
- **Guide selector table**:

| Guide | Audience | What You'll Learn | Time |
|-------|----------|-------------------|------|
| [Contributor Guide](./contributor-guide.md) | New contributors with Python/JS experience | Setup, first PR, codebase patterns | ~30 min |
| [Staff Engineer Guide](./staff-engineer-guide.md) | Staff/principal engineers | Architecture, design decisions, system boundaries | ~45 min |
| [Executive Guide](./executive-guide.md) | VP/directors of engineering | Capabilities, risks, team topology, investment thesis | ~20 min |
| [Product Manager Guide](./product-manager-guide.md) | Product managers | Features, user journeys, constraints, data model | ~20 min |

## Language Detection

Scan the repository for build files to determine the primary language for code examples:
- `package.json` / `tsconfig.json` → TypeScript/JavaScript
- `*.csproj` / `*.sln` → C# / .NET
- `Cargo.toml` → Rust
- `pyproject.toml` / `setup.py` / `requirements.txt` → Python
- `go.mod` → Go
- `pom.xml` / `build.gradle` → Java

---

## Guide 1: Contributor Guide

**File**: `onboarding/contributor-guide.md`
**Audience**: Engineers joining the project. Assumes proficiency in Python or JavaScript and general software engineering experience.
**Length**: 1000–2500 lines. Progressive — each section builds on the last.

### Required Sections

**Part I: Foundations** (skip if repo uses Python or JS)
1. **{Primary Language} for Python/JS Engineers** — Syntax comparison tables, async model, collections, type system, package management. Concrete code side-by-side, NOT abstract descriptions.
2. **{Primary Framework} Essentials** — Compare to equivalent Python/JS frameworks (e.g., FastAPI, Express). Request pipeline, routing, DI, config.

**Part II: This Codebase**
3. **What This Project Does** — 2-3 sentence elevator pitch
4. **Project Structure** — Annotated directory tree (what lives where and why). Include `graph TB` architecture overview.
5. **Core Concepts** — Domain-specific terminology explained with code examples. Use `erDiagram` for data model.
6. **Request Lifecycle** — `sequenceDiagram` (with `autonumber`) tracing a typical request end-to-end.
7. **Key Patterns** — "If you want to add X, follow this pattern" templates with real code

**Part III: Getting Productive**
8. **Prerequisites & Setup** — Table: Tool, Version, Install Command. Step-by-step with expected output at each step.
9. **Your First Task** — End-to-end walkthrough of adding a simple feature
10. **Development Workflow** — Branch strategy, commit conventions, PR process. Use `flowchart` diagram.
11. **Running Tests** — All tests, single file, single test, coverage commands
12. **Debugging Guide** — Common issues table: Symptom, Cause, Fix
13. **Common Pitfalls** — Mistakes every new contributor makes and how to avoid them

**Appendices**
- **Glossary** (40+ terms)
- **Key File Reference** — Table: Path, Purpose, Why It Matters, Source
- **Quick Reference Card** — Cheat sheet of most-used commands and patterns

### Rules
- All code examples in the detected primary language
- Every command must be copy-pasteable with expected output
- **Minimum 5 Mermaid diagrams** (architecture, ER, sequence, flowchart, state)
- Use Mermaid for workflow diagrams (dark-mode colors) — add `<!-- Sources: ... -->` comment block after each
- Ground all claims in actual code — cite using linked format

---

## Guide 2: Staff Engineer Guide

**File**: `onboarding/staff-engineer-guide.md`
**Audience**: Staff/principal engineers who need the "why" behind every decision. Deep systems experience, may not know this repo's language.
**Length**: 800–1200 lines. Dense, opinionated, architectural.

### Required Sections

1. **Executive Summary** — What the system is in one dense paragraph. What it owns vs delegates.
2. **The Core Architectural Insight** — The SINGLE most important concept. Include pseudocode in a DIFFERENT language from the repo.
3. **System Architecture** — Full Mermaid `graph TB` diagram. Call out the "heart" of the system.
4. **Domain Model** — Mermaid `erDiagram` of core entities. Data invariants table: Entity, Invariant, Enforced By, Source.
5. **Key Abstractions & Interfaces** — `classDiagram` showing load-bearing abstractions.
6. **Request Lifecycle** — `sequenceDiagram` (with `autonumber`) showing typical request from entry to response.
7. **State Transitions** — `stateDiagram-v2` for entities with meaningful lifecycle states.
8. **Decision Log** — Table: Decision, Alternatives Considered, Rationale, Source.
9. **Dependency Rationale** — Table: Dependency, Purpose, What It Replaced, Source.
10. **Data Flow & State** — How data moves through the system. Storage comparison table.
11. **Failure Modes & Error Handling** — `flowchart` for error propagation paths.
12. **Performance Characteristics** — Bottlenecks, scaling limits, hot paths.
13. **Security Model** — Auth, authorization, trust boundaries, data sensitivity.
14. **Testing Strategy** — What's tested, what isn't, testing philosophy.
15. **Known Technical Debt** — Table: Issue, Risk Level, Affected Files, Source.
16. **Where to Go Deep** — Recommended reading order of source files, links to wiki sections.

### Rules
- Use **pseudocode in a different language** to explain concepts
- Use **comparison tables** to map unfamiliar concepts (e.g., `Task<T>` = `Awaitable[T]`)
- Dense prose with tables, NOT shallow bullet lists
- Every claim backed by linked citation
- **Minimum 5 Mermaid diagrams** (architecture, ER, class, sequence, state, flowchart)
- Each diagram followed by `<!-- Sources: ... -->` comment block
- **Use tables aggressively** — decisions, dependencies, debt should ALL be tables with Source columns
- Focus on WHY decisions were made, not just WHAT exists

---

## Guide 3: Executive Guide

**File**: `onboarding/executive-guide.md`
**Audience**: VP/director of engineering. Needs capability overview, risk assessment, and investment context — NOT code-level details.
**Length**: 400–800 lines. Strategic, concise, decision-oriented.

### Required Sections

1. **System Overview** — What it does, who uses it, business value in 2-3 sentences
2. **Capability Map** — Table: Capability, Status (Built/Partial/Planned), Maturity, Dependencies. What the system can and cannot do today.
3. **Architecture at a Glance** — High-level Mermaid `graph LR` diagram. Services, data stores, external integrations — NO internal code details. Focus on deployment units and team boundaries.
4. **Team Topology** — Which team/person owns which components. Table: Component, Owner, Criticality, Bus Factor.
5. **Technology Investment Thesis** — Why these technologies were chosen. Table: Technology, Purpose, Alternatives Considered, Risk Level.
6. **Risk Assessment** — Table: Risk, Likelihood, Impact, Mitigation, Owner. Cover reliability, security, scalability, compliance.
7. **Cost & Scaling Model** — How costs scale with usage. What the bottlenecks are. When the next scaling investment is needed.
8. **Dependency Map** — `graph TB` showing critical external dependencies. Table: Dependency, Type (Service/Library/Platform), Risk if Unavailable.
9. **Key Metrics & Observability** — What's measured, what dashboards exist, alerting coverage. Table: Metric, Current Value, Target, Source.
10. **Roadmap Alignment** — Engineering workstreams mapped to business priorities. What's in progress, what's planned, what's blocked.
11. **Technical Debt Summary** — Top 5 debt items with business impact. Table: Issue, Business Impact, Effort to Fix, Priority.
12. **Recommendations** — 3-5 actionable recommendations for the next quarter, prioritized by impact.

### Rules
- **NO code snippets** — this guide is for engineering leaders, not coders
- **Diagrams at service/team level**, not class/function level
- **Every claim backed by evidence** — cite wiki sections, architecture docs, or source files
- **Minimum 3 Mermaid diagrams** (architecture overview, dependency map, capability/roadmap)
- Tables for every structured finding — this audience reads tables, not prose
- **Business language** — translate technical concepts into impact (reliability, velocity, cost, risk)

---

## Guide 4: Product Manager Guide

**File**: `onboarding/product-manager-guide.md`
**Audience**: Product managers and non-engineering stakeholders. Needs to understand what the system does, what's possible, and where the boundaries are — NOT how it's built.
**Length**: 400–800 lines. User-centric, feature-focused, constraint-aware.

### Required Sections

1. **What This System Does** — 2-3 sentence elevator pitch in user-facing language (no jargon)
2. **User Journey Map** — Mermaid `graph LR` or `journey` diagram showing primary user flows through the system
3. **Feature Capability Map** — Table: Feature, Status (Live/Beta/Planned/Not Possible), User-Facing Behavior, Limitations. Comprehensive map of what's built and what's not.
4. **Data Model (Product View)** — Simplified Mermaid `erDiagram` showing entities users interact with. Explain in business terms (e.g., "A Project has many Documents" not "FK relationship").
5. **Configuration & Feature Flags** — Table: Flag/Config, What It Controls, Default, Who Can Change It. What can be toggled without engineering work.
6. **API Capabilities** — What integrations are possible. Table: Capability, Endpoint/Method, Authentication, Rate Limits. Written for integration partners, not developers.
7. **Performance & SLAs** — Response times, throughput limits, availability targets. Table: Operation, Expected Latency, Throughput Limit, Current SLA.
8. **Known Limitations & Constraints** — Honest list of what the system can't do or does poorly. Table: Limitation, User Impact, Workaround, Planned Fix.
9. **Data & Privacy** — What data is collected, where it's stored, retention policies, compliance status. Table: Data Type, Storage Location, Retention, Compliance.
10. **Glossary** — Domain terms explained in plain language (not engineering jargon)
11. **FAQ** — 10+ common questions a PM would ask, answered concisely

### Rules
- **ZERO engineering jargon** — no "middleware", "dependency injection", "ORM". Use plain language.
- **User-centric framing** — describe everything in terms of what users experience, not how code works
- **Minimum 3 Mermaid diagrams** (user journey, data model, feature map/capability overview)
- Tables for every structured finding — PMs scan tables, not prose
- If a technical concept must be mentioned, explain it in one sentence (e.g., "Feature flags — toggles that let us turn features on/off without deploying code")
- Every claim grounded in evidence — cite wiki sections or source files for verification

---

## Mermaid Diagram Rules (ALL guides)

ALL diagrams must use dark-mode colors:
- Node fills: `#2d333b`, borders: `#6d5dfc`, text: `#e6edf3`
- Subgraph backgrounds: `#161b22`, borders: `#30363d`
- Lines: `#8b949e`
- If using inline `style` directives, use dark fills with `,color:#e6edf3`
- Do NOT use `<br/>` in Mermaid labels (use `<br>` or line breaks)

## Validation

After generating each guide, verify:
- All file paths mentioned actually exist in the repo
- All class/method names are accurate (not hallucinated)
- Mermaid diagrams render (no syntax errors)
- No bare HTML-like tags (generics like `List<T>`) outside code fences — wrap in backticks
- Each guide is appropriate for its audience — no code in Executive/PM guides

Alle Dateien

0 Dateien

wiki-onboarding installieren

Laden Sie die Skill-Dateien herunter und entpacken Sie sie in Ihr Verzeichnis „.claude/skills/“.

ZIP herunterladen

Klonen Sie das Repository und kopieren Sie die Skill-Dateien in Ihr Projekt.

git clone https://github.com/microsoft/skills/tree/main/.github/plugins/deep-wiki/skills/wiki-onboarding # Copy SKILL.md to your .claude/skills/ directory

Kopieren Kopieren
Schnelle Einrichtung: Kopiere den Skill-Ordner nach „.claude/skills/“. Claude erkennt den Skill automatisch und nutzt ihn.
Repository microsoft/skills

Ähnliche Skills

golang-dependency-injection
Zeit aktualisiert 29. Juni 2026
nuxthub
Zeit aktualisiert 23. August 2026
tc-tracker
Zeit aktualisiert 27. August 2026
code-quality
Zeit aktualisiert 22. August 2026
OR