Skills: Jobhunt

The /jobhunt skill manages your job search as a knowledge graph. The agent acts as your career coach, building understanding of positions, companies, and your fit over time. It supports two operational modes: interactive (Claude Code session) and automated (OpenClaw cron forager running overnight).

Overview

The skill follows the five-stage curation workflow:

Foraging — Discover job postings (manual URLs or automated forager)
Ingestion — Fetch raw content, store as artifact with provenance
Sensemaking — Agent reads artifact, extracts entities, creates notes
Analysis — Query across notes to answer gap analysis questions
Reporting — Dashboard views of pipeline and skills

Quick Start

Build Your Skill Profile

Before analyzing jobs, add your skills:

You: My skills are:
     - Python: strong (5 years production)
     - Machine Learning: strong (built models at CZI)
     - Distributed Systems: some (built caching layer, some k8s)
     - Rust: learning (started last month)

Agent: [Creates skill profile with levels]

Added 4 skills to your profile. I'll use these for fit analysis.

Or directly:

uv run python .claude/skills/jobhunt/jobhunt.py add-skill \
    --name "Python" --level "strong"

uv run python .claude/skills/jobhunt/jobhunt.py add-skill \
    --name "Distributed Systems" --level "some" \
    --description "Built caching layer, some k8s experience"

Add a Job Posting

You: I found a job at Anthropic:
     https://boards.greenhouse.io/anthropic/jobs/123456

Agent: I'll ingest and analyze this posting...

[Fetches job description]
[Extracts company info, requirements, qualifications]
[Compares against your skill profile]
[Creates fit analysis]

## Analysis: Research Engineer at Anthropic

**Your Fit: 82%**

| Requirement | Level | You | Match |
|-------------|-------|-----|-------|
| Python | Required | Strong | ✓ |
| ML Systems | Required | Strong | ✓ |
| Distributed Systems | Required | Some | △ |
| Rust | Preferred | None | ✗ |

Key Gap: Distributed systems required; recommend DDIA + MIT 6.824.

Want me to set a priority level?

Automated Forager

The forager automates discovery by searching job boards and aggregators, filtered by your skill profile. This is the OpenClaw killer feature: configure it once, run nightly via cron, triage results in Telegram.

Setup: Add Search Sources

# Company boards (no auth required)
uv run python .claude/skills/jobhunt/job_forager.py add-source \
    --name "Anthropic" --platform greenhouse --token anthropic

uv run python .claude/skills/jobhunt/job_forager.py add-source \
    --name "LangChain" --platform ashby --token langchain

# Aggregator sources
uv run python .claude/skills/jobhunt/job_forager.py add-source \
    --name "ML Jobs" --platform linkedin \
    --query "machine learning" --location "San Francisco"

uv run python .claude/skills/jobhunt/job_forager.py add-source \
    --name "Remote ML" --platform remotive \
    --query "machine learning"

Heartbeat: Full Discovery Cycle

# Search all sources, filter by skill profile, dedup, store candidates
uv run python .claude/skills/jobhunt/job_forager.py heartbeat \
    --min-relevance 0.3

Triage Candidates

# List new candidates from overnight run
uv run python .claude/skills/jobhunt/job_forager.py list-candidates --status new

# Review and triage
uv run python .claude/skills/jobhunt/job_forager.py triage \
    --id candidate-abc123 --action reviewed

# Promote to full position (triggers sensemaking workflow)
uv run python .claude/skills/jobhunt/job_forager.py promote \
    --id candidate-abc123

Supported Platforms

Platform	Type	Auth	Key Arg
`greenhouse`	Company board	None	`--token` (slug, e.g. `anthropic`)
`lever`	Company board	None	`--token` (slug)
`ashby`	Company board	None	`--token` (slug)
`linkedin`	Aggregator	None	`--query`, `--location`
`remotive`	Aggregator	None	`--query`, `--location`
`adzuna`	Aggregator	API key	`--query`, `--location`

OpenClaw Cron Configuration

To run the forager overnight via OpenClaw, add a cron entry in openclaw.yaml:

crons:
  - name: jobhunt-forager
    schedule: "0 2 * * *"    # 2am nightly
    command: |
      uv run python .claude/skills/jobhunt/job_forager.py heartbeat \
          --min-relevance 0.3
    notify_telegram: true     # sends candidate count to Telegram on completion

See OpenClaw Configuration for full cron and notification setup.

Sensemaking Workflow (7 Steps)

When you say “analyze this job posting” or after promoting a forager candidate, the agent follows this workflow:

Step 1: Get the Artifact

uv run python .claude/skills/jobhunt/jobhunt.py show-artifact --id "artifact-xyz"

Step 2: Read and Comprehend

The agent reads the full job description, identifying:

