wiki-onboarding
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 erweiternWiki-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:
- Auf „git remote“ prüfen: Führen Sie
„git remote get-url origin“aus, um festzustellen, ob ein Remote vorhanden ist - 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)
- Remote-URL angegeben → als
- Standardzweig ermitteln:
„git rev-parse --abbrev-ref HEAD“ausführen - 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# / .NETCargo.toml→ Rustpyproject.toml/setup.py/requirements.txt→ Pythongo.mod→ Gopom.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)
- {Primärsprache} für Python-/JS-Entwickler – Tabellen zum Syntaxvergleich, asynchrones Modell, Sammlungen, Typsystem, Paketverwaltung. Konkrete Code-Beispiele im direkten Vergleich, KEINE abstrakten Beschreibungen.
- 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 Anfrage – Sequenzdiagramm (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
- Zusammenfassung – Was das System ist, in einem prägnanten Absatz. Was es selbst übernimmt und was es delegiert.
- Die zentrale architektonische Erkenntnis — Das EINZIGE wichtigste Konzept. Füge Pseudocode in einer ANDEREN Sprache als der des Repos ein.
- Systemarchitektur – Vollständiges Mermaid
-TB-Diagramm. Heben Sie das „Herzstück“ des Systems hervor. - Domänenmodell –
Mermaid-ER-Diagrammder Kernentitäten. Tabelle der Dateninvarianten: Entität, Invariante, Durchgesetzt von, Quelle. - Wichtige Abstraktionen und Schnittstellen —
Klassendiagramm, das die tragenden Abstraktionen zeigt. - Anfrage-Lebenszyklus –
Sequenzdiagramm(mitautomatischer Nummerierung), das eine typische Anfrage vom Eingang bis zur Antwort darstellt. - Zustandsübergänge –
„stateDiagram-v2“für Entitäten mit aussagekräftigen Lebenszykluszuständen. - Entscheidungsprotokoll – Tabelle: Entscheidung, in Betracht gezogene Alternativen, Begründung, Quelle.
- Begründung der Abhängigkeiten – Tabelle: Abhängigkeit, Zweck, Was sie ersetzt hat, Quelle.
- Datenfluss und Zustand — Wie Daten durch das System fließen. Vergleichstabelle für Speicherorte.
- Fehlermodi und Fehlerbehandlung –
Flussdiagrammfür Fehlerausbreitungswege. - Leistungsmerkmale – Engpässe, Skalierungsgrenzen, Hot-Paths.
- Sicherheitsmodell – Authentifizierung, Autorisierung, Vertrauensgrenzen, Datensensibilität.
- Teststrategie – Was getestet wird, was nicht, Testphilosophie.
- Bekannte technische Schulden – Tabelle: Problem, Risikostufe, betroffene Dateien, Quelle.
- 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
- Systemübersicht – Was es leistet, wer es nutzt, geschäftlicher Nutzen in 2–3 Sätzen
- Funktionsübersicht – Tabelle: Funktion, Status (implementiert/teilweise/geplant), Reifegrad, Abhängigkeiten. Was das System heute leisten kann und was nicht.
- Architektur im Überblick –
Mermaid-Diagrammauf hoher Ebene(LR-Diagramm). Dienste, Datenspeicher, externe Integrationen – KEINE internen Code-Details. Fokus auf Bereitstellungseinheiten und Teamgrenzen. - Teamtopologie – Welches Team/welche Person ist für welche Komponenten verantwortlich? Tabelle: Komponente, Verantwortlicher, Kritikalität, Bus-Faktor.
- Technologie-Investitionskonzept – Warum diese Technologien ausgewählt wurden. Tabelle: Technologie, Zweck, in Betracht gezogene Alternativen, Risikostufe.
- Risikobewertung – Tabelle: Risiko, Eintrittswahrscheinlichkeit, Auswirkung, Risikominderung, Verantwortlicher. Bezieht Zuverlässigkeit, Sicherheit, Skalierbarkeit und Compliance ein.
- Kosten- und Skalierungsmodell – Wie skalieren die Kosten mit der Nutzung? Wo liegen die Engpässe? Wann ist die nächste Skalierungsinvestition erforderlich?
- Abhängigkeitskarte –
TB-Diagramm, das kritische externe Abhängigkeiten darstellt. Tabelle: Abhängigkeit, Typ (Dienst/Bibliothek/Plattform), Risiko bei Nichtverfügbarkeit. - Wichtige Kennzahlen und Überwachbarkeit – Was gemessen wird, welche Dashboards vorhanden sind, Abdeckung durch Warnmeldungen. Tabelle: Kennzahl, aktueller Wert, Zielwert, Quelle.
- Abgleich der Roadmap — Zuordnung der technischen Arbeitsströme zu den geschäftlichen Prioritäten. Was ist in Arbeit, was ist geplant, was ist blockiert?
- Zusammenfassung der technischen Schulden – Die 5 wichtigsten Schuldenposten mit geschäftlichen Auswirkungen. Tabelle: Problem, geschäftliche Auswirkungen, Aufwand für die Behebung, Priorität.
- 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
- Was dieses System leistet – 2–3-zeiliger Elevator Pitch in nutzerorientierter Sprache (ohne Fachjargon)
- User-Journey-Map – Mermaid
-Diagramm (LR) oderJourney-Diagramm, das die primären Nutzerabläufe durch das System darstellt - 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.
- 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“). - Konfiguration & Feature-Flags — Tabelle: Flag/Konfiguration, Was es steuert, Standardwert, Wer kann es ändern. Was ohne technische Arbeit umgeschaltet werden kann.
- API-Funktionen – Welche Integrationen sind möglich? Tabelle: Funktion, Endpunkt/Methode, Authentifizierung, Ratenbegrenzungen. Für Integrationspartner verfasst, nicht für Entwickler.
- Leistung & SLAs – Antwortzeiten, Durchsatzgrenzen, Verfügbarkeitsziele. Tabelle: Vorgang, erwartete Latenz, Durchsatzgrenze, aktuelles SLA.
- 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.
- Daten & Datenschutz – Welche Daten werden erfasst, wo werden sie gespeichert, Aufbewahrungsrichtlinien, Compliance-Status. Tabelle: Datentyp, Speicherort, Aufbewahrungsfrist, Compliance.
- Glossar – Fachbegriffe in verständlicher Sprache erklärt (kein technischer Jargon)
- 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 stattdessenoder 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
---
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 Dateienwiki-onboarding installieren
Laden Sie die Skill-Dateien herunter und entpacken Sie sie in Ihr Verzeichnis „.claude/skills/“.
ZIP herunterladenKlonen 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





Heim
