What happens to code dumps during onboarding?

The onboard process returns a clean summary and creates a YAML handoff without polluting the main context with full codebase dumps.

Where is the handoff stored?

In thoughts/shared/handoffs/ /onboard- .yaml, and the agent also creates the directories thoughts/shared/handoffs/ / and .claude/.

How do I update the onboard handoff later?

Use the /create_handoff command to update the YAML handoff with new goals, actions, or findings.

onboard

Scanned

npx machina-cli add skill parcadei/Continuous-Claude-v3/onboard --openclaw

Files (1)

SKILL.md

2.0 KB

Onboard - Project Discovery & Ledger Creation

Analyze a brownfield codebase and create an initial continuity ledger.

When to Use

First time working in an existing project
User says "onboard", "analyze this project", "get familiar with codebase"

How to Use

Spawn the onboard agent:

Use the Task tool with subagent_type: "onboard" and this prompt:

Onboard me to this project at $CLAUDE_PROJECT_DIR.

1. Create required directories if they don't exist:
   mkdir -p thoughts/shared/handoffs/<project-name> .claude

2. Explore the codebase using available tools:
   - Try: tldr tree . && tldr structure .
   - Fallback: find . -type f -name "*.py" -o -name "*.ts" -o -name "*.js" | head -50

3. Detect tech stack (look for package.json, requirements.txt, Cargo.toml, go.mod, etc.)

4. Ask the user about their goals using AskUserQuestion

5. Create a YAML handoff at thoughts/shared/handoffs/<project-name>/onboard-<date>.yaml:
   ---
   date: <ISO date>
   type: onboard
   status: active
   ---
   goal: <user's stated goal>
   now: Start working on <first priority>
   tech_stack: [list of detected technologies]
   key_files:
     - path: <important file>
       purpose: <what it does>
   architecture: <brief description>
   next:
     - <suggested first action>

Why an Agent?

The onboard process:

Requires multiple exploration steps
Should not pollute main context with codebase dumps
Returns a clean summary + creates the handoff

Output

Directories created: thoughts/shared/handoffs/<project>/, .claude/
YAML handoff created (loaded automatically on session start)
User has clear starting context
Ready to begin work with full project awareness

Notes

This skill is for BROWNFIELD projects (existing code)
For greenfield, use /create_plan instead
Handoff can be updated anytime with /create_handoff

Source

git clone https://github.com/parcadei/Continuous-Claude-v3/blob/main/.claude/skills/onboard/SKILL.mdView on GitHub

Overview

Onboard analyzes a brownfield codebase and creates the initial continuity ledger. It sets up dedicated thoughts folders, inventories the tech stack and key files, and outputs a YAML handoff summarizing goals, current status, and next actions.

How This Skill Works

Spawn the onboard agent, explore the repository (tree/structure) and detect tech stack, then query the user for goals. It writes a YAML handoff at thoughts/shared/handoffs/<project-name>/onboard-<date>.yaml containing date, type, status, goal, now, tech_stack, key_files, architecture, and next actions, while leaving the main context clean.

When to Use It

First time working in an existing brownfield project
User asks to onboard, analyze this project, or get familiar with codebase
You need an initial continuity ledger and a project summary before heavy work
Preparing teammates with a shareable handoff and project context
Starting a brownfield project and requiring a structured discovery phase

Quick Start

Step 1: Spawn the onboard agent with subagent_type: "onboard" and point to the project directory
Step 2: Run exploration to detect tech stack and collect key files (e.g., tree ., structure ., and common config files)
Step 3: Answer the user questions, then the agent creates thoughts/shared/handoffs/<project-name>/onboard-<date>.yaml and initializes the project context

Best Practices

Confirm the project name to generate correct paths: thoughts/shared/handoffs/<project-name> and .claude
Run exploration steps (tree/structure) and tech stack detection before deep changes
Ask the user about goals early to populate the 'goal' and 'now' fields accurately
Create and store the YAML handoff at onboard-<date>.yaml and keep dumps out of main context
Use the handoff as a living reference; update it with /create_handoff as goals evolve

Example Use Cases

Onboard a React + Node.js monorepo: tech_stack includes JavaScript, Node.js, React; key_files: package.json, package-lock.json, tsconfig.json; architecture described as a multi-service frontend-backend setup
Onboard a Python Django app: tech_stack includes Python, Django, PostgreSQL; key_files: requirements.txt, manage.py, settings.py; architecture described as a traditional MVC web app
Onboard a Go microservice: tech_stack includes Go, Docker; key_files: go.mod, main.go, Dockerfile; architecture described as a set of microservices with API gateway
Onboard a Rust CLI tool: tech_stack includes Rust, cargo; key_files: Cargo.toml, src/main.rs; architecture described as a single executable with modular crates
Onboard a large monorepo with multiple services: tech_stack spans JS/TS, Python, and Go; key_files span multiple service folders; architecture described as a polyrepo with service boundaries and shared libs

Frequently Asked Questions

Add this skill to your agents