Company name, job title, location, salary, remote policy
Requirements, responsibilities, qualifications
Team info, culture signals, growth opportunities

Step 3: Create/Update Company

uv run python .claude/skills/jobhunt/jobhunt.py add-company \
    --name "Anthropic" \
    --url "https://anthropic.com" \
    --description "AI safety research company"

Step 4: Extract Requirements as Fragments

uv run python .claude/skills/jobhunt/jobhunt.py add-requirement \
    --position "position-abc123" \
    --skill "Python" \
    --level "required" \
    --your-level "strong" \
    --content "5+ years Python experience, focus on ML systems"

uv run python .claude/skills/jobhunt/jobhunt.py add-requirement \
    --position "position-abc123" \
    --skill "Distributed Systems" \
    --level "required" \
    --your-level "some" \
    --content "Experience with distributed training at scale"

Step 5: Create Analysis Notes

# Fit analysis note (with score)
uv run python .claude/skills/jobhunt/jobhunt.py add-note \
    --about "position-abc123" \
    --type fit-analysis \
    --content "Strong fit for core requirements. Gap in distributed systems." \
    --fit-score 0.82 \
    --fit-summary "Strong technical fit, one gap to address"

# Company research note
uv run python .claude/skills/jobhunt/jobhunt.py add-note \
    --about "company-xyz" \
    --type research \
    --content "Series C, $4B raised. Strong safety focus. ~400 employees."

# Skill gap note
uv run python .claude/skills/jobhunt/jobhunt.py add-note \
    --about "position-abc123" \
    --type skill-gap \
    --content "Distributed systems required. Recommend: DDIA book, MIT 6.824 course."

Step 6: Flag Uncertainties

uv run python .claude/skills/jobhunt/jobhunt.py tag \
    --entity "requirement-xyz" --tag "uncertain"

Step 7: Report to User

The agent summarizes: company overview, fit score breakdown, key gaps, suggested next steps.

Application Tracking

# Update status
uv run python .claude/skills/jobhunt/jobhunt.py update-status \
    --position "position-abc123" \
    --status "applied" \
    --date "2025-02-05"

# Interaction note (phone screen)
uv run python .claude/skills/jobhunt/jobhunt.py add-note \
    --about "position-abc123" \
    --type interaction \
    --content "Phone screen went well, moving to technical round." \
    --interaction-type "call" \
    --interaction-date "2025-02-05"

# Strategy note
uv run python .claude/skills/jobhunt/jobhunt.py add-note \
    --about "position-abc123" \
    --type strategy \
    --content "Lead with distributed systems work from caching project."

Status values: researching applied phone-screen interviewing offer rejected withdrawn

Skill Gap Analysis

You: What skill gaps do I have across my high-priority positions?

Agent: [Queries positions, aggregates gaps]

Across 3 high-priority positions:

| Skill | Frequency | Your Level | Priority |
|-------|-----------|------------|----------|
| Distributed Systems | 3/3 | Some | Critical |
| Kubernetes | 2/3 | Some | High |
| Rust | 1/3 | Learning | Medium |

I recommend focusing on Distributed Systems first.
Want me to find learning resources?

Add Learning Resources

uv run python .claude/skills/jobhunt/jobhunt.py add-resource \
    --name "Designing Data-Intensive Applications" \
    --type "book" \
    --url "https://dataintensive.net" \
    --hours 30 \
    --skills "distributed-systems" "system-design"

Command Reference

Profile Commands

Command	Description	Key Args
`add-skill`	Add to your skill profile	`--name`, `--level`
`list-skills`	Show your skills

Ingestion Commands

Command	Description	Key Args
`ingest-job`	Fetch job URL, store raw artifact	`--url`, `--priority`, `--tags`
`list-artifacts`	List artifacts by status	`--status`
`show-artifact`	Get artifact content	`--id`

Sensemaking Commands

Command	Description	Key Args
`add-company`	Add company	`--name`, `--url`
`add-position`	Add position manually	`--title`
`add-requirement`	Add skill requirement	`--position`, `--skill`, `--level`, `--your-level`
`add-note`	Create any note type	`--about`, `--type`, `--content`
`add-resource`	Add learning resource	`--name`, `--type`, `--url`

Query Commands

Command	Description	Key Args
`list-pipeline`	Show applications	`--status`, `--priority`
`show-position`	Position details	`--id`
`show-company`	Company details	`--id`
`show-gaps`	Skill gap analysis
`learning-plan`	Prioritized study list
`update-status`	Change application status	`--position`, `--status`
`tag`	Tag an entity	`--entity`, `--tag`
`search-tag`	Find by tag	`--tag`
`link-collection`	Link paper collection to skill gap	`--collection`, `--skill`

Report Commands (Markdown Output)

Command	Description	Key Args
`report-pipeline`	Pipeline overview
`report-stats`	Stats summary
`report-gaps`	Skill gaps report
`report-position`	Position detail	`--id`

