opción
HogarHogar Skill Documentación wiki-onboarding

wiki-onboarding

microsoft/skills 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 todo
0
Tiempo actualizado 11 de septiembre de 2026

Generador 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:

  1. Comprueba si hay un git remote: ejecuta el comando «git remote get-url origin» para detectar si existe un remote
  2. 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_URL y 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)
  3. Determina la rama predeterminada: ejecuta «git rev-parse --abbrev-ref HEAD»
  4. 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# / .NET
  • Cargo.toml → Rust
  • pyproject.toml / setup.py / requirements.txt → Python
  • go.mod → Go
  • pom.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)

  1. {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.
  2. 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 solicitudDiagrama 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

  1. Resumen ejecutivo: qué es el sistema en un párrafo conciso. Qué gestiona y qué delega.
  2. La idea arquitectónica fundamental — El ÚNICO concepto más importante. Incluye pseudocódigo en un lenguaje DIFERENTE al del repositorio.
  3. Arquitectura del sistema — Diagrama TB completo en Mermaid. Destaca el «corazón» del sistema.
  4. Modelo de dominio: diagrama ER de Mermaid de las entidades principales. Tabla de invariantes de datos: Entidad, Invariable, Aplicado por, Fuente.
  5. Abstracciones e interfaces clave: diagrama de clases que muestre las abstracciones que soportan la carga.
  6. Ciclo de vida de una solicitud: diagrama de secuencia (con numeración automática) que muestra una solicitud típica desde la entrada hasta la respuesta.
  7. Transiciones de estado: diagrama de estado v2 para entidades con estados de ciclo de vida significativos.
  8. Registro de decisiones: tabla con los campos «Decisión», «Alternativas consideradas», «Justificación» y «Fuente».
  9. Justificación de las dependencias — Tabla: Dependencia, Propósito, A qué sustituye, Fuente.
  10. Flujo de datos y estado — Cómo se mueven los datos por el sistema. Tabla comparativa de almacenamiento.
  11. Modos de fallo y gestión de errores: diagrama de flujo de las rutas de propagación de errores.
  12. Características de rendimiento — Cuellos de botella, límites de escalabilidad, rutas críticas.
  13. Modelo de seguridad — Autenticación, autorización, límites de confianza, sensibilidad de los datos.
  14. Estrategia de pruebas: qué se prueba, qué no se prueba, filosofía de pruebas.
  15. Deuda técnica conocida — Tabla: problema, nivel de riesgo, archivos afectados, fuente.
  16. 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., Tarea o = 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

  1. Descripción general del sistema: qué hace, quién lo utiliza y su valor empresarial en 2-3 frases
  2. 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.
  3. Resumen de la arquitectura: diagrama LR de alto nivel tipo «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.
  4. Topología del equipo: qué equipo o persona es responsable de cada componente. Tabla: componente, responsable, criticidad, factor de bus.
  5. Tesis de inversión tecnológica — Por qué se eligieron estas tecnologías. Tabla: Tecnología, finalidad, alternativas consideradas, nivel de riesgo.
  6. Evaluación de riesgos — Tabla: riesgo, probabilidad, impacto, mitigación, responsable. Abarca la fiabilidad, la seguridad, la escalabilidad y el cumplimiento normativo.
  7. 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.
  8. Mapa de dependencias: gráfico de TB que muestra las dependencias externas críticas. Tabla: Dependencia, Tipo (servicio/biblioteca/plataforma), riesgo en caso de indisponibilidad.
  9. Métricas clave y observabilidad — Qué se mide, qué paneles de control existen, cobertura de alertas. Tabla: Métrica, valor actual, objetivo, fuente.
  10. 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.
  11. 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.
  12. 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

  1. Qué hace este sistema: presentación concisa de 2-3 frases en un lenguaje accesible para el usuario (sin jerga)
  2. Mapa del recorrido del usuario: gráfico Mermaid LR o diagrama de recorrido que muestre los flujos principales de los usuarios a través del sistema
  3. 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.
  4. Modelo de datos (vista del producto): diagrama erDiagram simplificado 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»).
  5. 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.
  6. 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.
  7. Rendimiento y SLA — Tiempos de respuesta, límites de rendimiento, objetivos de disponibilidad. Tabla: Operación, Latencia esperada, Límite de rendimiento, SLA actual.
  8. 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.
  9. 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.
  10. Glosario — Términos del ámbito explicados en un lenguaje sencillo (sin jerga técnica)
  11. 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 estilo en línea, utiliza rellenos oscuros con `color:#e6edf3`
  • NO utilices
    en las etiquetas de Mermaid (utiliza
    o 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
Ver en GitHub
---
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 archivos

Instalar wiki-onboarding

Descarga y descomprime los archivos de habilidades en tu directorio .claude/skills/.

Descargar ZIP

Clona 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 Copiar
Configuración rápida: Copia la carpeta de la habilidad en .claude/skills/ Claude detectará y utilizará automáticamente la habilidad
Repositorio microsoft/skills

Habilidades relacionadas

golang-dependency-injection
Tiempo actualizado 29 de junio de 2026
nuxthub
Tiempo actualizado 23 de agosto de 2026
tc-tracker
Tiempo actualizado 27 de agosto de 2026
code-quality
Tiempo actualizado 22 de agosto de 2026
OR