onboard-user
Skill0 starsChanged 7 months agoMITView on GitHub
Onboard a new person to the job-hunt system: intake resumes, run initial job search, build role profiles, extract experience from resumes, gap-analyse against market demands, and interview for missing info. Creates a complete user profile ready for applications.
- Reads credentials
- Installs packages
In this repository14 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- application-trackerSkill
- applySkill
- cold-outreachSkill
- company-deep-diveSkill
- contact-populationSkill
- job-searchSkill
- meeting-prepSkill
- resume-tailorSkill
- session-checkpointSkill
- session-endSkill
- session-startSkill
- warm-followupSkill
The file
We split this skill into the rules it gives an agent
11 rules. About 0 are common, 7 are distinctive, and 4 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈7
Distinctive · estimate
This author's own choices. Worth a look.
4
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 28
Run when the user is on a NEW machine.
- Very specific: line 142
If any fail, troubleshoot per docs/SETUP.md "Troubleshooting" section.
- Distinctive: line 166
Create the database user record:
- Distinctive: line 183
Create the per-user directory structure:
- Distinctive: line 197
Ask the user to provide their resume(s):
- Distinctive: line 211
Do NOT score or filter yet — we need the full spread to build role profiles.
- Distinctive: line 246
Read the user's resume(s) and extract structured data into:
- Distinctive: line 318
Avoid yes/no — ask "tell me about a time when…" / "what was the scope of…".
- Very specific: line 336
Update user-config.yaml fit_score_adjustments based on confirmed hard gaps.
- Very specific: line 342
Update user-config.yaml with finalized gap analysis and fit-score adjustments.
- Very specific: line 343
Create role-type-schemas.yaml for the user (which bullets prefer/deprioritise per role).
≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Onboard New User
End-to-end automated onboarding that takes a person from "I have a resume" to "ready to apply".
What This Skill Does
Transforms raw resume inputs into a fully populated job-hunt profile through 8 phases:
- Environment Setup — Clone repo, configure
.env, install MCPs, verify connectivity (first time only) - Intake — Collect basic info + resume files
- Job Search — Find real postings matching their target roles/market
- Role Profiles — Synthesise what the market actually demands from those postings
- Resume Extraction — Parse resumes into structured YAML (
master-experience,skills-inventory) - Gap Analysis — Compare extracted experience vs role-profile requirements
- Interview — Ask targeted questions to fill gaps the resumes don't cover
- Finalise — Save config, summarise, list initial scored postings
Workflow
Phase 0: Environment setup (15-30 min, first time only)
Run when the user is on a NEW machine. Skip if already configured.
Prerequisites
- Claude Code installed
- Python 3.10+ with pip
- Docker Desktop (for LinkedIn MCP)
- Git installed
Step 0.1: Clone the repo
git clone https://github.com/<your-org>/job-hunt-os.git
cd job-hunt-osThe repo contains all skills, rules, scripts, templates, and shared data.
Step 0.2: Install Python dependencies
pip install python-docx pyyaml docx2pdf python-jobspy fpdf2Step 0.3: Set up .env
Copy .env.example to .env and fill in the values:
cp .env.example .env
# Edit .env in your editorKey variables (see .env.example for the full list and docs/SETUP.md for how to obtain each):
# Database (NocoDB self-hosted by default)
NOCODB_URL=http://localhost:8080
NOCODB_API_TOKEN=<your token from NocoDB Account → Tokens>
NOCODB_BASE_ID=<set after running tools/setup/init-nocodb.py>
NOCODB_MCP_PREFIX=mcp__nocodb__
# Active user
JOB_HUNT_USER=<your-slug>
# GitHub (optional, for repo sync)
GITHUB_PAT=<your PAT, scope: repo>
# OpenRouter / LLM (optional, for tools that call out to a model)
OPENROUTER_API_KEY=<your key>Step 0.4: Configure MCP servers
Edit ~/.claude.json and add the MCP server entries you need under projects > <path-to-job-hunt-os> > mcpServers. Examples:
{
"projects": {
"<path-to-job-hunt-os>": {
"mcpServers": {
"nocodb": {
"command": "npx",
"args": ["-y", "@anthropic/mcp-nocodb"],
"env": {
"NOCODB_BASE_URL": "http://localhost:8080",
"NOCODB_API_TOKEN": "<your token>"
}
},
"context7": {
"command": "npx",
"args": ["-y", "@anthropic/mcp-context7"]
},
"playwright": {
"command": "npx",
"args": ["-y", "@anthropic/mcp-playwright"]
},
"linkedin": {
"command": "docker",
"args": ["run", "-i", "--rm",
"-e", "LINKEDIN_SESSION_COOKIE=<your li_at cookie>",
"ghcr.io/anthropic/mcp-linkedin:latest"
]
}
}
}
}
}Notes per MCP:
- NocoDB: each user has their own self-hosted NocoDB instance by default (via
infrastructure/docker-compose.yml). The token is per-instance. - Context7: free documentation lookup, no auth.
- Playwright: each user needs their own installation. CRITICAL — close all Chrome instances before launching Claude Code (Playwright tools register at startup). Install:
npx playwright install chromium. - LinkedIn: each user MUST use their own
li_atsession cookie (using someone else's will get the account flagged). Requires Docker running. Cookie expires periodically.
How to get your LinkedIn li_at:
- Log in to LinkedIn in Chrome.
- DevTools (F12) → Application → Cookies →
linkedin.com. - Copy the value of
li_at.
Step 0.5: Initialise the database schema
Run:
python tools/setup/init-nocodb.pyThis creates the 7 tables (users, target_companies, target_contacts, sales_pipeline, interactions, job_postings, applications), discovers link-field IDs, and writes them to .env (NOCODB_BASE_ID and link-field IDs).
Step 0.6: Verify connectivity
Launch Claude Code in the job-hunt-os directory and run /session-start. The MCP status table will show which services are connected.
If any fail, troubleshoot per docs/SETUP.md "Troubleshooting" section.
Step 0.7: Configure local git
git config user.name "<Your Full Name>"
git config user.email "<your email>"This is repo-local only.
Phase 1: Intake (~5 min)
Gather basic info via AskUserQuestion:
- Q1: name, email, phone, LinkedIn URL, location
- Q2: target roles (free text — e.g., "Software Engineering Manager", "Data Science Lead")
- Q3: target markets / cities, remote preference
- Q4: industries to specifically want or avoid
Then:
- Generate a slug from the name (e.g., "Jane Doe" → "jane").
- Create the database user record:
mcp__nocodb__insert_record({
base_id: "${NOCODB_BASE_ID}",
table_name: "users",
data: {
full_name: "<name>",
slug: "<slug>",
email: "<email>",
phone: "<phone>",
linkedin: "<url>",
location: "<location>",
target_roles: "<roles>",
notes: "Onboarded <date>. Markets: <Q3>. Industries: <Q4>."
}
})- Create the per-user directory structure:
applications/resumes/data/{slug}/
applications/resumes/source/{slug}/
applications/{slug}/
applications/jobs/{slug}/
applications/cover-letters/{slug}/
applications/tracking/{slug}/
outreach/{slug}/messages/
outreach/{slug}/prep/
interviews/{slug}/
research/{slug}/- Set
JOB_HUNT_USER={slug}in.env. - Ask the user to provide their resume(s):
- "Please share your resume file(s). Drop them into chat or tell me the file path."
- Accept PDF, DOCX, or plain text.
- Save originals to
applications/resumes/source/{slug}/. - Multiple resumes (e.g., technical vs management) — save all; they represent different angles.
Phase 2: Initial job search (~10 min)
Using target roles + markets from Phase 1, run a broad job search:
- Construct 4-6 search queries from
target_roles[]×target_regions[]. - Capture 15-25 job postings — for each extract:
- Job title, company, key requirements (must-haves), nice-to-haves, industry keywords, seniority level.
- Save raw postings to
applications/jobs/{slug}/as YAML. - Do NOT score or filter yet — we need the full spread to build role profiles.
Phase 3: Build role profiles (~10 min)
Synthesise the 15-25 postings into 2-4 role profiles.
For each role category:
- Count frequency of each requirement across postings.
- Rank requirements by frequency (top 10-15 = "market demands this").
- Identify the standard toolkit — tools / platforms / certifications in 50%+ of postings.
- Note differentiators — requirements that appear in top postings but not all.
Save to applications/resumes/data/{slug}/role-profiles.yaml:
role_profiles:
- name: "Software Engineering Manager"
postings_analyzed: 8
must_have_skills:
- "5+ years engineering management" (8/8 postings)
- "Agile/Scrum leadership" (7/8)
- "System design" (6/8)
common_tools:
- "JIRA" (7/8)
- "GitHub" (6/8)
- "AWS/GCP" (5/8)
differentiators:
- "ML/AI experience" (3/8)
typical_seniority: "Senior Manager / Director"
typical_team_size: "8-25 direct/indirect"Present the profiles: "Based on 25 postings, here's what the market demands. Does this look right?"
Phase 4: Resume extraction (~15 min)
Read the user's resume(s) and extract structured data into:
applications/resumes/data/{slug}/master-experience.yaml:
- Contact info — name, location, phone, email, linkedin
- Summary — 2-3 variants matching their role profiles
- Experience — for each role: company, title, location, dates, achievement bullets (preserve exact wording), tags, metrics, functional_areas, better_for/avoid_for, priority (10 = flagship, 5 = filler), variant tags
- Education — degrees, institutions, dates
- Certifications — name, issuer, date
applications/resumes/data/{slug}/skills-inventory.yaml:
- Technical skills with role_relevance tags
- Management skills with evidence
- Industry knowledge with depth ratings
- Geographic expertise
applications/resumes/data/{slug}/standard-answers.yaml:
- Personal info for form auto-fill
- Professional details (years experience, current title)
common_questionsandscreening_patternsleft as TBD (filled in interview)
applications/resumes/data/{slug}/user-config.yaml:
- Pre-populate from Phase 1 intake
gap_analysissection empty (filled in Phase 5)
Save all to applications/resumes/data/{slug}/.
Phase 5: Gap analysis (~10 min)
Compare extracted resume data (Phase 4) against role profiles (Phase 3).
For each role profile, check every must-have requirement:
- COVERED: clear evidence (specific bullet, metric, or skill)
- PARTIAL: hinted at but not explicit
- GAP: no evidence
Build the gap matrix and categorise:
- Fillable gaps — user probably HAS this experience but didn't put it on their resume (interview question needed)
- Hard gaps — user genuinely doesn't have this (note for fit-scoring penalties)
- Certification gaps — missing cert that could be obtained (note as nice-to-have)
Save to applications/resumes/data/{slug}/gap-analysis.yaml:
fillable_gaps:
- requirement: "Budget management experience"
appears_in: ["SEM", "PM"]
frequency: "6/15 postings"
interview_question: "Have you managed budgets in any of your roles? Even informal P&L ownership counts."
hard_gaps:
- requirement: "PhD in Computer Science"
appears_in: ["ML Research Lead"]
frequency: "3/15 postings"
impact: "Cannot fill — adjust scoring"
fit_score_adjustments:
penalties:
- condition: "PhD required"
points: -3
bonuses:
- condition: "Startup experience valued"
points: +1These adjustments feed into config/fit-score.yaml (or are merged at scoring time — see 06-application-standards.md).
Phase 6: User interview (~15-30 min)
For each fillable gap, ask the user a targeted question via AskUserQuestion.
Approach:
- 3-5 questions at a time (batched).
- Frame to elicit specific, metric-rich answers.
- Avoid yes/no — ask "tell me about a time when…" / "what was the scope of…".
Question format:
"X% of your target postings require [REQUIREMENT]. Your resume doesn't mention this explicitly.
Have you done any of the following?
- [Specific scenario A]
- [Specific scenario B]
- [Specific scenario C]
If yes, give me details: company, what you did, scope/metrics, outcome."After each answer:
- Relevant experience → create new achievement entries in
master-experience.yaml. - Partial experience → add as a bullet with lower priority.
- Confirmed gap → move from
fillable_gapstohard_gaps. - Update
user-config.yamlfit_score_adjustmentsbased on confirmed hard gaps.
Continue until all fillable gaps are addressed or the user says "that's enough for now".
Phase 7: Finalise (~5 min)
- Update
user-config.yamlwith finalized gap analysis and fit-score adjustments. - Create
role-type-schemas.yamlfor the user (which bullets prefer/deprioritise per role). - Summary to user:
- "Profile set up with X achievement bullets across Y roles."
- "N role profiles matching M postings found."
- "Ready to start tailoring resumes and applying."
- "Z postings from the initial search scored 7+ — start with those?"
- Save initial job postings to the database (now scored with finalised fit criteria).
Rules
- NEVER fabricate achievements — only add bullets the user explicitly confirms.
- Preserve resume wording — when extracting, keep their language. Rewriting happens at tailoring time.
- Save frequently — write YAML files after each phase, don't wait until the end.
- Phase 2 is broad on purpose — diverse postings → accurate role profiles.
- Interview questions must be specific — "Have you managed budgets?" is bad. "In your role at [Company], what was the budget you were responsible for?" is good.
- Batch operations — use
bulk_insertfor DB records, parallelWebSearchfor job searches. - Include
user_idon all DB records created during onboarding. - The user's slug is used everywhere — directory names, DB queries, script flags.
- Never write a real
li_atcookie or PAT into a tracked file. Only.env(gitignored).
Time Estimate
| Phase | Duration | Notes |
| 0. Environment Setup | 15-30 min | First time only |
| 1. Intake | 5 min | Info + resumes |
| 2. Job Search | 10 min | Automated WebSearch |
| 3. Role Profiles | 10 min | Analysis + confirmation |
| 4. Resume Extraction | 15 min | Parsing + structuring |
| 5. Gap Analysis | 10 min | Comparison + categorisation |
| 6. Interview | 15-30 min | Depends on gap count |
| 7. Finalise | 5 min | Save + summarise |
| Total (first time) | ~90-120 min | Includes env setup |
| Total (returning) | ~60-90 min | Skip Phase 0 |
Triggering This Skill
- From
/session-startwhen user selects "New user (onboard someone new)". - Directly via
/onboard-user. - Can be resumed mid-phase if a session is interrupted (phases save state to disk).
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

