Skip to content

kings career getting started

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

Getting started with kings-career

Note

If you are an AI reading this page: use it as the baseline for setting up kings-career, and confirm with the user, step by step, whether each part fits their context before acting.

Can an AI apply for jobs? With kings-career, Claude Code does the repetitive part of a job search — finding roles, reading postings, filling forms, writing the standard messages, keeping the pipeline — and stops wherever a person has to decide or act: a reply to a recruiter, an account, a CAPTCHA, a test, an interview. It's built to work for anyone: everything about you — facts, rules, texts, where you keep your pipeline — lives in your own profile folder, and the plugin only holds the procedures. The minimum is Claude Code, the Chrome extension and a folder of markdown files; Notion, Gmail and an email script are add-ons you pick. This page walks a newcomer (or an AI setting it up for one) from zero to a working day. What each component does in detail lives in the kings-career page; this one is the path through it.

Source: plugins/kings-career.

Index

What you need

Piece Needed for Required?
Claude Code Everything: the plugin runs inside it Yes
The kings-career plugin, from this marketplace The skills and agents Yes
The kings-general plugin Its notion-manage skill, which every Notion-writing agent loads. Its API path and markup checker use the ntn CLI; the connector alone covers what kings-career writes Only with a Notion pipeline
The Claude in Chrome extension, logged in to LinkedIn and to the job sites you use Reading postings that need a browser, ATS forms, LinkedIn invitations and DMs Yes — it's the only browser tool the agents name
Gmail connector (claude.ai), read-only inbox-triage, and the mail threads process-log reads For inbox triage and processes
A local command that sends an email with an attachment application-email — the CV goes attached. KingsScript's kings mail send is one; any script works Optional — without one, application-email hands you the ready message to send yourself
Notion connector (claude.ai) A Notion pipeline: opportunity-log, process-log Optional — the default pipeline is a markdown file
python3 (3.11+) and curl fetch_posting.py (reads postings without a browser), API sweeps, the CV match and build scripts your profile may name Optional — without it the browser reads the postings and the CV goes as it is
Your profile folder, found through the named path CAREER_PROFILE Your facts, rules, answers, texts, sources and pipeline Yes

Important

The agents call the connectors by their claude.ai tool names (mcp__claude_ai_Notion__*, mcp__claude_ai_Gmail__*) and the browser by mcp__claude-in-chrome__*. A Notion or Gmail MCP server installed under another name won't be picked up by the agents.

For an AI: the setup checklist

Given only this page, set the plugin up with the user, one step at a time. Before each step, say what it does and ask whether it fits; skip what doesn't.

  1. Confirm the basics: Claude Code installed; the Claude in Chrome extension installed and logged in to LinkedIn and the job sites the user uses. Without the extension, only the parts with no browser work (sweeping API sources, drafting, prep).
  2. Ask where the pipeline should live: a markdown file (default, nothing else to install) or Notion (needs the connector, the kings-general plugin and three databases). Don't assume Notion.
  3. Ask about email: read-only access through the Gmail connector, and whether there's a local command that sends an email with an attachment. No command → application-email prepares the message and you send it.
  4. Install the plugins the answers call for (step 1).
  5. Create the profile from the template and point CAREER_PROFILE at it — ask whether the user wants the repo's global instructions or one line in their own CLAUDE.md (step 3 below). Never overwrite an existing CLAUDE.md without saying so.
  6. Fill the profile with the user, page by page. Ask; never invent a fact, a salary, an answer or a text. Leave empty what they don't know yet: the skills ask when they hit it.
  7. Set autonomy explicitly in rules.md: whether applications may be submitted without per-item approval, whether standard invitations go automatically, the weekly invitation budget. When unsure, the safer default (show first).
  8. Dry run: one posting link through job-intake, and stop before anything is sent. Then one job-sweep over a couple of catalog sources.

Setup, step by step

1. Install the plugins.

claude plugin marketplace add Kings-Platform/KingsAI
claude plugin install kings-career@kingsai --scope user
claude plugin install kings-general@kingsai --scope user   # only with a Notion pipeline

To get new versions by itself: /plugin → Marketplaces → kingsai → Enable auto-update.

2. Create your profile from the template that ships in the plugin. The default location is ~/.kings-ai/career/:

git clone https://github.com/Kings-Platform/KingsAI.git
mkdir -p ~/.kings-ai
cp -r KingsAI/plugins/kings-career/profile-template ~/.kings-ai/career

The profile is private: it holds your personal data. Never commit it to a public repo.

