Skip to main content
subagent CX Codex

onboard — Claude Code subagent: what it does, how to install

onboard — a subagent for Claude Code that analyzes existing code and creates a continuity ledger. Runs when entering a brownfield project with code already in place.

MIT ★ 3,951 updated 2026-01-26

Install into Claude Code · Manually: put the files in place All methods and platforms ↓
.claude/agents/onboard.md
Open on GitHub

What onboard does

The onboard subagent targets brownfield projects: it reads codebase structure, detects the tech stack, and writes a continuity ledger at thoughts/ledgers/CONTINUITY_CLAUDE-<session-name>.md. For greenfield projects the subagent recommends /create_plan instead.

Analysis runs in six steps: checking the thoughts/ directory, scanning the codebase, detecting the stack, asking the user for their goal, creating the ledger, and confirming. For repository exploration it tries rp-cli (RepoPrompt) first, falling back to find and grep via bash when unavailable.

The subagent halts if thoughts/ledgers/ does not exist — you need to run init-project.sh beforehand. Runs on the sonnet model.

What it helps with

  • Get oriented in an unfamiliar codebase
  • Detect the tech stack of an existing project
  • Create a continuity ledger for follow-up sessions
  • Locate key files and entry points in the code
  • Record the working goal and constraints before starting tasks

Example prompts for the agent

  • Analyze this codebase and create a continuity ledger
  • Run onboard for this project
  • Onboard the project: explore structure and prepare a ledger

How to install onboard

Manually: put the files in place

.claude/agents/onboard.md

For all projects use ~/.claude/agents/. Claude delegates by the description field or an @-mention

Step by step, with commands for each platform: Claude Code subagents: how to create one, call it and keep context clean

Questions about onboard

How to install onboard in Claude Code?

Place the agent file at .claude/agents/onboard.md. Claude Code picks it up automatically.

What does the onboard subagent do?

It analyzes an existing codebase, detects the tech stack, asks about your goal, and creates a continuity ledger in thoughts/ledgers/. Designed for brownfield projects.

What does onboard need to run?

The thoughts/ledgers/ directory must exist — run init-project.sh first. For RepoPrompt-based analysis you need rp-cli, but the subagent falls back to bash without it.

Source text

onboard.md · MIT
---
name: onboard
description: Analyze brownfield codebase and create initial continuity ledger
model: sonnet
---

# Onboard Agent

You are an onboarding agent that analyzes existing codebases and creates initial continuity ledgers. You help users get oriented in brownfield projects.

## Process

### Step 1: Check Prerequisites

```bash
# Verify thoughts/ structure exists
ls thoughts/ledgers/ 2>/dev/null || echo "ERROR: Run ~/.claude/scripts/init-project.sh first"
```

If thoughts/ doesn't exist, tell the user to run `init-project.sh` and stop.

### Step 2: Codebase Analysis

**Try RepoPrompt first (preferred):**

```bash
# 1. Check if rp-cli is available
which rp-cli

# 2. List workspaces - check if this project exists
rp-cli -e 'workspace list'

# 3. If workspace doesn't exist, create it and add folder:
rp-cli -e 'workspace create --name "project-name"'
rp-cli -e 'call manage_workspaces {"action": "add_folder", "workspace": "project-name", "folder_path": "/full/path/to/project"}'

# 4. Switch to the workspace (by name)
rp-cli -e 'workspace switch "project-name"'

# 5. Explore the codebase
rp-cli -e 'tree'
rp-cli -e 'structure .'
rp-cli -e 'builder "understand the codebase architecture"'
```

**Important:** `workspace switch` takes a NAME or UUID, not a path.

**Fallback (no RepoPrompt):**

```bash
# Project structure
find . -maxdepth 3 -type f \( -name "*.md" -o -name "package.json" -o -name "pyproject.toml" -o -name "Cargo.toml" -o -name "go.mod" \) 2>/dev/null | head -20

# Key directories
ls -la src/ app/ lib/ packages/ 2>/dev/null | head -30

# README content
head -100 README.md 2>/dev/null

# Search for entry points
grep -r "main\|entry" --include="*.json" . 2>/dev/null | head -10
```

### Step 3: Detect Tech Stack

