agentleFS
alexmonegropalexmonegrop/job-hunt-os/.claude/skills/job-search/SKILL.md

job-search

Skill0 starsChanged 7 months agoMITView on GitHub

Automated job discovery across Indeed, Glassdoor, LinkedIn, and regional boards using python-jobspy + Playwright LinkedIn search + WebSearch. Scores results by fit (0-10), applies adjusted-score adjustments from config/fit-score.yaml, batch-creates Job Posting records, and cross-references with existing Target Companies. Use when searching for new opportunities or running periodic sweeps.

36 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use cover-letter, company-research and 1 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • claude-office-skillsSkill

    cover-letter

    >

    Also in 4 projects that use this

  • claude-office-skillsSkill

    company-research

    Conduct comprehensive company research and due diligence. Analyze business model, competitive landscape, management, and market position.

    Also in 3 projects that use this

  • VercelSkill

    setup

    Set up Vercel CLI and project configuration. Use when the user says "set up Vercel", "configure Vercel", "link to Vercel", or "vercel init".

    Also in 3 projects that use this

The file

We split this skill into the rules it gives an agent

8 rules. 0 are common, 4 are distinctive, and 4 are very specific to this project.

  • 0

    Common

    Most of the 31 edited versions we read keep these.

  • 4

    Distinctive

    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
  1. Distinctive:

    Search-results snapshots are small (~10K chars) and contain clean job-listing data:

    line 79
  2. Very specific:

    Search-result snapshots are small — browser_navigate is safe.

    line 99
  3. Very specific:

    NEVER use browser_navigate or browser_snapshot on individual job-detail pages (500K+ chars).

    line 100
  4. Very specific:

    If browser_navigate times out on search, retry ONCE.

    line 101
  5. Distinctive:

    Prefer LinkedIn Playwright data (most accurate, real-time).

    line 131
  6. Distinctive:

    ALWAYS present both raw and adjusted scores in the summary.

    line 164
  7. Very specific:

    Create all qualifying records (adjusted ≥ 5) via bulk_insert.

    line 182
  8. Distinctive:

    ALWAYS check for duplicate postings: before creating records.

    line 261

“Common” is measured: kept by at least 6 in 10 of the 31 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Job Search

Automated job discovery and scoring across multiple boards.

What This Skill Does

  • Multi-board search — Indeed, Glassdoor, LinkedIn via python-jobspy
  • LinkedIn Playwright search — direct LinkedIn job search via Playwright (logged in as the active user) — supplements jobspy with real-time results, Easy Apply filtering, accurate posting data
  • LinkedIn MCP search_jobs — fast URL-only discovery (no DOM parsing)
  • Regional board coverage — additional boards via WebSearch + Playwright (configured in config/regions.yaml job_boards[])
  • Fit scoring — 0-10 raw score, then adjusted score per config/fit-score.yaml
  • Batch processing — score all results, then bulk_insert records
  • Cross-reference — check existing Target Companies for warm-application opportunities
  • Deduplication — check existing Job Postings to avoid double-creating

Prerequisites

Required:

  • Python 3.10+ with python-jobspy
  • Database access (mcp__nocodb__*, ${NOCODB_BASE_ID})
  • Playwright MCP (load via ToolSearch each session — tools are deferred)
  • LinkedIn MCP (optional, recommended)
  • config/fit-score.yaml, config/user-profile.yaml, config/regions.yaml

Quick Start

"Search for Program Manager jobs in [target city]"
"Find AI Product Manager roles in [target country] on Indeed and LinkedIn"
"Search for open roles at Acme Renewables, Globex Power, Initech AI"

Workflow

Step 1: Define search parameters

Gather from user or load from config/user-profile.yaml:

  • Keywords — from target_roles[]
  • Locations — from target_regions[]
  • Boards — from config/regions.yaml job_boards[] (default: all available)
  • Distance — radius in miles (default: 50)
  • Results per board — default: 20

Step 2: Execute searches in parallel

Source A: python-jobspy (passive — no login)

from jobspy import scrape_jobs

jobs = scrape_jobs(
    site_name=["indeed", "glassdoor", "linkedin"],
    search_term="Program Manager AI",
    location="[target city, country]",
    results_wanted=20,
    country_indeed="[country]"
)

Known limitations:

  • Glassdoor doesn't support all countries — check before searching.
  • Some regional boards return 403 — fall back to WebSearch.
  • Indeed in some markets is very noisy — title-filter aggressively.
  • LinkedIn via jobspy is a passive scrape; may miss recent postings.

Source B: LinkedIn Playwright search (active — logged in)

CRITICAL: load Playwright tools first via ToolSearch("playwright browser").

browser_navigate → https://www.linkedin.com/jobs/search/?keywords=<role>&location=<city>

Search-results snapshots are small (~10K chars) and contain clean job-listing data:

  • Job title (link text)
  • Company name
  • Location + work mode (On-site / Hybrid / Remote)
  • Job ID (from URL: /jobs/view/{ID}/)

Each listitem in the search-results list contains:

- listitem:
    - link "Job Title":
        - /url: /jobs/view/JOBID/?trk=...
    - generic: Company Name
    - generic: Location (Work Mode)

Extract job ID with regex: /jobs/view/(\d+)/.

Pagination: &start=25, &start=50, etc.

Anti-loop rules:

  • Search-result snapshots are small — browser_navigate is safe.
  • NEVER use browser_navigate or browser_snapshot on individual job-detail pages (500K+ chars).
  • If browser_navigate times out on search, retry ONCE. If it fails again, fall back to jobspy-only.
  • Max 3 pages of results (start=0, 25, 50) per search — diminishing relevance after that.

Easy Apply filter: add &f_AL=true to URL.

