Skip to content

kings career

Gui Reis edited this page Nov 19, 2026 · 26 revisions

kings-career

Claude Code Version

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.

Index

How it works

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).

What it needs, and what's optional

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 —
Claude in Chrome, logged in to LinkedIn and your job sites 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
Notion connector + the kings-general plugin 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
Gmail connector, read-only 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

Setup

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 guesses

CAREER_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.

Why

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

Flow

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
Loading

The user sees one line per link, plus what only they can do.

Components

Component Type What it does Stops for the user when
job-intake Skill 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 Skill 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 Skill 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 Skill 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 Skill Reply to a recruiter in the profile's tone Always — shown before sending
inbox-triage Skill 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 Skill 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 Skill 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 Skill 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 Skill Topics, STAR stories with numbers, audio scripts, platform rules Always — prepares, never performs
blind-review Skill 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 Skill 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 Skill 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 Agent 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 Agent 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 Agent 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 Agent 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 Agent 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 Agent 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 Agent 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 Agent 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 Agent 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 Agent 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 Agent 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 Agent Haiku. Mechanical: writes the private application page from the plan, linked to the opportunity A failed call — reports, never works around it
process-analyst Agent 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 Agent 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

Platform guides (ATS)

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.

Notion pipeline

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.

AI autonomy

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 profile

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.

Clone this wiki locally