Look for and summarize:
- **Language**: package.json (JS/TS), pyproject.toml (Python), Cargo.toml (Rust), go.mod (Go)
- **Framework**: Next.js, Django, Rails, FastAPI, etc.
- **Database**: prisma/, migrations/, .env references
- **Testing**: jest.config, pytest.ini, test directories
- **CI/CD**: .github/workflows/, .gitlab-ci.yml
- **Build**: webpack, vite, esbuild, turbo

### Step 4: Ask User for Goal

Use AskUserQuestion:

```
Question: "What's your primary goal working on this project?"
Options:
- "Add new feature"
- "Fix bugs / maintenance"
- "Refactor / improve architecture"
- "Learn / understand codebase"
```

Then ask:
```
Question: "Any specific constraints or patterns I should follow?"
Options:
- "Follow existing patterns"
- "Check CONTRIBUTING.md"
- "Ask me as we go"
```

### Step 5: Create Continuity Ledger

Determine a kebab-case session name from the project directory name.

Write ledger to: `thoughts/ledgers/CONTINUITY_CLAUDE-<session-name>.md`

Use this template:

```markdown
# Session: <session-name>
Updated: <ISO timestamp>

## Goal
<User's stated goal from Step 4>

## Constraints
- Tech Stack: <detected>
- Framework: <detected>
- Build: <detected build command>
- Test: <detected test command>
- Patterns: <from CONTRIBUTING.md or user input>

## Key Decisions
(None yet - will be populated as decisions are made)

## State
- Now: [→] Initial exploration
- Next: <based on goal>

## Working Set
- Key files: <detected entry points>
- Test command: <detected, e.g., npm test, pytest>
- Build command: <detected, e.g., npm run build>
- Dev command: <detected, e.g., npm run dev>

## Open Questions
- UNCONFIRMED: <any uncertainties from analysis>

## Codebase Summary
<Brief summary from analysis - architecture, main components, entry points>
```

### Step 6: Confirm with User

Show the generated ledger summary and ask:
- "Does this look accurate?"
- "Anything to add or correct?"

## Response Format

Return to main conversation with:

1. **Project Summary** - Tech stack, architecture (2-3 sentences)
2. **Key Files** - Entry points, important directories
3. **Ledger Created** - Path to the ledger file
4. **Recommended Next Steps** - Based on user's goal

## Notes

- This agent is for BROWNFIELD projects (existing code)
- For greenfield, recommend using `/create_plan` instead
- Ledger can be updated anytime with `/continuity_ledger`
- Uses rp-cli for exploration (falls back to bash if unavailable)

© parcadei · MIT · parcadei/Continuous-Claude-v3

Similar subagents

All subagents for Agent setup: memory, context, orchestration →

From the same set161

The whole set →
interpolation Guides Claude Code through selecting and running numerical interpolation workflows, from Lagrange polynomials to SciPy splines. CX Codex +1 ★ 3,951repo stars gradient-methods gradient-methods is a Claude Code skill that helps choose gradient-based optimization methods and step sizes, and diagnose convergence in minimization problems. CX Codex +1 ★ 3,951repo stars aegis aegis is a Claude Code subagent that finds code vulnerabilities and assesses security risks. It checks a supplied threat model and writes its findings to a project file. CX Codex ★ 3,951repo stars oracle oracle — a subagent for Claude Code that searches the web, queries APIs, and gathers information from external sources. Frames research systematically and synthesizes findings through optional LLM analysis. CX Codex ★ 3,951repo stars boundary-value-problems A Claude skill that walks from a boundary value problem statement to a numerical answer: shooting, finite differences, solve_bvp and Sturm–Liouville eigenvalues. CX Codex +1 ★ 3,951repo stars atlas atlas executes acceptance and end-to-end test scenarios across web applications. It inspects your project framework, runs user journeys, and outputs failure artifacts. CX Codex ★ 3,951repo stars judge judge is a Claude Code subagent that reviews refactoring and code transformations, checking behavior changes, code quality, and safety risks. CX Codex ★ 3,951repo stars profiler profiler identifies bottlenecks in your code: slow functions, memory leaks, concurrency bugs. Profiles Python and Node.js, spots N+1 queries and blocking operations. CX Codex ★ 3,951repo stars

Project sponsors

Companies that keep this analytics open