Skip to content
Back to search

send-me-a-job

SkillWorks with Claude CodeGitHub

Turn job links into tailored CVs and cover letters. Claude skill + standalone CLI (Anthropic API key only).

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/sultansxr--send-me-a-job/badge.svg)](/listings/sultansxr--send-me-a-job)

HTML

<a href="/listings/sultansxr--send-me-a-job"><img src="/api/listings/sultansxr--send-me-a-job/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 183 lines
  1. # Send me a job
  2. Turn job links into tailored application packs. For each link it reads the advert, checks the role suits you and doesn't rule out your work rights, then writes a CV and cover letter (.docx, A4) using **only facts from your own profile**. It keeps a tracked list of every job.
  3. It also estimates, privately, **your chance of getting each job**. The research covers the advert, the employer's hiring history, the market, published patterns of who got the job before, and visa sponsorship. It then **suggests the open roles where your chances are best** and tells you **what to change in your profile to raise them**.
  4. You can use it in three ways:
  5. | | In the Claude app | Hands-off on your computer | Standalone (no Claude login) |
  6. |---|---|---|---|
  7. | What you need | Claude (web, desktop or mobile) with skills | Claude **desktop app**, open on a computer that stays awake | Node 18+ and an Anthropic API key |
  8. | Builds CV + cover letter | Yes | Yes | Yes |
  9. | Fills in application forms | Yes, in the desktop app's built-in browser while you watch | Yes, while you're away | No (you submit yourself) |
  10. | When it needs you | Asks in the chat | **Sends a notification**; you answer or approve from the Claude app on any device | — |
  11. | Submits | Only after your yes | Only after you reply "submit <company>" | Never |
  12. Your personal details never go in this repository. `profile.json`, `config.json`, `data/` and `out/` are git-ignored and stay on your computer. All three ways share the same data folder, so you can build packs with the command-line tool and apply with the Claude app.
  13. ---
  14. ## 1. Use it in the Claude app
  15. 1. Download **[`dist/send-me-a-job-skill.zip`](dist/send-me-a-job-skill.zip)**, or build it yourself with `npm run package-skill`.
  16. 2. In Claude, open **Settings → Capabilities → Skills**, choose **Upload skill** and pick the zip. In Claude Code, unzip it into `~/.claude/skills/` instead.
  17. 3. In the **Claude desktop app**, open a chat and click **+ → Add folder** to connect a folder for your job hunt (e.g. `~/job-hunt`). Your profile, job list and documents live there.
  18. 4. Say: *"Set up send-me-a-job. Here's my CV."* Claude builds your `profile.json` with you, asking for your target country, your work-rights sentence and the job tracks you want.
  19. 5. Paste a link: *"Build my application pack for this job: https://…"*
  20. 6. To apply while you watch: *"Apply to my ready jobs."* Claude opens each application in the app's **built-in browser**, fills it in from your profile and pack, shows you everything, and clicks Submit only after your yes.
  21. The skill also works in Claude on the web or mobile for building packs. Filling in forms needs the desktop app, or Claude in Chrome.
  22. Skill contents (`skill/send-me-a-job/`):
  23. ```
  24. SKILL.md workflow: profile → collect links → build packs → apply
  25. scripts/make_docs.js renders the CV and cover letter (.docx) from a spec
  26. templates/profile.example.json
  27. templates/spec.example.json
  28. references/apply.md filling in employer forms safely (live)
  29. references/hands-off.md applying while you're away, with notifications
  30. references/automation.md scheduled pack-building and the public link form
  31. ```
  32. ## 2. Hands-off: let it apply while you're away
  33. Start it, leave your computer, and approve from your phone.
  34. **One-time setup** (Claude walks you through it when you say *"Set up hands-off applying"*):
  35. 1. **Keep the Claude desktop app open and signed in** on your computer, with your job-hunt folder connected.
  36. 2. **Sign in once to your job sites in the built-in browser** (open it with Cmd/Ctrl+Shift+B): LinkedIn, plus any application portals such as Workday, Greenhouse or cvMail. Sign-ins are remembered, and Claude never types your passwords.
  37. 3. **Keep the computer awake and plugged in.** The screen may turn off, but the computer must not sleep.
  38. - macOS: run `caffeinate -dimsu` in Terminal, or turn on System Settings → Battery → Options → "Prevent automatic sleeping on power adapter when the display is off".
  39. - Windows: Settings → System → Power → "When plugged in, put my device to sleep after: Never".
  40. 4. **Turn on notifications** for the Claude app on your phone.
  41. 5. Claude creates a scheduled task, **"Send me a job: hands-off apply"**, that runs on your computer (e.g. every 2 hours).
  42. **Day to day:**
  43. - Queue the jobs you want to apply to. Say *"apply to these while I'm away"*, click **Queue for applying** in the local portal, or run `send-me-a-job mark <id> queued`.
  44. - Each run opens every queued application in the built-in browser, fills it in and **stops before Submit**.
  45. - When it needs you, you get a notification, for example *"Acme – Analyst is filled in. Reply 'submit Acme' to send it."* or *"Acme needs 2 answers: notice period, salary."* Tap it and reply in that conversation from anywhere. Claude then submits, or carries on with your answers.
  46. - Things only you can do (signing in, CAPTCHAs, creating accounts, paying fees) are flagged to you and never done for you.
  47. ## 3. Run it without Claude (command-line tool + local portal)
  48. ```bash
  49. git clone https://github.com/<you>/send-me-a-job.git
  50. cd send-me-a-job
  51. npm install
  52. npm link # puts `send-me-a-job` on your PATH (optional)
  53. mkdir ~/job-hunt && cd ~/job-hunt # your private data folder
  54. send-me-a-job init # creates config.json and profile.json
  55. # edit profile.json: replace the example person with your own details
  56. export ANTHROPIC_API_KEY=sk-ant-... # from console.anthropic.com
  57. send-me-a-job add https://careers.example.com/jobs/123 --track business
  58. send-me-a-job run # builds packs for every new job
  59. send-me-a-job list
  60. ```
  61. Each pack goes into `out/<job id>/` and contains `<Name>_<Company>_<Role>_CV.docx`, `…_Cover_Letter.docx` and `pack.md`. `pack.md` lists the role, closing date, apply link, why it fits, visa sponsorship, gaps and suggested screening answers.
  62. **Local portal:** `send-me-a-job serve` opens a page at `http://127.0.0.1:4321`. There you can paste links, click **Apply** (choose **Apply now** to build the pack and queue it straight away, or **Add to the queue** for the next scheduled run), build packs, download the documents, queue jobs for hands-off applying and mark them as applied. It also shows which jobs are waiting for your answers or approval. It listens only on your own computer.
  63. **Run on a schedule:** add a cron job (or a Windows Task Scheduler task). This runs twice a day; every new job is built (set `maxJobsPerRun` in `config.json` to cap it):
  64. ```
  65. 35 10,18 * * * cd ~/job-hunt && ANTHROPIC_API_KEY=sk-ant-... /usr/local/bin/send-me-a-job run >> run.log 2>&1
  66. ```
  67. **Adverts that need a sign-in** (e.g. LinkedIn): copy the advert text into a file, then run `send-me-a-job add <url> --text advert.txt`.
  68. ### All commands
  69. | Command | What it does |
  70. |---|---|
  71. | `init` | Create `config.json` and `profile.json` in the current folder |
  72. | `add <url> [--track legal\|business] [--note …] [--text file]` | Add a job link (duplicates are ignored) |
  73. | `pull` | Import links from your Netlify form (needs `NETLIFY_TOKEN` and `netlify.formId`) |
  74. | `build [id …]` | Build packs for new jobs, or for the ids given |
  75. | `run [--suggest]` | `pull` (if configured), `build`, `score` (and `suggest`). Use this from cron |
  76. | `list [--status ready]` | Show jobs and their status |
  77. | `mark <id> <status>` | Set a status: `new`, `ready`, `queued` (for hands-off applying), `applied`, `skipped`, … |
  78. | `score [id …]` | Estimate your chance of an offer for open jobs (private) |
  79. | `suggest [--count 5]` | Find open roles where your chances are best, ranked |
  80. | `advice` | Profile changes that would raise your chances |
  81. | `render <spec.json> [dir]` | Render a CV and letter from a spec, with no API call |
  82. | `serve [--port 4321]` | Local web portal |
  83. | `package-skill` | Build `dist/send-me-a-job-skill.zip` |
  84. Environment variables: `ANTHROPIC_API_KEY` (required to build), `ANTHROPIC_MODEL` (optional, default `claude-sonnet-5-5`), `ANTHROPIC_BASE_URL` (optional), `NETLIFY_TOKEN` (optional).
  85. ## Your chances, best-chance suggestions and advice
  86. Every job you haven't applied to gets a private estimate, for example **"3% (likely 1–5%), low confidence"**. Expand it to see five scored factors with sources:
  87. - **Skills match**: how you compare with the advert's requirements.
  88. - **Hiring history**: places per year, applicants per place, and sponsorship record.
  89. - **Market & competition**: how many people are applying now.
  90. - **Past hires like you**: published, anonymous patterns only. It never looks up named individuals.
  91. - **Visa sponsorship**.
  92. The numbers are deliberately honest. Graduate schemes often take about 1 in 100 applicants, so low figures are normal. The value is in comparing jobs and seeing what moves your chances.
  93. | Command | What it does |
  94. |---|---|
  95. | `send-me-a-job score` | Estimates jobs without a recent estimate. `build` also scores each new pack (`scoreOnBuild`). |
  96. | `send-me-a-job suggest` | Researches open roles where your chances are best, adds those at or above `minSuggestChance` (default 2%) ranked highest first, and retires weaker suggestions |
  97. | `send-me-a-job advice` | Turns the estimates into up to 8 concrete changes to your CV, LinkedIn or targeting. It never suggests claiming anything untrue. |
  98. The local portal shows suggestions ranked by chance, an "Add to my jobs" button, and a "How to raise your chances" box. All of it stays on your computer: nothing about your chances is ever shown on the public form. In the Claude app, ask *"what are my chances for these jobs?"*, *"suggest jobs I'm likely to get"* or *"how can I improve my chances?"*.
  99. These steps use Anthropic's web search tool through your API key, so each estimate costs a few searches. `researchSearches` and `suggestSearches` in `config.json` cap them.
  100. ## 4. Let friends send you jobs (optional)
  101. `public-form/` is a static page with a Netlify form. Friends paste a link and choose *Legal* or *Non-legal*. No sign-in is needed.
  102. 1. Set `OWNER` (your first name) at the top of the `<script>` in `public-form/index.html`. You can also set `FEED`, a published Google Sheet of suggested roles, or leave it empty.
  103. 2. Deploy the folder to Netlify: drag it onto app.netlify.com/drop, or run `netlify deploy --prod --dir public-form`.
  104. 3. Copy the form id from the Netlify dashboard into `config.json` → `netlify.formId`, and set `NETLIFY_TOKEN`. `send-me-a-job run` then imports new submissions every time it runs.
  105. ## How it works
  106. ```
  107. links ─┬─ CLI `add` / local portal
  108. ├─ public form (Netlify) ── `pull`
  109. └─ Claude chat (skill)
  110. │
  111. ▼
  112. data/jobs.json (new → preparing → ready → queued → awaiting-approval → applied; or skipped / needs-info)
  113. │
  114. build: fetch advert → Claude tailors a spec from profile.json + advert
  115. │ (skips closed roles, missing qualifications,
  116. │ sponsorship refusals when you need sponsorship)
  117. ▼
  118. make_docs.js → CV.docx + Cover_Letter.docx + pack.md in out/<id>/
  119. │
  120. apply (Claude desktop app, built-in browser): fill form → stop before Submit
  121. → notify you → submit only after "submit <company>"
  122. ```
  123. Code map:
  124. - `cli/index.js`: command parsing and every command.
  125. - `cli/lib.js`: config, the job store (`data/jobs.json`), advert fetching (`fetchAdvert`), tailoring with the Anthropic Messages API (`tailor`), building packs (`buildJob`), chance estimates with web search (`scoreJob`, `scoreOpen`), best-chance suggestions (`suggest`), profile advice (`makeAdvice`) and Netlify import (`pullNetlify`).
  126. - `cli/portal.js`: the local web portal and its small JSON API.
  127. - `cli/test.js`: an end-to-end test against a mock API (`npm test`, needs no key).
  128. - `skill/send-me-a-job/scripts/make_docs.js`: the `.docx` renderer, shared by the skill and the CLI.
  129. - `public-form/`: the static Netlify form for friends.
  130. ## Ground rules built in
  131. - Only facts from `profile.json` are used. It never invents numbers, dates, grades or qualifications, and anything in `notForCV` stays out.
  132. - Your work-rights sentence (e.g. *"I will require visa sponsorship to work in the UK."*) is used word for word. If you need sponsorship, roles that refuse it are skipped.
  133. - Advert and form text is treated as data, never as instructions.
  134. - Nothing is submitted, emailed or paid for automatically. The skill asks for your yes before every submit, including in hands-off mode. The CLI never submits at all.
  135. - Claude never types your passwords, creates accounts, solves CAPTCHAs or pays fees. Those are flagged to you.
  136. ## License
  137. MIT. See [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.