Skill — Codebase Onboarding
When this skill activates
When entering a new or unfamiliar repository for the first time, when asked to
summarize or map a codebase, or when needing to build a mental model before
making changes. Also activates when explicitly asked to generate an onboarding
report or learning path.
Mandatory actions when this skill is active
Execute the following auto-summarization pipeline in order:
Step 1 — Detect Stack
Identify the technology stack by examining:
- Language(s): file extensions, shebang lines, language-specific config files
- Framework(s): package.json dependencies, requirements.txt, go.mod, Cargo.toml
- Build system: Makefile, webpack, vite, turbopack, gradle, cargo, mix
- Test framework: jest, pytest, vitest, go test, RSpec, xUnit
- Package manager: npm, yarn, pnpm, pip, poetry, cargo, go modules
- Infrastructure: Docker, Kubernetes, Terraform, CDK, serverless configs
Step 2 — Find Entry Points
Locate all entry points into the application:
- Main files (main.ts, index.ts, app.py, main.go, Program.cs)
- CLI entry points (bin/ directory, package.json bin field)
- Route definitions (router files, controller registrations)
- Event handlers (message consumers, cron jobs, webhook handlers)
- Worker/queue processors
- Migration entry points (seed files, migration runners)
Step 3 — Build Module Dependency Graph
Create a graph where:
- Nodes = modules, packages, or major source directories
- Edges = imports, function calls, event emissions between modules
- Identify circular dependencies (flag as architectural debt)
- Note external service dependencies (databases, APIs, queues)
Step 4 — Identify Hot Paths
Find the most critical files by measuring:
- Most imported: files that appear in the most import statements
- Most modified: files with the highest git commit frequency (last 90 days)
- Largest fan-out: files that import the most other modules
- Gateway files: files that bridge between major subsystems
Step 5 — Generate Learning Path
Create an ordered reading list that builds understanding progressively:
- Configuration files (understand the shape of the project)
- Entry points (understand how the system starts)
- Core domain logic (understand what the system does)
- Infrastructure/adapters (understand how it connects to the world)
- Edge cases and error handling (understand failure modes)
- Tests (understand expected behavior and invariants)
Step 6 — Output Report
Write ONBOARDING-REPORT.md to .planning/ containing:
- Stack summary (one-line per technology)
- Entry points list (file path + purpose)
- Dependency graph (ASCII or Mermaid format)
- Hot paths table (file, import count, commit frequency)
- Learning path (ordered reading list with file paths)
- Key architectural decisions or patterns observed
- Known debt or areas of concern
Self-check before task completion
Before marking a task done when this skill was active:
1---2name: codebase-onboarding3version: 1.0.04min_mindforge_version: 10.0.45status: stable6triggers: onboarding, new repo, unfamiliar codebase, codebase summary, knowledge graph, entry points, learning path, repo overview, architecture discovery, codebase map, project familiarization, code exploration7disable-model-invocation: true8metadata:9 source: https://skillmd.com/skills/sairam0424/codebase-onboarding10---1112# Skill — Codebase Onboarding1314## When this skill activates1516When entering a new or unfamiliar repository for the first time, when asked to17summarize or map a codebase, or when needing to build a mental model before18making changes. Also activates when explicitly asked to generate an onboarding19report or learning path.2021## Mandatory actions when this skill is active2223Execute the following auto-summarization pipeline in order:2425### Step 1 — Detect Stack2627Identify the technology stack by examining:2829- **Language(s)**: file extensions, shebang lines, language-specific config files30- **Framework(s)**: package.json dependencies, requirements.txt, go.mod, Cargo.toml31- **Build system**: Makefile, webpack, vite, turbopack, gradle, cargo, mix32- **Test framework**: jest, pytest, vitest, go test, RSpec, xUnit33- **Package manager**: npm, yarn, pnpm, pip, poetry, cargo, go modules34- **Infrastructure**: Docker, Kubernetes, Terraform, CDK, serverless configs3536### Step 2 — Find Entry Points3738Locate all entry points into the application:3940- Main files (main.ts, index.ts, app.py, main.go, Program.cs)41- CLI entry points (bin/ directory, package.json bin field)42- Route definitions (router files, controller registrations)43- Event handlers (message consumers, cron jobs, webhook handlers)44- Worker/queue processors45- Migration entry points (seed files, migration runners)4647### Step 3 — Build Module Dependency Graph4849Create a graph where:5051- **Nodes** = modules, packages, or major source directories52- **Edges** = imports, function calls, event emissions between modules53- Identify circular dependencies (flag as architectural debt)54- Note external service dependencies (databases, APIs, queues)5556### Step 4 — Identify Hot Paths5758Find the most critical files by measuring:5960- **Most imported**: files that appear in the most import statements61- **Most modified**: files with the highest git commit frequency (last 90 days)62- **Largest fan-out**: files that import the most other modules63- **Gateway files**: files that bridge between major subsystems6465### Step 5 — Generate Learning Path6667Create an ordered reading list that builds understanding progressively:68691. Configuration files (understand the shape of the project)702. Entry points (understand how the system starts)713. Core domain logic (understand what the system does)724. Infrastructure/adapters (understand how it connects to the world)735. Edge cases and error handling (understand failure modes)746. Tests (understand expected behavior and invariants)7576### Step 6 — Output Report7778Write `ONBOARDING-REPORT.md` to `.planning/` containing:7980- Stack summary (one-line per technology)81- Entry points list (file path + purpose)82- Dependency graph (ASCII or Mermaid format)83- Hot paths table (file, import count, commit frequency)84- Learning path (ordered reading list with file paths)85- Key architectural decisions or patterns observed86- Known debt or areas of concern8788## Self-check before task completion8990Before marking a task done when this skill was active:9192- [ ] Did I identify the stack correctly (language, framework, build, test)?93- [ ] Did I find ALL entry points (not just the obvious main file)?94- [ ] Did I build a dependency graph showing module relationships?95- [ ] Did I identify hot paths (most-imported and most-modified)?96- [ ] Did I create a usable learning path (ordered, progressive)?97- [ ] Did I output ONBOARDING-REPORT.md to .planning/?98- [ ] Is the report useful to someone with zero prior context?