Source C: LinkedIn MCP search_jobs (fast, no DOM parsing)

mcp__linkedin__search_jobs({
  keywords: "Program Manager",
  location: "[target city]",
  limit: 25
})
// Returns: { job_urls: ["https://www.linkedin.com/jobs/view/<id>/", ...], count: N }

Strengths: fast, returns clean URLs, no snapshot issues. Limitations: URL-only (no titles/companies/descriptions). Cross-reference with Source B or WebFetch. Note: get_job_details returns mostly null fields — unreliable for metadata.

Source D: WebSearch (regional boards)

WebSearch "site:[regional board] [role] [region] <current year>"

Step 3: Deduplicate across sources

Merge results from Sources A-D:

  • Match by job ID (LinkedIn) or by (company, title) cross-board.
  • Prefer LinkedIn Playwright data (most accurate, real-time).
  • Flag duplicates found across sources.

Step 4: Score results

Calculate raw fit score (0-10) per config/fit-score.yaml raw_criteria[]:

CriteriaPointsHow to Assess
Role Alignment0-3Posting role vs target_roles[]
Region Expansion Signal0-2Company expanding in target_regions[]
Industry Match0-2Posting industry vs target_industries[]
Seniority Fit0-1Senior / Director / VP level
Geography Match0-1Based in target region or remote-friendly
Existing Contact Bonus0-1Company already in target_companies

Step 4b: Calculate adjusted score (MANDATORY)

Apply penalties + bonuses from config/fit-score.yaml (penalties[], bonuses[]).

The agent reads the actual values from config — DO NOT hardcode.

Adjusted Score = Raw Score + Bonuses − Penalties (floor at 0).

Step 4c: Apply adjusted-score thresholds

Adjusted ScoreActionProtocol
7+FullTailored resume + cover letter + portal-first
5-6LongshotEasy Apply only, generic template, no cover letter, tag "LONGSHOT"
3-4Skip (unless user overrides)Present to user with reasoning
<3Auto-skipNo DB record needed

ALWAYS present both raw and adjusted scores in the summary.

Step 5: Cross-reference Target Companies

mcp__nocodb__search_records({
  base_id: "${NOCODB_BASE_ID}",
  table_name: "target_companies",
  query: "Company Name"
})

Flag results where:

  • Company exists → "Warm Application" opportunity
  • Company has existing networking contacts → prioritise

Step 6: Batch-create Job Posting records

Create all qualifying records (adjusted ≥ 5) via bulk_insert. Tag longshots (5-6) with "LONGSHOT" in notes:

mcp__nocodb__bulk_insert({
  base_id: "${NOCODB_BASE_ID}",
  table_name: "job_postings",
  records: [
    {
      job_title: "...",
      company_name: "Acme Renewables",
      company_id: 159,
      job_board: "LinkedIn",
      job_url: "https://www.linkedin.com/jobs/view/<id>/",
      location: "[city, country]",
      fit_score: 8,
      status: "New",
      discovered_date: "2026-MM-DD",
      user_id: ${ACTIVE_USER_ID}
    },
    // ... all qualifying postings
  ]
})

Step 7: Report summary

Output a summary table with BOTH scores:

| # | Company | Job Title | Source | Raw | Adj | Protocol | Easy Apply? | Warm? | Status  |
|---|---------|-----------|--------|-----|-----|----------|-------------|-------|---------|
| 1 | Acme    | Sr PM     | Indeed | 8   | 9   | Full     | No          | Yes   | Created |
| 2 | Globex  | AI PM     | LI PW  | 7   | 9   | Full     | Yes         | No    | Created |
| 3 | Initech | PM        | LI PW  | 6   | 3   | Skip     | Yes         | No    | Skipped |
| 4 | MBB Co  | Consultant| LI PW  | 7   | 5   | Longshot | Yes         | No    | Created |

Protocol column: Full (7+), Longshot (5-6), Skip (3-4), Auto-skip (<3).

Search Templates

These are illustrative — generate actual queries from config/user-profile.yaml target_roles[] × target_regions[].

search_term = "Program Manager"
locations = ["[target city 1]", "[target city 2]"]
search_term = "AI Product Manager"
# OR: "ML Product", "AI Strategy", "AI Program Manager"
search_term = "Digital Transformation Director"
# OR: "DT Manager", "Innovation Director"
search_term = "Operations Director"
# OR: "Delivery Manager", "PMO Director"

LinkedIn Search URL Parameters

ParameterPurposeExample
keywordsSearch termsProgram%20Manager
locationLocation filter[city]
startPagination offset0, 25, 50
f_ALEasy Apply onlytrue
f_TPRTime postedr86400 (24h), r604800 (week), r2592000 (month)
f_EExperience level4 (mid-senior), 5 (director)
f_JTJob typeF (full-time), C (contract)

Rules

  1. ALWAYS score before creating records — no unscored postings in the database.
  2. ALWAYS cross-reference Target Companies — flag warm opportunities.
  3. ALWAYS check for duplicate postings before creating records.
  4. ALWAYS use multiple sources — jobspy + LinkedIn Playwright/MCP + WebSearch (use at least 2).
  5. NEVER use browser_snapshot on individual LinkedIn job pages — 500K+ chars, causes loops.
  6. Batch-create all records via bulk_insert.
  7. Include the current year and prior year in search queries.
  8. Max 2 retries on any Playwright action — if it fails twice, fall back to jobspy-only.
  9. Load Playwright tools via ToolSearch at start of every session (deferred tools).
  10. ALWAYS present both raw and adjusted scores in summary tables.

Download now (ZIP)

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
What did you use it for? e.g. Reviewing pull requests in a Rails app

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.