Forager Commands

Command	Description	Key Args
`add-source`	Add a search source	`--name`, `--platform`, `--token`/`--query`
`list-sources`	List search sources
`remove-source`	Remove a source	`--id` or `--name`
`suggest-sources`	Profile-driven suggestions
`search-source`	Search one source	`--source`
`heartbeat`	Full discovery cycle	`--min-relevance`
`list-candidates`	List candidates	`--status`, `--source`
`triage`	Review/dismiss candidate	`--id`, `--action`
`promote`	Promote to full position	`--id`

TypeDB Schema Highlights

The jobhunt namespace (namespaces/jobhunt.tql) extends the core three-branch hierarchy:

domain-thing
├── your-skill              # Your skills for gap analysis (skill-name, skill-level)
├── jobhunt-company         # Employer organization (company-url, location)
├── jobhunt-position        # Specific job posting (job-url, priority-level, remote-policy)
├── jobhunt-learning-resource  # Course, book, tutorial (resource-type, estimated-hours)
├── jobhunt-contact         # Person at a company (contact-role, contact-email)
├── jobhunt-search-source   # Company board for forager (board-platform, board-token)
└── jobhunt-candidate       # Discovered posting (relevance-score, candidate-status)

collection
└── jobhunt-search          # A job search campaign

artifact
├── jobhunt-job-description # Full JD text (raw HTML)
├── jobhunt-resume          # Resume versions
├── jobhunt-cover-letter    # Tailored cover letters
└── jobhunt-company-page    # Careers/about page content

fragment
├── jobhunt-requirement     # Single skill requirement (skill-name, skill-level, your-level)
├── jobhunt-responsibility  # Job responsibility
└── jobhunt-qualification   # Required/preferred qualification

note
├── jobhunt-fit-analysis-note    # Fit assessment (fit-score, fit-summary)
├── jobhunt-research-note        # Company research
├── jobhunt-interview-note       # Interview prep/feedback (interview-date)
├── jobhunt-strategy-note        # Talking points, approach
├── jobhunt-skill-gap-note       # Learning needs
├── jobhunt-application-note     # Status tracking (application-status, applied-date)
└── jobhunt-interaction-note     # Contact logs (interaction-type, interaction-date)

Key relations:

Relation	Roles	Purpose
`position-at-company`	position, employer	Links positions to companies
`requirement-for`	requirement, position	Links requirements to positions
`addresses-requirement`	resource, requirement	Learning resources for skill gaps
`source-provides`	source, candidate	Forager: which source found a candidate
`works-at`	employee, employer	Contacts at companies

Cross-namespace bridge: collection plays addresses-requirement:resource — a scilit paper collection (from epmc-search) can directly address a jobhunt skill gap requirement.

TypeDB Query Examples

# All skill gaps in high-priority positions
match
    $p isa jobhunt-position, has priority-level "high";
    $r isa jobhunt-requirement;
    (position: $p, requirement: $r) isa requirement-for;
    $r has your-level "none";
fetch {
    "position": $p.name,
    "skill": $r.skill-name,
    "level": $r.skill-level
};

# Fit scores across all positions
match
    $p isa jobhunt-position;
    $n isa jobhunt-fit-analysis-note, has fit-score $score;
    (about: $p, note: $n) isa annotation;
fetch {
    "position": $p.name,
    "fit_score": $score
};

# Learning resources for a specific gap
match
    $r isa jobhunt-requirement, has skill-name "Distributed Systems";
    $lr isa jobhunt-learning-resource;
    (resource: $lr, requirement: $r) isa addresses-requirement;
fetch {
    "resource": $lr.name,
    "type": $lr.resource-type,
    "hours": $lr.estimated-hours
};

Cross-Skill Integration

Link Literature to Learning Plan

Search for papers on a skill gap topic and link them to your learning plan:

# Search for papers (epmc-search skill)
uv run python .claude/skills/epmc-search/epmc_search.py search \
    --query "machine learning systems design" \
    --collection "ML Systems Reading List"

# Link the paper collection to your skill gap
uv run python .claude/skills/jobhunt/jobhunt.py link-collection \
    --collection "<collection-id>" \
    --skill "machine-learning"

# View updated learning plan
uv run python .claude/skills/jobhunt/jobhunt.py learning-plan

The addresses-requirement relation bridges the scilit and jobhunt namespaces, enabling TypeDB to reason across both skills in a single query.

Dashboard

The Next.js dashboard (make dashboard-dev) provides:

Pipeline Board (/jobhunt) — Kanban columns by application status
Position Detail (/jobhunt/position/{id}) — Requirements, notes, gap analysis, fit score
Collection Detail (/jobhunt/collection/{id}) — Notes and resources grouped by collection