Understand Onboard
Turn an existing project knowledge graph into a structured onboarding guide when someone new needs to understand the codebase fast.
Overview
understand-onboard is an agent skill most often used in Build (also Operate, Grow) that generates a team onboarding guide from an existing project knowledge graph JSON.
Install
npx skills add https://github.com/lum1104/understand-anything --skill understand-onboardWhat is this skill?
- Generates a comprehensive onboarding guide from a project knowledge graph JSON
- Documents graph schema: project metadata, typed nodes, weighted edges, layers, and ordered tour
- Efficient context use: grep/search the graph before loading whole sections into the agent
- Supports code nodes (file, function, class, module) and domain/knowledge nodes (flow, article, claim, source)
- Edge types (imports, calls, depends_on, documents) drive how newcomers see system connections
- Graph documents node types across code, config, domain, and knowledge layers
- Tour entries include order, title, description, and nodeIds for sequenced walkthroughs
- Reading workflow is a 4-step efficient-context pattern (grep-first, selective reads)
Adoption & trust: 819 installs on skills.sh; 54.9k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You have a rich codebase graph but no coherent path for a new contributor to follow imports, services, and documented flows without days of random file opening.
Who is it for?
Small teams or solo builders shipping with Claude Code, Cursor, or Codex who already export a knowledge graph and regularly add collaborators or future selves.
Skip if: Greenfield repos with no graph JSON yet, or solos who never onboard anyone and only need a one-page README.
When should I use this skill?
Use when you need to generate an onboarding guide for new team members joining a project.
What do I get? / Deliverables
You get a structured onboarding guide anchored on graph nodes, edges, layers, and tour order, with grep-first reading so the agent stays within context limits.
- Comprehensive onboarding guide structured around graph layers and tour order
- Cross-references from newcomer tasks to relevant node IDs and edge relationships
- Efficiency notes embedded so future runs avoid dumping the entire graph into context
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Canonical shelf is Build because the primary output is documentation artifacts derived from analyzed project structure, not runtime ops or growth campaigns. Docs is the right subphase: the skill’s job is to compose onboarding narrative and navigation from graph nodes, edges, layers, and tour—not to write application code.
Where it fits
After the repo knowledge graph is built, invoke understand-onboard to publish a tour-ordered guide for module boundaries and key entrypoints.
After a major refactor updates graph edges and layers, regenerate onboarding so returning contractors see current depends_on and deploy paths.
When a part-time developer joins mid-sprint, produce an onboarding packet that cites article and flow nodes instead of Slack archaeology.
Before handing a feature area to another builder, attach an onboarding section that links function and endpoint nodes to the product tour.
How it compares
Use instead of ad-hoc README tours when you already invest in a machine-readable project graph rather than narrating architecture from memory.
Common Questions / FAQ
Who is understand-onboard for?
Solo and indie builders plus tiny teams who use agent skills to document complex repos and need repeatable newcomer guides tied to real structure, not generic checklists.
When should I use understand-onboard?
During Build/docs after a graph is generated; during Operate/iterate when architecture shifts and onboarding must update; during Grow/support when a contractor or hire joins and needs a guided tour of nodes and flows.
Is understand-onboard safe to install?
Treat it like any skills.sh package: review the Security Audits panel on this Prism page and confirm the skill only reads project files and graph JSON you already trust.
SKILL.md
READMESKILL.md - Understand Onboard
# /understand-onboard Generate a comprehensive onboarding guide from the project's knowledge graph. ## Graph Structure Reference The knowledge graph JSON has this structure: - `project` — {name, description, languages, frameworks, analyzedAt, gitCommitHash} - `nodes[]` — each has {id, type, name, filePath?, summary, tags[], complexity, languageNotes?} - Code node types: file, function, class, module, concept - Non-code node types: config, document, service, table, endpoint, pipeline, schema, resource - Domain/knowledge node types: domain, flow, step, article, entity, topic, claim, source - IDs use the node type as prefix, e.g. `file:path`, `function:path:name`, `config:path`, `article:path` - `edges[]` — each has {source, target, type, direction, weight} - Key types: imports, contains, calls, depends_on, configures, documents, deploys, triggers, contains_flow, flow_step, related, cites - `layers[]` — each has {id, name, description, nodeIds[]} - `tour[]` — each has {order, title, description, nodeIds[]} ## How to Read Efficiently 1. Use Grep to search within the JSON for relevant entries BEFORE reading the full file 2. Only read sections you need — don't dump the entire graph into context 3. Node names and summaries are the most useful fields for understanding 4. Edges tell you how components connect — follow imports and calls for dependency chains ## Instructions 1. Check that `.understand-anything/knowledge-graph.json` exists. If not, tell the user to run `/understand` first. 2. **Read project metadata** — use Grep or Read with a line limit to extract the `"project"` section (name, description, languages, frameworks). 3. **Read layers** — Grep for `"layers"` to get the full layers array. These define the architecture and will structure the guide. 4. **Read the tour** — Grep for `"tour"` to get the guided walkthrough steps. These provide the recommended learning path. 5. **Read file-level structural nodes only** — use Grep to find nodes with file-level types (`file`, `config`, `document`, `service`, `pipeline`, `table`, `schema`, `resource`, `endpoint`) in the knowledge graph. Skip function-level and class-level nodes to keep the guide high-level. Extract each node's `name`, `filePath`, `summary`, and `complexity`. 6. **Identify complexity hotspots** — from the file-level nodes, find those with the highest `complexity` values. These are areas new developers should approach carefully. 7. **Generate the onboarding guide** with these sections: - **Project Overview**: name, languages, frameworks, description (from project metadata) - **Architecture Layers**: each layer's name, description, and key files (from layers + file nodes) - **Key Concepts**: important patterns and design decisions (from node summaries and tags) - **Guided Tour**: step-by-step walkthrough (from the tour section) - **File Map**: what each key file does (from file-level nodes, organized by layer) - **Complexity Hotspots**: areas to approach carefully (from complexity values) 8. Format as clean markdown 9. Offer to save the guide to `docs/ONBOARDING.md` in the project 10. Suggest the user commit it to the repo for the team