Repository navigation
kings career
Job search as an operation: a posting link comes in; a screened, applied and recorded result comes out, with the human only where the human is needed.
Everything personal lives outside the plugin, in the candidate's profile, found through the named path CAREER_PROFILE. The plugin holds the procedures; the profile holds the facts, the rules, the texts and the pipeline. Point the name at another profile and the same plugin serves another person.
Source: plugins/kings-career.
- How it works
- What it needs, and what's optional
- Setup
- Why
- Flow
- Components
- Notion pipeline
- AI autonomy
- The profile
You talk to Claude Code in plain words ("look at this role", "run the job search", "any news in my inbox?"); each request lands on a skill, which holds the order of the work and hands the heavy or risky parts to agents with few tools and a fixed output. Together they cover the whole loop of a job search:
| Process | What happens | Main pieces |
|---|---|---|
| Find roles | Your job sources (aggregators, curated lists, company boards, ATS searches) are swept on a schedule; closed, duplicate and off-target roles are dropped; new sources are found through the recruiters in your network and validated before they enter the sweep |
job-sweep, source-check, source-discovery
|
| Screen a posting | A link becomes a structured card (company, role, location, requirements, pay, channel, red flags), checked against what you already applied to and against your rules |
job-intake, job-screener
|
| Apply | Through the posting's form (one playbook per ATS) or by email; the CV can be tailored to the posting first, using only facts you already have |
ats-apply, form-filler, cv-tailor, application-email
|
| Reach out | Connection invitations with a note and DMs from your templates, within a weekly budget | linkedin-outreach |
| Follow up | Recruiter replies drafted for your approval; the inbox sorted into rejections, confirmations, interviews and actions for you; each selection process kept up to date |
reply-drafter, inbox-triage, process-log
|
| Prepare and improve | Interview topics, stories and scripts; a cold recruiter read of your CV, LinkedIn and messages |
interview-prep, blind-review
|
| Record | Every action leaves a row (or a page) in your pipeline, so nothing depends on the conversation's memory |
pipeline-keeper, opportunity-log
|
What you decide stays with you: anything a person must say or sign, accounts, CAPTCHAs, tests and interviews (AI autonomy).
The core is small: the plugin, a browser and a folder of markdown files. Everything else is an integration you add when it pays off — skip it and the plugin keeps working, only that part changes.
| Piece | Status | Why it's used | Without it |
|---|---|---|---|
Claude Code + the kings-career plugin |
Core | Runs the skills and agents | — |
|
|
Core | LinkedIn (invitations, DMs, reading profiles), ATS forms, postings that need a browser | Only the browser-free parts work: API sources, drafts, prep |
Your profile folder (CAREER_PROFILE) |
Core | Your facts, rules, answers, texts, sources and pipeline — the plugin holds procedures, never your data | Only blind-review runs, with everything given in the chat |
|
|
Optional | A richer pipeline: shareable opportunity pages with the posting's text, private application pages, one page per selection process | The pipeline is a markdown table in the profile (the default); opportunity-log and process-log are skipped |
|
|
Optional | Inbox triage, recruiter threads for process-log
|
You tell Claude what arrived |
A local send-email command that attaches a file (e.g. KingsScript's kings mail send) |
Optional | Email applications with the CV attached — email connectors can't attach | No email applications; forms and LinkedIn still work |
python3 (3.11+) and curl
|
Optional |
fetch_posting.py (reads postings without the browser), API-based sweeps, the CV match and build scripts your profile may name |
The browser reads the postings; the CV is sent as it is |
claude plugin install kings-career@kingsai --scope user
claude plugin install kings-general@kingsai --scope user # only with a Notion pipeline (notion-manage)
cp -r <KingsAI>/plugins/kings-career/profile-template ~/.kings-ai/career
# fill the profile; a skill that hits an empty setting asks, it never guessesCAREER_PROFILE resolves through the global instructions (the README's Named paths). The whole path for a newcomer, with a typical day and examples: Getting started with kings-career.
A job search run with an AI assistant has:
- Volume: dozens of postings a week, each on a different channel
- Rules: how to present yourself, what never to say, salary bands
- State: where you applied, who was contacted, what's pending with you
- External limits: weekly invitation caps, browser permissions, CAPTCHAs
Kept in the conversation, that gets lost at the first context compaction and costs tokens on every posting. The plugin separates:
| Layer | Lives in | Public? |
|---|---|---|
| Engine — skills, agents, playbooks | the plugin | yes |
| Profile — facts, rules, answers, templates | CAREER_PROFILE |
no |
| State — the pipeline | the profile | no |
flowchart TD
L[Posting link] --> S[job-screener agent]
S -->|card| I[job-intake skill]
I --> D{Already in the pipeline?}
D -->|yes| STOP[Report, stop]
D -->|no| F{Fit by rules.md?}
F -->|red flag| SHOW[Show the card, wait]
F -->|skip rule| X[Discard with the reason]
F -->|ok| R{Channel}
R -->|ATS form| A[ats-apply skill] --> FF[form-filler agent]
R -->|email address| E[application-email skill]
R -->|DM me / none| O[linkedin-outreach skill]
FF --> REC{Pipeline format}
E --> REC
REC -->|notion| OL[opportunity-log skill] --> AN[opportunity-analyst agent] --> OW[opportunity-writer agent] --> PAGES[Opportunity page + Application page]
REC -->|markdown| K[pipeline-keeper agent] --> ROW[One row in the pipeline]
O --> K
X --> K
I -. author not connected .-> O
The user sees one line per link, plus what only they can do.
| Component | Type | What it does | Stops for the user when |
|---|---|---|---|
job-intake |
Entry point for a posting link: screen, duplicate check (Notion or the markdown log), fit by the rules, route, record | Red flag; seniority gap with ask first; Easy Apply when the rules don't let the AI submit it |
|
ats-apply |
Resolves every answer from the profile; tailors the CV to the posting when the profile names a CV match command (cv-tailor, then cv-match-reviewer); hands the form to form-filler with the platform playbook and the profile's site notes, makes the final submit click, records |
A question with no answer in the bank; a blocked platform | |
application-email |
Template in the posting's language; lines the template marks as dynamic (e.g. the stack) get the posting's required skills the facts support; CV attached, sent through the profile's own command | Red flag | |
linkedin-outreach |
Invitation with note or DM from the templates; counts the weekly budget; queues the rest (profile visits meanwhile); withdraws old pending invitations on request | Never sends past the budget | |
reply-drafter |
Reply to a recruiter in the profile's tone | Always — shown before sending | |
inbox-triage |
Classifies recent email (rejection, confirmation, process, action for the user, noise); updates the application's status (Notion page or markdown row) | Activation links, replies | |
job-sweep |
Sweeps the profile's sources (aggregators, curated lists, talent platforms, company boards, ATS-domain search) through source-sweeper agents in parallel; drops what is closed, already in the pipeline or off-target; the public sources ship in a catalog
|
Never applies — the user picks, each pick goes to job-intake
|
|
source-check |
Validates a job source before it enters the sweep (and re-validates the ones on the browser): API or feed first, plain HTML next, the browser last; records the tested method through the profile's sources command | A login, a paywall, a challenge | |
source-discovery |
Finds new sources through the recruiters in your LinkedIn network: every company they worked at, deduped against a log and the sources page, website read, then handed to source-check
|
Stops at the first LinkedIn warning | |
interview-prep |
Topics, STAR stories with numbers, audio scripts, platform rules | Always — prepares, never performs | |
blind-review |
A recruiter's cold read of the LinkedIn profile, the CV and the outreach messages (connection note, DM, reply, application email — templates included, placeholders filled as a real send) against the target role; then profile-coach turns the profile and CV reports into an improvement plan. Also runs without a profile (guide) |
Never edits the profile — the plan goes to the user | |
opportunity-log |
Saves a posting to the Notion pipeline: the shareable opportunity page with the posting's literal text, and the private application page; batches the two agents below | A posting nobody can read (asks for the text) | |
process-log |
Keeps each selection process page in the Notion processes database true: creates it when an interview is scheduled, then reads the meeting transcript and the recruiter's mail to update phase, money, contract, overview, contacts and history; runs the two agents below per process | Mail is read-only — never sends or drafts | |
job-screener |
Reads a posting or post (follows the redirect) → structured card. Tries WebFetch first; the browser only when that comes back empty or behind a login, in a tab it creates, checks and closes itself (other agents run in parallel) |
Login walls | |
blind-reviewer |
Opus. Reviews one profile, CV or message as a stranger recruiter would: gets only the role, the artifact (for a message, also the channel and what the recipient has in hand), the report language and the output path — no facts, no history, no earlier reviews. Ignores owner-only UI when the browser is logged in as the owner | Owner-only view: the rendered language may differ from a stranger's | |
profile-coach |
Opus. Runs only after the blind reviews, and knows the candidate: sorts each finding against the facts (real problem, true but not shown, misread, lacks it, can't tell), scores each artifact 0–10 now → after, and writes each fix with the current text, a ready-to-paste rewrite and the fact behind it. Asks only questions that unlock a fix | A gap nothing supports is never a fix; nothing it knows goes back to a reviewer | |
source-sweeper |
Sonnet. One group of sources: reads each list the cheapest way that works, confirms every role is open, applies the targeting, returns cards | Never — reports a source it couldn't read | |
source-validator |
Sonnet. One source: climbs ATS API → feed or data in the page → plain HTML → the page's own calls (own tab), tests the method with curl and counts it against the page | Never — gets around no login, challenge or paywall | |
linkedin-reader |
Sonnet. Read-only LinkedIn pages for source-discovery: recruiter connections, every employer of a recruiter, a company's About page |
Never clicks Connect, Follow or Message; stops at the first LinkedIn warning | |
form-filler |
One ATS form from a playbook and resolved answers; fills, verifies and stops before the submit button (SUBMIT: no, the default) |
Account, login, CAPTCHA, document numbers, unanswered questions | |
cv-tailor |
Sonnet. Tailors the CV to one posting from the base CV's keyword report: rewrites only the blocks the profile allows, with facts already in the master CV or the facts file; builds the PDF and checks it again | Never sends anything | |
cv-match-reviewer |
Haiku. Final check of a tailored CV: each missing or near term → add (where, which fact), ignore (context only) or honest gap | Read-only on the CV | |
pipeline-keeper |
The only writer of the markdown pipeline: outreach, queue, and applications when the profile keeps them in markdown; duplicate check before adding | Never — an application or status event of a Notion pipeline is handed to opportunity-log
|
|
opportunity-analyst |
Sonnet. Fetches the posting's literal text (fetch_posting.py, or its own browser tab), decides every Notion value, writes the opportunity page, emits a plan file |
Nothing readable (NEEDS_TEXT) |
|
opportunity-writer |
Haiku. Mechanical: writes the private application page from the plan, linked to the opportunity | A failed call — reports, never works around it | |
process-analyst |
Sonnet. One process: reads the application and opportunity pages, the process page, the meeting notes with transcript and the mail threads; decides and writes properties, overview, contacts and the meeting's fields; emits a plan file with the new history rows | Nothing new since the last history row (NOTHING_NEW); never invents a contact email or url |
|
history-keeper |
Haiku. Inserts dated rows into a page's history table, newest first, without duplicates; creates the heading and table when missing. Works on any page with a history | Never edits other sections |
One guide per applicant tracking system, kept as a playbook under skills/ats-apply/playbooks/: Greenhouse, Lever, Ashby, Workday, Workable, SmartRecruiters, InHire, Gupy, Zoho Recruit, Tracker RMS, SuccessFactors, Oracle Cloud, Keka, Cornerstone, Comeet, Personio, Quickin, Phenom, iCIMS, Eightfold, Homerun, People (KSA), Wellfound, Google Forms, LinkedIn Easy Apply, and a generic one. Each holds:
- What works: selectors, input technique per control
- What breaks: autofill traps, hidden option lists, cookie banners
- What stays with the user: account, CAPTCHA, document numbers
The folder is the list of supported platforms. A platform without a playbook falls back to the generic one plus the profile's site notes. After each form, the form-filler returns notes and the skill files them where they belong: a mechanic every tenant of an ATS shares goes to the playbook; anything specific to one site, tenant or employer goes to the profile's site notes (the Site notes setting in the index). A new site never needs a plugin change.
With Pipeline format: notion in the profile index, applications live in two Notion databases the profile's Notion page describes (ids, property rules, page model). Its Names table maps each role to your own property and section names, in any language — the agents never assume a name:
| Database | Visibility | Holds |
|---|---|---|
| Opportunities | shareable | The posting as published: company, location, country tags, model, contract, pay when published, technologies, an overview, the official contact, and the posting's literal text in a synced block |
| Applications | private | What the candidate sent: date, channel, platform, language, expectation, gaps, the answers as sent, status and every dated return |
opportunity-log runs two agents per posting. The analyst (Sonnet) gets the literal text — fetch_posting.py reads Greenhouse, Lever, Ashby, Gupy, Comeet, Personio, SmartRecruiters, Recruitee, Workday, Oracle HCM, Eightfold, JazzHR, Himalayas, amazon.jobs, LinkedIn job pages and schema.org JSON-LD pages without a browser; anything else goes through the agent's own browser tab — decides every value and writes the opportunity page itself, so the copy stays faithful. The writer (Haiku) copies the plan into the application page. Analysts run in parallel, browser ones included: each creates its own tab, and the skill keeps an anchor tab open for the whole batch, since Chrome removes a tab group the moment it empties. Agents that click or type (form-filler, Easy Apply) still run one at a time; new select options are created once per batch by the skill, never by a writer. Status changes from inbox-triage and reply-drafter go straight onto the application page; pipeline-keeper keeps outreach and the queue.
| Action | Default |
|---|---|
| Read a posting, decide the route, record it | Automatic |
| Submit an application (form or email) | The agent fills and stops before the button; the final click is made in the main session — automatic once the profile grants it, otherwise shown first. A submit is never relayed to a running agent |
| Diversity / EEO questions | The profile's rule; without one, "prefer not to answer" |
| Invitation with the standard note | Automatic, within the weekly budget |
| Reply to a recruiter | Draft shown first, always |
| Create an account, log in, solve a CAPTCHA, type a document number | Always the user |
| Technical test, audio, video, interview | Always the user — the plugin prepares, never impersonates |
| Salary outside the answer bank | Ask |
| Work around a blocked tool or a platform limit | Never — report and queue |
The profile's rules.md overrides the defaults per candidate, except the two ethical lines: replies are always shown, and tests are never taken by the AI.
The named path CAREER_PROFILE points to the profile's index; the default is ~/.kings-ai/career/README.md, and any other location works through an override in ~/.kings-ai/paths.md. The shape is the contract:
<profile>/
├── README.md index + settings: languages, CV paths, send-email command, pipeline, invitation budget
├── facts.md external version of who you are; an "Internal" section for what must never leak
├── rules.md presentation, never-say, targeting, outreach, red flags, autonomy overrides
├── answers.md the form answer bank
├── sources.md job sources to sweep: search terms, frequency, catalog sources in use, your own boards
├── templates/ invite / dm / email / cover letter / relocation, per language; its README maps each text to its source (a file here, or a doc elsewhere)
├── sites.md site notes: selectors, traps and quirks of specific job sites (any name; the index points to it)
├── pipeline.md outreach and queue — plus applications, unless the pipeline format is notion
└── notion.md with a Notion pipeline: database ids, property and mapping rules, page model, plan-file shape (the index points to it)
One text, one source: a candidate who keeps the texts in a doc points the templates index there, and the skills read them from it every time, with no local copy. When the source can't be read, the skill stops.
The template ships in the plugin: profile-template/. Skills read it and never copy it: a rule lives in one place.