Codebase Onboarding
Spin up Claude Code in a repo you have never touched by generating an architecture map, entry points, conventions, and a starter CLAUDE.md.
Overview
Codebase Onboarding is an agent skill most often used in Build (also Idea research and Ship review prep) that analyzes an unfamiliar repository and produces an architecture map, conventions, entry points, and a starter C
Install
npx skills add https://github.com/affaan-m/everything-claude-code --skill codebase-onboardingWhat is this skill?
- Parallel reconnaissance across package manifests, framework configs, entry points, and a two-level directory tree
- Ignores noise dirs (node_modules, dist, .git, __pycache__, .next) while fingerprinting stacks
- Structured onboarding guide with architecture map and key entry points
- Starter CLAUDE.md generation tailored to detected conventions
- Triggered on join-new-repo, understand this codebase, or onboard me requests
- 5 parallel reconnaissance checks (manifests, frameworks, entry points, directory snapshot, config tooling)
- Top 2 directory levels in structure snapshot
- 10+ package manifest ecosystems listed in SKILL.md
Adoption & trust: 4.6k installs on skills.sh; 210k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You opened a repo with Claude Code but lack a trustworthy map of structure, entry points, and team conventions, so every agent turn starts with expensive guesswork.
Who is it for?
Solo builders onboarding to a inherited monorepo, polyglot service, or OSS fork before their first feature branch with Claude Code.
Skip if: Repos where architecture and CLAUDE.md are already maintained and approved—skip repeat runs unless the stack or layout changed materially.
When should I use this skill?
First time opening a project with Claude Code; joining a new team or repository; user asks to understand the codebase, generate CLAUDE.md, onboard, or walk through the repo.
What do I get? / Deliverables
You get a structured onboarding guide and starter CLAUDE.md so the agent can work from named entry points and detected tooling instead of random file search.
- Structured onboarding guide with architecture map and conventions
- Starter CLAUDE.md aligned to detected stack
- Identified application entry points and tooling fingerprint
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Canonical shelf is Build because the primary outcome is agent-ready repo context (CLAUDE.md and tooling fingerprints), which solo builders need right before they code with an agent. agent-tooling fits first-time Claude Code setup and procedural repo maps more than generic app frontend/backend work.
Where it fits
Map how a competitor OSS repo is organized before deciding whether to fork or integrate.
First Claude Code session in a client repo: produce CLAUDE.md and entry points before implementing a ticket.
Turn detected conventions into an onboarding doc for your future self when you return to the project in six months.
Refresh structure snapshot after a large refactor so review prompts reference the new module boundaries.
How it compares
Use instead of ad-hoc "read the whole repo" chat threads when you need a repeatable reconnaissance ritual and agent context file.
Common Questions / FAQ
Who is codebase-onboarding for?
Solo and indie builders (and small teams) who use Claude Code or similar agents and need a fast, structured first pass on an unfamiliar repository.
When should I use codebase-onboarding?
On first Claude Code open in a repo, when joining a new project, when you ask to understand the codebase or generate CLAUDE.md, or during Idea-phase research before committing to a refactor scope.
Is codebase-onboarding safe to install?
It drives broad repository reads and structure scans; review the Security Audits panel on this Prism page and your org policy before running it on proprietary code.
SKILL.md
READMESKILL.md - Codebase Onboarding
# Codebase Onboarding Systematically analyze an unfamiliar codebase and produce a structured onboarding guide. Designed for developers joining a new project or setting up Claude Code in an existing repo for the first time. ## When to Use - First time opening a project with Claude Code - Joining a new team or repository - User asks "help me understand this codebase" - User asks to generate a CLAUDE.md for a project - User says "onboard me" or "walk me through this repo" ## How It Works ### Phase 1: Reconnaissance Gather raw signals about the project without reading every file. Run these checks in parallel: ``` 1. Package manifest detection → package.json, go.mod, Cargo.toml, pyproject.toml, pom.xml, build.gradle, Gemfile, composer.json, mix.exs, pubspec.yaml 2. Framework fingerprinting → next.config.*, nuxt.config.*, angular.json, vite.config.*, django settings, flask app factory, fastapi main, rails config 3. Entry point identification → main.*, index.*, app.*, server.*, cmd/, src/main/ 4. Directory structure snapshot → Top 2 levels of the directory tree, ignoring node_modules, vendor, .git, dist, build, __pycache__, .next 5. Config and tooling detection → .eslintrc*, .prettierrc*, tsconfig.json, Makefile, Dockerfile, docker-compose*, .github/workflows/, .env.example, CI configs 6. Test structure detection → tests/, test/, __tests__/, *_test.go, *.spec.ts, *.test.js, pytest.ini, jest.config.*, vitest.config.* ``` ### Phase 2: Architecture Mapping From the reconnaissance data, identify: **Tech Stack** - Language(s) and version constraints - Framework(s) and major libraries - Database(s) and ORMs - Build tools and bundlers - CI/CD platform **Architecture Pattern** - Monolith, monorepo, microservices, or serverless - Frontend/backend split or full-stack - API style: REST, GraphQL, gRPC, tRPC **Key Directories** Map the top-level directories to their purpose: <!-- Example for a React project — replace with detected directories --> ``` src/components/ → React UI components src/api/ → API route handlers src/lib/ → Shared utilities src/db/ → Database models and migrations tests/ → Test suites scripts/ → Build and deployment scripts ``` **Data Flow** Trace one request from entry to response: - Where does a request enter? (router, handler, controller) - How is it validated? (middleware, schemas, guards) - Where is business logic? (services, models, use cases) - How does it reach the database? (ORM, raw queries, repositories) ### Phase 3: Convention Detection Identify patterns the codebase already follows: **Naming Conventions** - File naming: kebab-case, camelCase, PascalCase, snake_case - Component/class naming patterns - Test file naming: `*.test.ts`, `*.spec.ts`, `*_test.go` **Code Patterns** - Error handling style: try/catch, Result types, error codes - Dependency injection or direct imports - State management approach - Async patterns: callbacks, promises, async/await, channels **Git Conventions** - Branch naming from recent branches - Commit message style from recent commits - PR workflow (squash, merge, rebase) - If the repo has no commits yet or only a shallow history (e.g. `git clone --depth 1`), skip this section and note "Git history unavailable or too shallow to detect conventions" ### Phase 4: Generate Onboarding Artifacts Produce two outputs: #### Output 1: Onboarding Guide ```markdown # Onboarding Guide: [Project Name] ## Overview [2-3 sentences: what this project does and who it serves] ## Tech Stack <!-- Example for a Next.js project — replace with detected stack --> | Layer | Technology | Version | |-------|-