agentleFS
james5101james5101/jobtrack/.claude/skills/smart-job-search/SKILL.md

smart-job-search

Skill2 starsChanged 6 months agoMITView on GitHub

Run a repeatable job search across a user-chosen set of employers' careers sites (and LinkedIn) for roles matching the user's profile, deduped against applications already tracked in jobtrack via MCP. Use when the user wants to find new jobs to apply to, refresh their leads, or says "search for jobs", "find me openings", "run the job search". Produces standardized per-company files plus a single ranked shortlist.

The file

We split this skill into the rules it gives an agent

9 rules. About 0 are common, 5 are distinctive, and 4 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈5

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

    Don't assume any of these — confirm them at the start of a run.

    line 14
  2. Very specific:

    Pull jobtrack state first: Call the jobtrack MCP list_applications to get every company + role + status already tracked.

    line 24
  3. Distinctive:

    If neither path returns data → unreachable (handle as below).

    line 39
  4. Very specific:

    Dedupe against jobtrack: Check each candidate posting against the tracked set (find_application_by_company confirms a specific company):

    line 45
  5. Distinctive:

    Never silently drop a match.

    line 49
  6. Very specific:

    No scratch artifacts in the repo: Keep intermediate data in context.

    line 62
  7. Distinctive:

    Use one consistent format for every per-company file in a run.

    line 67
  8. Distinctive:

    Every per-company file uses the standard template and ends in one of the three states (matches / no matches / unreachable).

    line 132
  9. Very specific:

    If the user has overlapping applications, the "skipped (already in jobtrack)" count is non-zero — if it's zero, double-check the MCP dedupe …

    line 135

≈ “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.

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

Smart job search

Find current openings at a set of employers the user cares about, match them against the user's profile, skip anything they've already applied to (via the jobtrack MCP), and produce both per-company capture files and one ranked shortlist to act on.

The intelligence is yours: you do the searching, scraping, matching, and ranking with the browser/fetch tools you already have. jobtrack's role is the dedupe — it knows what's already in flight so the search doesn't resurface it.

Inputs to gather first

Don't assume any of these — confirm them at the start of a run. Different users want different things.

  • Roles / titles. What the user is targeting. Example: "DevOps, Platform Engineering, SRE, Cloud Infrastructure." Include adjacent titles (e.g. "Software Engineer") only when the posting body matches the focus.
  • Location filter. Example: "Remote-eligible OR a specific city." Decide whether on-site-elsewhere roles are excluded outright or kept as near-misses.
  • Target companies. The set to search. This might be a list the user maintains (e.g. the LinkedIn Top Companies list), a handful of dream employers, or a sector ("fintechs hiring SREs"). Example set: Google, Microsoft, Stripe, Datadog, Cloudflare. Ask — there is no default list.
  • Resume. Pull the most recent resume text via the jobtrack MCP get_recent tool (its files.resume_text), or ask for a resume path if MCP returns nothing. The resume drives the fit ranking.
  • Output folder. Where to write results. Default to a jobs/ directory; confirm the location.