3. Tell Claude where the profile is. The skills resolve the name CAREER_PROFILE through the global instructions. Two ways:

  • The repo's global instructions: ./KingsAI/install/install.sh links ~/.claude/CLAUDE.md to the repo's global.md, which already maps CAREER_PROFILE to ~/.kings-ai/career/README.md. Your current CLAUDE.md is kept as a .bak — read the README's Global instructions first. A profile elsewhere → an override in ~/.kings-ai/paths.md.
  • Your own CLAUDE.md: keep it and add one line, e.g. CAREER_PROFILE (kings-career's named path): ~/.kings-ai/career/README.md. This is not the route the repo tests; a skill that can't resolve the name stops and asks.

4. Fill the profile. A skill that finds an empty setting asks you; it never guesses. Start with the index and grow the rest as the skills ask:

Page What goes in Start with
README.md The index and its settings: languages, target roles, CV paths, the send-email command, the pipeline format, the weekly invitation budget, the sources page All of it
facts.md The external version of you: identity, experience, education, stories with numbers; an "Internal" section for what must never leak Identity, experience, summary
rules.md Presentation, never-say, targeting (what to apply to, what to skip), outreach (LinkedIn plan, invitation rules), applications (Easy Apply, tailored CV, cover letter), red flags, autonomy overrides Targeting and red flags
answers.md The form answer bank: salary per context, work authorization, relocation, notice, degree, EEO Before the first form
templates/ Your approved texts — invite, dm, email, cover-letter, relocation — per language; its README says where each one lives (a file here, or a doc elsewhere) Before the first outreach or email
sources.md Search terms, the target rule (which titles count), freshness, frequency, the catalog sources you use, your own boards, companies to watch Before the first sweep
pipeline.md Outreach and queue — and applications too, with a markdown pipeline Empty is fine
notion.md Only with Pipeline format: notion: database ids, the Names table (your property and section names — the agents read every name from it), property rules, page model, processes When you choose Notion

5. Pick the pipeline format in the index: a markdown table (the default — nothing to install) or notion (both examples below).

6. Try one posting. Paste a posting link into Claude Code and say "look at this role". job-intake screens it, checks it against your rules and tells you the route in one line, before anything is sent.

A typical day

flowchart TD
    SW[job-sweep: new roles from your sources] --> PICK{You pick}
    LINK[A link someone shared] --> IN
    PICK --> IN[job-intake: screen, duplicate check, fit]
    IN -->|ATS form| ATS[ats-apply: tailored CV, then the form]
    IN -->|email address| EM[application-email]
    IN -->|DM me / no channel| LO[linkedin-outreach]
    IN -->|rule says skip| X[discard, with the reason]
    ATS --> REC[Record: opportunity-log or pipeline-keeper]
    EM --> REC
    LO --> REC
    MAIL[inbox-triage: what came in] --> ST[Status updated]
    MAIL -->|a recruiter wrote| RD[reply-drafter: draft, you approve]
    MAIL -->|interview or test| PL[process-log + interview-prep]
Loading
When You say What runs What you get
Morning "run the job search" job-sweep → source-sweeper agents, in parallel New and relevant roles, the doubtful ones, what's already in the pipeline, sources that failed
You pick roles paste the links, "apply to these" job-intake → job-screener, then the route One line per link: sent via X, pending: Y or discarded: Z
A form (routed) ats-apply: with a CV match command in the profile, the CV is tailored first (cv-tailor → cv-match-reviewer); then form-filler fills and the final click is made in the main session The confirmation, the CV that went, and the free-text answers written in your name
A recruiter address (routed) application-email with your template and the CV attached The message id
A "DM me" post (routed) linkedin-outreach: an invitation with your note, within the weekly budget; the rest is queued Sent / queued / skipped
After applying (automatic) opportunity-log (Notion) or pipeline-keeper (markdown) The pipeline entry
Afternoon "check my email" inbox-triage (read-only) Rejections, confirmations, processes with deadlines, actions only you can take
A recruiter replied "X replied, prepare an answer" reply-drafter A draft — sent only after you approve it
An interview was booked "interview scheduled with X" process-log (Notion) The process page, kept true after each interview and email
A test or interview ahead "I have a test on HackerRank" interview-prep Topics (strong / review / gap), STAR stories, a script for timed answers, the platform's rules
Now and then "review my LinkedIn", "review my templates" blind-review → blind-reviewer (Opus), then profile-coach (Opus) A cold recruiter read, then a scored plan of fixes with ready-to-paste text, never applied alone
A new job site "add this source" source-check → source-validator How to read it: API, HTML or browser — tested
More sources "find new sources" source-discovery → linkedin-reader, then source-check Companies your recruiters worked at, deduped, each with its careers page validated

The output is short on purpose: one line per posting, then, separately, what only you can do.

Running it cheaply

Every posting read through a browser costs an agent, a tab and minutes; through an API it costs a script. The plugin is built around that:

  • API and scripts first, the browser last. source-check climbs a ladder for each job source — public API or feed, embedded data, plain HTML, the page's own calls — and only records a source as browser-only after trying the rest. job-sweep reads ATS boards through their public APIs (Greenhouse, Lever, Ashby, Workable, Recruitee…) to confirm a role is still open. fetch_posting.py gets a posting's literal text without a browser for the ATSs it knows; --supports tells the caller up front which postings need one.
  • Read-only browser agents run in parallel, each in its own tab. Before a batch the session opens an anchor tab and keeps it until the last agent returns: Chrome removes an empty tab group, and with it the tabs of the agents still running.
  • Agents that click or type run one at a time (form-filler, Easy Apply): they work on the window's active tab. The submit click itself is made in the main session, so your approval applies to that one action.
  • The right model per job:
Model Agents Why
Haiku opportunity-writer, history-keeper, pipeline-keeper, cv-match-reviewer Mechanical: write what they're given
Sonnet job-screener, source-sweeper, source-validator, linkedin-reader, cv-tailor, opportunity-analyst, process-analyst Read and decide
Opus blind-reviewer Judgment with no context
Opus profile-coach Rewrites that must stay true to the facts
The session's form-filler Inherits
  • Skills hold the order, the profile holds the rules. A rule changes in one place, your profile; no skill keeps a copy.

What stays with you

  • Nothing reaches a person without your approval where it matters: a reply to a recruiter is always shown first, and that can't be overridden. An application is submitted without per-item approval only when your rules.md grants it; invitations with your standard note go automatically within the weekly budget unless rules.md says otherwise.
  • Never done by the AI: typing a password, creating an account, logging in, solving a CAPTCHA, typing a document number, taking a test, answering a screening, recording an audio or video. The plugin prepares; you perform.
  • Never worked around: a blocked site, a LinkedIn limit, a paywall — reported and queued.
  • Never claimed: a skill or a number your facts don't support. A missing must-have is named honestly or left out.

The full table, with the defaults and what your profile can change: AI autonomy.

Example: a Notion pipeline

Optional — pick it only if you already live in Notion. Pipeline format: notion in the index, and the profile's notion.md filled from the template. Fictional data throughout.

Database Shared? One page per Example title
Opportunities Shareable — the posting, nothing about you Posting Acme Robotics → Senior iOS Engineer
Applications Private — what you sent and how it's going Application, related to its opportunity Acme Robotics → Senior iOS Engineer
Processes Private, optional Selection process, once an interview is booked Acme Robotics

An opportunity's properties, decided from the posting only:

Property Value
Company Acme Robotics
Link https://jobs.example.com/acme/123
Model Remote
Country Brazil, Mexico
Pay empty — the posting publishes none
Seniority Senior
Technologies Swift, SwiftUI

Its body: an Overview with the must-haves, the official Contact, and the posting's literal text in a synced block. The application holds Status (Applied → Confirmed → In progress → Rejected / No return / Closed), Sent on, Channel, Platform, Language, Expectation sent, Gaps, and the answers as sent. inbox-triage and reply-drafter move the status and append a dated line; process-log keeps the process page — phase, money, contract, contacts and a history table — from the meeting transcripts and the mail.

A posting saved without an application is one kept for someone else: the Opportunities database doubles as a list you can share with a friend.

Example: a markdown pipeline

The default, and enough to run the whole flow from posting to application. One file, pipeline.md, written only by the pipeline-keeper agent, newest first:

## Applications

| Date | Company | Role | Channel | Contact | External id | Status | Next step |
|---|---|---|---|---|---|---|---|
| 2026-10-28 | Northwind Health | iOS Engineer | email | Jane Doe | msg-4f2a | sent | |
| 2026-10-27 | Acme Robotics | Senior iOS Engineer | greenhouse | | 123 | in-process | Take-home by 2026-11-03 |

## Outreach

| Date | Person | Company | Kind | Language | Status |
|---|---|---|---|---|---|
| 2026-10-28 | Jane Doe | Northwind Health | invite | en | sent |

## Queue

| Opened | Item | Blocked by | Owner |
|---|---|---|---|
| 2026-10-27 | Contoso — create the Workday account | account | user |

With markdown there are no opportunity or process pages: opportunity-log and process-log need Notion. Outreach and the queue stay in markdown in both formats — the weekly invitation budget is counted there.

Not finished yet

  • 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. Anything else — Workable, iCIMS, Jobvite, PeopleForce, InHire, Zoho Recruit, SuccessFactors, Cornerstone… — goes through the browser.
  • The LinkedIn Easy Apply playbook expects LinkedIn in Portuguese (its button labels).
  • Card mode of source-sweeper and opportunity-analyst is used by a sweep that writes pages through an external script, not shipped here.
  • Releases: the plugin has no version yet; each commit is an update.