wiki-onboarding
microsoft/skills
Genera cuatro guías de incorporación adaptadas a cada tipo de público en la carpeta «onboarding/»: colaborador, ingeniero de plantilla, directivo y gestor de producto. Úsalas cuando el usuario necesite documentación de incorporación para un código fuente.
...Expandir todoGenerador de guías de incorporación a la wiki
Genera cuatro documentos de incorporación adaptados a cada público en la carpeta «onboarding/», cada uno de los cuales proporciona a un grupo de interés concreto exactamente la información que necesita.
Resolución del repositorio de origen (IMPRESCINDIBLE HACERLO PRIMERO)
Antes de generar ninguna guía, DEBES determinar el contexto del repositorio de origen:
- Comprueba si hay un git remote: ejecuta el comando
«git remote get-url origin»para detectar si existe un remote - Pregunta al usuario: «¿Se trata de un repositorio solo local o dispones de una URL de repositorio de origen (por ejemplo, GitHub, Azure DevOps)?»
- Si se proporciona una URL remota → guárdala como
REPO_URLy utiliza citas enlazadas:[archivo:línea](REPO_URL/blob/BRANCH/archivo#Llínea) - Solo local → utiliza citas locales:
(ruta_del_archivo:número_de_línea)
- Si se proporciona una URL remota → guárdala como
- Determina la rama predeterminada: ejecuta
«git rev-parse --abbrev-ref HEAD» - NO continúes hasta que se haya resuelto el contexto del repositorio de origen
Cuándo activarlo
- El usuario solicita documentación de incorporación o guías de introducción
- El usuario ejecuta el comando
/deep-wiki:onboard - El usuario quiere ayudar a los nuevos miembros del equipo a comprender el código
Estructura de salida
Genera una carpeta «onboarding/» con estos archivos:
onboarding/
├── index.md # Centro de incorporación: enlaces a las cuatro guías con descripciones de los destinatarios
├── contributor-guide.md # Para nuevos colaboradores (se presupone que tienen conocimientos de Python o JS)
├── staff-engineer-guide.md # Para ingenieros de plantilla e ingenieros principales
├── executive-guide.md # Para líderes de ingeniería a nivel de vicepresidente o director
└── product-manager-guide.md # Para gestores de producto y partes interesadas ajenas a la ingeniería
index.md — Centro de incorporación
Una página de inicio con:
- Un resumen del proyecto de un párrafo
- Tabla de selección de guías:
| Guía | Público | Qué aprenderás | Duración |
|---|---|---|---|
| Guía para colaboradores | Nuevos colaboradores con experiencia en Python/JS | Configuración, primera solicitud de incorporación de cambios (PR) y patrones del código base | ~30 min |
| Guía para ingenieros de plantilla | Ingenieros de plantilla y principales | Arquitectura, decisiones de diseño, límites del sistema | ~45 min |
| Guía para ejecutivos | Vicepresidentes y directores de ingeniería | Capacidades, riesgos, estructura del equipo, tesis de inversión | ~20 min |
| Guía para el gestor de producto | Gestores de producto | Funcionalidades, recorridos de usuario, limitaciones, modelo de datos | ~20 min |
Detección de lenguaje
Analiza el repositorio en busca de archivos de compilación para determinar el lenguaje principal de los ejemplos de código:
package.json/tsconfig.json→ TypeScript/JavaScript*.csproj/*.sln→ C# / .NETCargo.toml→ Rustpyproject.toml/setup.py/requirements.txt→ Pythongo.mod→ Gopom.xml/build.gradle→ Java
Guía 1: Guía para colaboradores
Archivo: onboarding/contributor-guide.md
Destinatarios: Ingenieros que se incorporan al proyecto. Se da por supuesto un dominio de Python o JavaScript y experiencia general en ingeniería de software.
Extensión: 1000–2500 líneas. Progresiva: cada sección se basa en la anterior.
Secciones obligatorias
Parte I: Fundamentos (omitir si el repositorio utiliza Python o JS)
- {Lenguaje principal} para ingenieros de Python/JS: tablas comparativas de sintaxis, modelo asíncrono, colecciones, sistema de tipos y gestión de paquetes. Código concreto en paralelo, NO descripciones abstractas.
- Fundamentos de {marco principal} — Comparación con marcos equivalentes de Python/JS (p. ej., FastAPI, Express). Flujo de peticiones, enrutamiento, inyección de dependencias, configuración.
Parte II: Este código fuente
3. Qué hace este proyecto — Presentación breve de 2-3 frases
4. Estructura del proyecto — Árbol de directorios comentado (qué hay en cada sitio y por qué). Incluye un gráfico con la visión general de la arquitectura de la base de datos.
5. Conceptos fundamentales — Terminología específica del dominio explicada con ejemplos de código. Utiliza un diagrama ER para el modelo de datos.
6. Ciclo de vida de una solicitud — Diagrama de secuencia (con numeración automática) que traza una solicitud típica de principio a fin.
7. Patrones clave — Plantillas del tipo «Si quieres añadir X, sigue este patrón» con código real
Parte III: Ponerse a trabajar
8. Requisitos previos y configuración — Tabla: herramienta, versión, comando de instalación. Guía paso a paso con el resultado esperado en cada paso.
9. Tu primera tarea — Guía paso a paso para añadir una característica sencilla
10. Flujo de trabajo de desarrollo — Estrategia de ramas, convenciones de commit, proceso de PR. Utiliza diagramas de flujo.
11. Ejecución de pruebas: todas las pruebas, un solo archivo, una sola prueba, comandos de cobertura.
12. Guía de depuración: tabla de problemas comunes: síntoma, causa, solución.
13. Errores habituales: errores que cometen todos los nuevos colaboradores y cómo evitarlos.
Anexos
- Glosario (más de 40 términos)
- Referencia de archivos clave — Tabla: ruta, finalidad, importancia, código fuente
- Ficha de referencia rápida — Hoja de referencia con los comandos y patrones más utilizados
Normas
- Todos los ejemplos de código en el idioma principal detectado
- Cada comando debe poder copiarse y pegarse con el resultado esperado
- Mínimo de 5 diagramas Mermaid (arquitectura, ER, secuencia, diagrama de flujo, estados)
- Utiliza Mermaid para los diagramas de flujo de trabajo (colores de modo oscuro); añade
un bloque de comentarios después de cada uno - Justifica todas las afirmaciones con código real — cita utilizando el formato de enlaces
Guía 2: Guía para ingenieros sénior
Archivo: onboarding/staff-engineer-guide.md
Destinatarios: Ingenieros de plantilla/principales que necesitan conocer el «porqué» detrás de cada decisión. Con amplia experiencia en sistemas, es posible que no conozcan el lenguaje de este repositorio.
Extensión: 800–1200 líneas. Denso, con opiniones firmes, de carácter arquitectónico.
Secciones obligatorias
- Resumen ejecutivo: qué es el sistema en un párrafo conciso. Qué gestiona y qué delega.
- La idea arquitectónica fundamental — El ÚNICO concepto más importante. Incluye pseudocódigo en un lenguaje DIFERENTE al del repositorio.
- Arquitectura del sistema — Diagrama
TBcompletoenMermaid. Destaca el «corazón» del sistema. - Modelo de dominio:
diagrama ERde Mermaid de las entidades principales. Tabla de invariantes de datos: Entidad, Invariable, Aplicado por, Fuente. - Abstracciones e interfaces clave:
diagrama de clasesque muestre las abstracciones que soportan la carga. - Ciclo de vida de una solicitud:
diagrama de secuencia(connumeración automática) que muestra una solicitud típica desde la entrada hasta la respuesta. - Transiciones de estado:
diagrama de estado v2para entidades con estados de ciclo de vida significativos. - Registro de decisiones: tabla con los campos «Decisión», «Alternativas consideradas», «Justificación» y «Fuente».
- Justificación de las dependencias — Tabla: Dependencia, Propósito, A qué sustituye, Fuente.
- Flujo de datos y estado — Cómo se mueven los datos por el sistema. Tabla comparativa de almacenamiento.
- Modos de fallo y gestión de errores:
diagrama de flujode las rutas de propagación de errores. - Características de rendimiento — Cuellos de botella, límites de escalabilidad, rutas críticas.
- Modelo de seguridad — Autenticación, autorización, límites de confianza, sensibilidad de los datos.
- Estrategia de pruebas: qué se prueba, qué no se prueba, filosofía de pruebas.
- Deuda técnica conocida — Tabla: problema, nivel de riesgo, archivos afectados, fuente.
- Dónde profundizar — Ordende lectura recomendado de los archivos fuente, enlaces a secciones de la wiki.
Reglas
- Utiliza pseudocódigo en otro lenguaje para explicar conceptos
- Utiliza tablas comparativas para explicar conceptos desconocidos (p. ej.,
Tareao =Awaitable[T]) - Texto denso con tablas, NO listas de viñetas superficiales
- Cada afirmación debe ir respaldada por una cita enlazada
- Un mínimo de 5 diagramas Mermaid (de arquitectura, ER, de clases, de secuencia, de estados y de flujo)
- Cada diagrama debe ir seguido de
un bloque de comentarios - Utiliza tablas de forma intensiva: las decisiones, las dependencias y la deuda deben aparecer TODAS en tablas con columnas de «Fuente»
- Céntrate en el PORQUÉ de las decisiones, no solo en lo que existe
Guía 3: Guía para ejecutivos
Archivo: onboarding/executive-guide.md
Destinatarios: vicepresidente o director de ingeniería. Necesita una visión general de las capacidades, una evaluación de riesgos y el contexto de la inversión; NO detalles a nivel de código.
Extensión: 400-800 líneas. Estratégico, conciso y orientado a la toma de decisiones.
Secciones obligatorias
- Descripción general del sistema: qué hace, quién lo utiliza y su valor empresarial en 2-3 frases
- Mapa de capacidades: tabla con capacidad, estado (implementada/parcial/prevista), madurez y dependencias. Lo que el sistema puede y no puede hacer en la actualidad.
- Resumen de la arquitectura: diagrama
LRde alto niveltipo«Mermaid». Servicios, almacenes de datos, integraciones externas — SIN detalles internos del código. Centrarse en las unidades de implementación y los límites de los equipos. - Topología del equipo: qué equipo o persona es responsable de cada componente. Tabla: componente, responsable, criticidad, factor de bus.
- Tesis de inversión tecnológica — Por qué se eligieron estas tecnologías. Tabla: Tecnología, finalidad, alternativas consideradas, nivel de riesgo.
- Evaluación de riesgos — Tabla: riesgo, probabilidad, impacto, mitigación, responsable. Abarca la fiabilidad, la seguridad, la escalabilidad y el cumplimiento normativo.
- Modelo de costes y escalabilidad: cómo varían los costes en función del uso. Cuáles son los cuellos de botella. Cuándo se necesitará la próxima inversión en escalabilidad.
- Mapa de dependencias:
gráfico de TBque muestra las dependencias externas críticas. Tabla: Dependencia, Tipo (servicio/biblioteca/plataforma), riesgo en caso de indisponibilidad. - Métricas clave y observabilidad — Qué se mide, qué paneles de control existen, cobertura de alertas. Tabla: Métrica, valor actual, objetivo, fuente.
- Alineación con la hoja de ruta: flujos de trabajo de ingeniería alineados con las prioridades empresariales. Lo que está en curso, lo que está previsto, lo que está bloqueado.
- Resumen de la deuda técnica: las 5 principales partidas de deuda con impacto en el negocio. Tabla: problema, impacto en el negocio, esfuerzo necesario para solucionarlo, prioridad.
- Recomendaciones: de 3 a 5 recomendaciones prácticas para el próximo trimestre, priorizadas por impacto.
Normas
- NO se incluyen fragmentos de código: esta guía está dirigida a responsables de ingeniería, no a programadores
- Diagramas a nivel de servicio o equipo, no a nivel de clase o función
- Cada afirmación debe estar respaldada por pruebas: cita secciones de la wiki, documentos de arquitectura o archivos fuente
- Mínimo de 3 diagramas de Mermaid (visión general de la arquitectura, mapa de dependencias, capacidades/hoja de ruta)
- Tablas para cada conclusión estructurada: este público lee tablas, no texto narrativo
- Lenguaje empresarial: traduce los conceptos técnicos en impacto (fiabilidad, velocidad, coste, riesgo)
Guía 4: Guía para gestores de producto
Archivo: onboarding/product-manager-guide.md
Público: Gestores de producto y partes interesadas ajenas a la ingeniería. Deben comprender qué hace el sistema, qué es posible y cuáles son los límites —NO cómo está construido—.
Extensión: 400-800 líneas. Centrada en el usuario, enfocada en las funcionalidades y consciente de las limitaciones.
Secciones obligatorias
- Qué hace este sistema: presentación concisa de 2-3 frases en un lenguaje accesible para el usuario (sin jerga)
- Mapa del recorrido del usuario:
gráficoMermaidLRo diagramade recorridoque muestre los flujos principales de los usuarios a través del sistema - Mapa de capacidades de las funcionalidades: tabla con las siguientes columnas: funcionalidad, estado (activa/beta/planificada/imposible), comportamiento visible para el usuario y limitaciones. Mapa exhaustivo de lo que está implementado y lo que no.
- Modelo de datos (vista del producto):
diagrama erDiagramsimplificado de Mermaid que muestre las entidades con las que interactúan los usuarios. Explícalo en términos empresariales (p. ej., «Un proyecto tiene muchos documentos», no «relación FK»). - Configuración y indicadores de funcionalidades — Tabla: indicador/configuración, qué controla, valor por defecto, quién puede modificarlo. Qué se puede activar o desactivar sin necesidad de trabajo de ingeniería.
- Capacidades de la API — Qué integraciones son posibles. Tabla: Capacidad, Punto final/Método, Autenticación, Límites de tasa. Dirigido a socios de integración, no a desarrolladores.
- Rendimiento y SLA — Tiempos de respuesta, límites de rendimiento, objetivos de disponibilidad. Tabla: Operación, Latencia esperada, Límite de rendimiento, SLA actual.
- Limitaciones y restricciones conocidas — Lista sincera de lo que el sistema no puede hacer o hace mal. Tabla: Limitación, impacto en el usuario, solución alternativa, corrección prevista.
- Datos y privacidad — Qué datos se recopilan, dónde se almacenan, políticas de retención, estado de cumplimiento normativo. Tabla: Tipo de datos, ubicación de almacenamiento, retención, cumplimiento normativo.
- Glosario — Términos del ámbito explicados en un lenguaje sencillo (sin jerga técnica)
- Preguntas frecuentes — Más de 10 preguntas habituales que se le harían a un gestor de proyectos, respondidas de forma concisa
Normas
- CERO jerga técnica: nada de «middleware», «inyección de dependencias» ni «ORM». Utiliza un lenguaje sencillo.
- Enfoque centrado en el usuario: describe todo en términos de lo que experimentan los usuarios, no de cómo funciona el código
- Mínimo de 3 diagramas Mermaid (recorrido del usuario, modelo de datos, mapa de funcionalidades/resumen de capacidades)
- Tablas para cada conclusión estructurada: los gestores de proyectos revisan las tablas, no los textos narrativos
- Si hay que mencionar un concepto técnico, explícalo en una sola frase (p. ej., «Indicadores de funcionalidad: controles que nos permiten activar o desactivar funcionalidades sin implementar código»)
- Cada afirmación debe estar respaldada por pruebas: cita secciones de la wiki o archivos fuente para su verificación
Normas para los diagramas Mermaid (TODAS las guías)
TODOS los diagramas deben utilizar colores de modo oscuro:
- Relleno de los nodos:
#2d333b; bordes:#6d5dfc; texto:#e6edf3 - Fondos de los subgrafos:
#161b22, bordes:#30363d - Líneas:
#8b949e - Si utilizas directivas
de estiloen línea, utiliza rellenos oscuros con`color:#e6edf3` - NO utilices
en las etiquetas de Mermaid (utilizao saltos de línea)
Validación
Tras generar cada guía, comprueba lo siguiente:
- Que todas las rutas de archivo mencionadas existan realmente en el repositorio
- Que todos los nombres de clases y métodos sean correctos (que no sean inventados)
- Que los diagramas de Mermaid se visualicen correctamente (sin errores de sintaxis)
- No hay etiquetas sin formato similares al HTML (genéricas como
List) fuera de los bloques de código; envuélvelas entre comillas invertidas - Que cada guía sea adecuada para su público objetivo — no debe haber código en las guías para ejecutivos ni para gestores de proyectos
---
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
Todos los archivos
0 archivosInstalar wiki-onboarding
Descarga y descomprime los archivos de habilidades en tu directorio .claude/skills/.
Descargar ZIPClona el repositorio y copia los archivos de la habilidad a tu proyecto.
git clone https://github.com/microsoft/skills/tree/main/.github/plugins/deep-wiki/skills/wiki-onboarding # Copy SKILL.md to your .claude/skills/ directory
Copiar





Hogar