The pattern

  1. Pull jobtrack state first. Call the jobtrack MCP list_applications to get every company + role + status already tracked. Hold this as the dedupe set. (find_application_by_company confirms a specific match.) If the MCP server isn't connected, say so and proceed without dedupe rather than guessing.
  2. Pull the resume via get_recent so the fit ranking has something to score against.
  3. Search and capture. Two entry paths — pick per run:

    • Company-by-company — for a fixed target list, search each employer's openings.
    • Role + location — one search for the role across a metro, then group hits by company. More efficient when the user cares about a location (e.g. "platform roles in Jacksonville" surfaces several employers in one query).

    Filter results to the role + location profile. Apply the location/remote cut early — it's the most decisive filter. A remote-primary search at large enterprises typically returns near-zero (they hub-concentrate infra hiring on-site); a remote filter surfaces that fast and should reshape the company set (remote-primary ⇒ favor remote-native / cloud-native companies over big enterprises).

    Fetching — use the tool that matches the page and its auth needs:

    1. WebFetch on a direct posting URL or a LinkedIn job-search URL (e.g. linkedin.com/jobs/search/?keywords=...&location=...&f_WT=2, where f_WT=2 = remote). Server-rendered enough to read, no browser needed. Caveat: LinkedIn keywords=<CompanyName> is imprecise — it matches any posting that mentions the company (searching "Microsoft" returned an Oracle role). To pin a company, use LinkedIn's f_C=<companyId> filter, or extract strictly by employer from the results.
    2. A browser tool for first-party career boards (Workday / Greenhouse / Ashby / custom SPAs — e.g. Microsoft, Datadog, Amazon). WebFetch returns only chrome/config on these (it can't run their JS). Two engines — pick by context:
      • Claude in Chrome — for interactive runs and any logged-in source (LinkedIn especially): it rides your real signed-in Chrome, so results are complete. Costs: per-domain permission prompts, a second "act" grant to type/click, and get_page_text sometimes returns nav chrome (use find / read_page for the results region; read_network_requests to grab a board's JSON API).
      • Playwright (headless) — for public boards and unattended/scheduled runs (the engine the jobtrack-agent pipeline should use). No permission prompts, deterministic waitForLoadState / waitForSelector, can drive the search box and extract structured rows. Costs: cookieless by default, so logged-in sources (LinkedIn) hit walls / bot-detection unless you supply a persisted profile — and scripted LinkedIn scraping breaks its ToS.
    3. If neither path returns data → unreachable (handle as below).

    Per-board quirks seen in practice (expect each board to differ — there's no one URL recipe): Google honors URL ?q= queries cleanly. Microsoft ignores URL queries and forces "latest" — you must drive its search box. Amazon returns zero results if you pass an invalid country= param (drop it). Don't assume "careers site = easy, LinkedIn = hard" — with these tools it's often the reverse.

    If you cannot access a company's postings with either tool — login wall, bot detection, JS you can't render, fetch error — do not omit it and do not invent results. Write an honest entry saying you couldn't scrape it and why, and flag it for manual review. An accurate "couldn't reach this one" is a valid, useful result.

  4. Dedupe against jobtrack. Check each candidate posting against the tracked set (find_application_by_company confirms a specific company):
    • Same company + same role → don't list as new; put it under "Already applied".
    • Same company, different role → list it as new, but annotate inline that an application already exists at that company (with its status) so the user can decide whether to double up.
    • New company → list as new. Never silently drop a match; the user wants to see it was considered.
  5. Rank by resume fit. For each new posting, assign High / Medium / Low fit with a one-line rationale tied to the resume (e.g. "5+ yrs Kubernetes + AWS matches required stack"). Be honest — don't inflate.
  6. Write the output (both forms).

Scope & stop conditions — read this before scraping

The goal is a ranked shortlist of best-fit roles, not a complete index of every posting. Stay bounded:

  • Read the first page / top ~15–25 results of a role+remote-filtered search per company. That's enough to rank and recommend. If the first filtered page shows no matches, that is the answer — record it and move on.
  • Do NOT paginate exhaustively to "get them all," intercept XHR/JSON APIs, reverse-engineer a board's backend (Typesense/Workday/etc.), or write parser scripts to crunch raw API dumps. If you find yourself doing any of these, you've overshot — stop and just read the rendered first page.
  • Cap browser actions to a handful per company. A bounded, slightly-incomplete result beats a deep crawl. Breadth across companies > depth on one.
  • No scratch artifacts in the repo. Keep intermediate data in context. Only write the final jobs/*.md files. Never dump response bodies or JSON into the repo; if you genuinely must persist scratch, use an OS temp dir outside the repo.
  • No ad-hoc python parser scripts. This is a uv project — bare python isn't on PATH, and if you're parsing raw API payloads you've already overshot (see above).

Output format

Use one consistent format for every per-company file in a run. Write to the chosen output folder.

Per-company file — <Company>.md

# <Company> — <role focus> Jobs

> Searched <YYYY-MM-DD>. Profile: <roles>; <location filter>.
> Source: <careers site URL | LinkedIn>.

| Job Title | Location | Fit | Apply |
|-----------|----------|-----|-------|
| Senior SRE | Remote | High | [Apply](url) |

## Already applied (skipped)
- Lead DevOps Engineer — tracked in jobtrack as `<app-id>` (status: screening)

## Near-misses (right role, wrong location)
- Infrastructure Engineer III — Columbus, OH (on-site)

States a per-company file can end in:

  • Matches found — fill the table.
  • No matches — keep the header + criteria, then No matching roles found at time of search. Optionally add near-misses so the user knows the company has relevant roles, just not matching the filter.
  • Couldn't scrape — Unable to access <Company>'s postings: <reason, e.g. login wall / bot detection / fetch failed>. Needs manual check — no results captured. Never leave this implicit.

Ranked shortlist — _shortlist.md

Leading underscore sorts it to the top of the folder. This is the act-on-it file.

# Job Search Shortlist — <YYYY-MM-DD>

Profile: <roles> · <location filter>.
Searched <N> companies · <M> new matches · <K> skipped (already in jobtrack) · <U> unreachable.

| Rank | Company | Role | Location | Fit | Why | Apply |
|------|---------|------|----------|-----|-----|-------|
| 1 | Google | Senior SRE, Cloud | Remote | High | K8s+AWS+Go all present in resume | [Apply](url) |

## Unreachable (manual check)
- <Company> — <reason>

Sort by fit (High → Low). Cap the shortlist at the top ~20–30 so it's actionable. Surface unreachable companies explicitly so they aren't silently dropped.

After the run

Offer to capture the ones the user wants to pursue into jobtrack with jobtrack add (CLI — creating applications is intentionally CLI-only, not an MCP tool). Don't auto-add; let the user pick from the shortlist.

Anti-patterns

  • ❌ Inventing postings, apply links, or results for a site you couldn't actually load. If a fetch fails, report the failure.
  • ❌ Silently omitting a company you couldn't scrape. Give it an explicit "unreachable" entry.
  • ❌ Re-listing jobs the user already applied to as if new. Dedupe against list_applications first.
  • ❌ Inflating fit. An honest Low beats a wall of "High".
  • ❌ Inconsistent file formats across companies in the same run. Use one template.
  • ❌ Trying to read a JS career board (Workday/Greenhouse/SPA) with WebFetch and giving up. Those need a browser engine — Claude in Chrome (logged-in/interactive) or headless Playwright (public/unattended) — before you call them unreachable.
  • ❌ Reverse-engineering a board's search API, intercepting XHR, or paginating exhaustively to "get them all." Read the first filtered page and move on — see "Scope & stop conditions."
  • ❌ Writing scratch files (API dumps, JSON, parser scripts) into the repo. Only jobs/*.md gets written.
  • ❌ Auto-adding to jobtrack. The user decides what to pursue.
  • ❌ Assuming a company list, profile, or location. Gather them at the start of the run.

Verify

  • Every per-company file uses the standard template and ends in one of the three states (matches / no matches / unreachable).
  • The shortlist exists, is ranked, and reports the matched / skipped / unreachable counts.
  • Spot-check 2–3 apply links resolve to a real posting.
  • If the user has overlapping applications, the "skipped (already in jobtrack)" count is non-zero — if it's zero, double-check the MCP dedupe actually ran.

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.