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.
In this repository3 other files it gives its agents.
- add-application-fieldSkill
- add-cli-commandSkill
- add-mcp-toolSkill
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
- Distinctive: line 14
Don't assume any of these — confirm them at the start of a run.
- Very specific: line 24
Pull jobtrack state first: Call the jobtrack MCP list_applications to get every company + role + status already tracked.
- Distinctive: line 39
If neither path returns data → unreachable (handle as below).
- Very specific: line 45
Dedupe against jobtrack: Check each candidate posting against the tracked set (find_application_by_company confirms a specific company):
- Distinctive: line 49
Never silently drop a match.
- Very specific: line 62
No scratch artifacts in the repo: Keep intermediate data in context.
- Distinctive: line 67
Use one consistent format for every per-company file in a run.
- Distinctive: line 132
Every per-company file uses the standard template and ends in one of the three states (matches / no matches / unreachable).
- Very specific: line 135
If the user has overlapping applications, the "skipped (already in jobtrack)" count is non-zero — if it's zero, double-check the MCP dedupe …
≈ “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
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_recenttool (itsfiles.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
- Pull jobtrack state first. Call the jobtrack MCP
list_applicationsto get every company + role + status already tracked. Hold this as the dedupe set. (find_application_by_companyconfirms a specific match.) If the MCP server isn't connected, say so and proceed without dedupe rather than guessing. - Pull the resume via
get_recentso the fit ranking has something to score against. 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:
WebFetchon a direct posting URL or a LinkedIn job-search URL (e.g.linkedin.com/jobs/search/?keywords=...&location=...&f_WT=2, wheref_WT=2= remote). Server-rendered enough to read, no browser needed. Caveat: LinkedInkeywords=<CompanyName>is imprecise — it matches any posting that mentions the company (searching "Microsoft" returned an Oracle role). To pin a company, use LinkedIn'sf_C=<companyId>filter, or extract strictly by employer from the results.- A browser tool for first-party career boards (Workday / Greenhouse / Ashby / custom SPAs — e.g. Microsoft, Datadog, Amazon).
WebFetchreturns 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_textsometimes returns nav chrome (usefind/read_pagefor the results region;read_network_requeststo 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.
- 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
- 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 invalidcountry=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.
- Dedupe against jobtrack. Check each candidate posting against the tracked set (
find_application_by_companyconfirms 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.
- 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.
- 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/*.mdfiles. 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
pythonparser scripts. This is auvproject — barepythonisn'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_applicationsfirst. - ❌ 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
WebFetchand 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/*.mdgets 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.
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.

