Portfolio-first job search kit: a 7-skill scoring chain (resume, LinkedIn, GitHub, portfolio, two scores (machine and human read) with a resume gate, improvement plan, resume rebuilder), 7 agents, 4 commands, stdlib-only scripts.

GitHub stars
67

Install

/plugin install ai-era-job-kit@ai-era-job-kit

Run it inside Claude Code after adding the marketplace with /plugin marketplace add Vets-Who-Code/ai-era-job-kit.

Contents

Discovered from source

Skills 7

Composite scorer: two scores and a gate (step 5 of 7)

$KIT is two folders up from this skill's base directory.

Run it

python3 $KIT/scripts/scorecard.py composite --resume resume-score.json --linkedin linkedin-score.json --github github-score.json --portfolio portfolio-score.json --sync sync.md [--screen screen.json ...] --json composite.json --md composite.md

The two reads

ReadWhoResumeLinkedInGitHubPortfolioWhy
MachineATS and AI screeners40351510They read text literally: titles, keywords, dates, structure, match to the posting. They can't judge a running app or a design.
HumanRecruiter, hiring manager, engineers20153035People skim for proof: a live demo, real impact, a clear story, recent commits.

Resume gate (default 70): a resume that scores under 70 on its own text (text_score, before GitHub or LinkedIn back anything), or that fails the parse gate, is flagged whatever either total says. A weak resume means no human ever sees the GitHub or the portfolio.

Screen Grades: pass each posting's screen.json (screen_grade.py grade --out) with --screen. They're the one score modeled on vendor documents and they're per posting, so they're reported beside the two reads with no weight. A C or D is flagged.

  • These weights and the gate are a VWC design judgment (Nov 6 2026), not research and not any employer's. Say so when you report them. Change them with --machine-weights resume=40,linkedin=35,github=15,portfolio=10, --human-weights portfolio=35,github=30,resume=20,linkedin=15 and --gate 70.
  • The LinkedIn and GitHub share of the machine read rests on a chat-only claim ($KIT/references/ats-research.md): no vendor documents which systems score them. The report says so; say it too.
  • A portfolio score without the checklist pass is automated checks only. The report says so; run step 4's --checklist before leaning on the human read.
  • A surface not run is left out of both reads and the rest are reweighted; the report marks the scores partial.
  • The sync check sits beside the scores, not inside them.
  • Before either read, the resume is rescored with the GitHub and LinkedIn skill_evidence: a skill is proven only when a resume bullet with a number names it and recent GitHub work or LinkedIn shows it. So the resume score here can be higher than step 1's.

Report

Lead with the gate: passed or flagged, and why. Then the machine read and the human read, and the one surface with the most points left. Then go to step 6 (improvement-plan).

GitHub scorer (step 3 of 7)

$KIT is two folders up from this skill's base directory. GitHub is how you show you exist: it should say what the portfolio says, in code. Rankers read it alongside the resume ($KIT/references/ats-research.md).

Run it

python3 $KIT/scripts/github_score.py --user <handle> --repos <pinned,repos> --market resume-score.json --portfolio <repo>/portfolio.json --json github-score.json --md github-score.md

  • Pass the pinned repos: the REST API doesn't list pins, so without --repos it reads the six most recently pushed and says so.
  • No token, no account: 60 requests an hour per IP address (a shared network shares it), about 20 a run. If GitHub can't be reached it stops (exit 3); say so. On a rate-limit stop, wait an hour or export GITHUB_TOKEN=$(gh auth token) and rerun.
  • Report the score and the top six fixes. The weights are a VWC rubric; GitHub publishes no hiring score.
  • The JSON also carries skill_evidence: each lane skill a pinned repo pushed in the last year shows. AI screeners score activity against the posting (Jerome, Nov 8 2026), so step 1 and the composite use it: a resume skill is proven only when GitHub or LinkedIn backs it.

What good looks like (the fixes point here)

  • Pins: only manicured repos, fully built and working, each with a live demo (or a video demo when cost or security rules one out). Unpin tutorials, unfinished work and unchanged forks. There's no fixed number.
  • Profile README (<handle>/<handle>), from $KIT/templates/github-profile-readme.md: one line on what they build, three artifacts with outcomes and live links, links to portfolio and LinkedIn. Skip vanity stat cards.
  • Repo READMEs, in order: the problem, why it matters, how it works (diagram, key decisions, tests, CI, evals), live link, how to run it, what's next. Every claim links to the code that implements it.
  • Hygiene: description, website, topics, license, CI workflow. If a secret was ever committed, rotate it first.

Jerome's playbook

Skill-Proof Matrix: production > shipped project > significant contribution > deployed personal project > course or cert (weak alone) > tutorial. "Don't claim what you can't prove."

Never

Never fabricate contributions or activity. Give them the files and the fix list; they commit and push.

Improvement plan (step 6 of 7)

$KIT is two folders up from this skill's base directory.

Run it

python3 $KIT/scripts/scorecard.py plan --composite composite.json --md plan.md

A flagged resume gate goes first, whatever the other gaps, because a weak resume means no human sees the rest. Then surfaces are ranked by points left (weight x the gap to 100), averaged over the machine read and the human read. Each lists its failed checks, highest weight first, with the fix the scorer wrote.

Turn it into work (portfolio first, always)

  1. Fix at the source. A missing skill, number or project goes into portfolio.json and brag/entries first. Then the surfaces are regenerated from it.
  2. Resume: prove the top lift skills in Experience or Projects bullets with numbers. Step 7 (resume-rebuilder) does the rebuild.
  3. LinkedIn: rewrite the fields the plan names (headline, skills, About, Featured, Experience), matching the record. See linkedin-scorer.
  4. GitHub: pins, profile README, repo READMEs, hygiene. See github-scorer.
  5. Portfolio: artifact pages, live links, the checklist sections that failed. See portfolio-scorer.
  6. Sync: clear every mismatch so all four surfaces tell one story. Give them the exact text or files to change. They publish and push.

Rules

Never invent a number or a skill to close a gap. A skill they can't prove becomes something to build, not something to claim.

LinkedIn scorer (step 2 of 7)

$KIT is two folders up from this skill's base directory. This skill never logs in to LinkedIn or scrapes it.

Why LinkedIn is scored

  • Recruiters search with filters (skills, job title, location, open to work) and LinkedIn standardizes titles and skills [vendor: LinkedIn, see $KIT/references/sources.md]. Each field is a filter you match or miss.
  • LinkedIn is for evidence, not applying. Recruiters compare it to the resume, and a mismatch is a red flag [Jerome, Feb 3 2026]. Rankers read it alongside the resume ($KIT/references/ats-research.md).
  • It mirrors the portfolio record. If something isn't in portfolio.json, add it there first.
  • The JSON carries skill_evidence: lane skills shown in Experience, Projects or Featured (not the Skills list). Step 1 and the composite use it to confirm a resume skill as proven.

Run it

  1. Paste the profile into a copy of $KIT/templates/linkedin-profile.txt (or save the profile as PDF from LinkedIn: More, then Save to PDF; needs pdftotext). The PDF leaves out Featured and Open to Work and lists only the top skills, so those three checks are skipped and the report says so. For a full score, use the pasted template.
  2. python3 $KIT/scripts/linkedin_score.py --profile linkedin.txt --market resume-score.json --portfolio <repo>/portfolio.json --resume <file> --json linkedin-score.json --md linkedin-score.md (No step 1 file? --onet <code> pulls O*NET live.)
  3. Report the score and the top five fixes, highest weight first. The weights are a VWC rubric; LinkedIn publishes no ranking.

What good looks like (the fixes point here)

FieldRule
HeadlineTarget role + stack + one differentiator, in the posting's words
LocationThe metro you're targeting, same as the resume
Open to WorkThe exact titles you apply to (recruiters only, if employed)
SkillsOnly skills a portfolio artifact proves, named the market's way
FeaturedFlagship case study, the live app, one piece of writing
AboutThree first-person paragraphs: what you build and for whom; proof with numbers; what you want next
ExperienceThe resume's strongest bullets, same titles, orgs and dates

Jerome's playbook

  • Apply elsewhere, follow up here: apply on the company's site, then follow up through a LinkedIn connection.
  • Post evidence, not branding: each artifact becomes a few posts (the problem, a decision, a bug and fix, a result). Draft them; they publish.

Never

Never invent metrics, endorsements or experience, and never post for them.

Portfolio scorer (step 4 of 7)

$KIT is two folders up from this skill's base directory. The portfolio is the base of the whole job search and the single source of truth: every resume line, LinkedIn field and GitHub pin points back to it.

Run it

  1. Automated pass (leave --github off in the chain; step 3 scores GitHub): python3 $KIT/scripts/portfolio_audit.py --url <site> --portfolio <repo>/portfolio.json --json portfolio-score.json It reads the home page and up to five project pages as raw HTML, checks each deployed artifact in portfolio.json is on the site, and loads each live link. If the site is drawn by JavaScript it says so and leaves out the checks it couldn't make; cover those in the judgment pass.
  2. Judgment pass: open the Vets Who Code Portfolio Checklist (https://vetswhocode.io/portfolio-checklist) and read each section's items on the page itself, not from memory. "The portfolio is a sales site." "You have 8 seconds." Write each item you checked to checklist.json as {"section", "item", "pass": true|false, "quote": "<what you saw on the page>"}, then rerun the script with --checklist checklist.json so the judgment is in the score. Every item needs a quote, pass or miss; the script refuses one without.
  3. Signal match: python3 $KIT/scripts/sync_check.py --portfolio <repo>/portfolio.json --resume <file> --linkedin <file> --github <handle> --md sync.md. Step 5 reports it beside the score.
  4. Report the automated score, each checklist section as passed out of checked (quote what you saw for each miss), and the top five fixes, highest leverage first. Don't call it ready until it clears the checklist's Quality Bar.

Jerome's playbook

  • Grade each claimed skill by its best evidence (Skill-Proof Matrix).
  • Ship before you certify.
  • Artifacts teams want now: spec work, test harnesses, LLM evals, and the "why" written into issues and pull requests.
  • The Brag Database lives in the portfolio (brag/entries); Friday Setup feeds it.

Tone and rules

Lead with what works, then the fixes. Quote what you saw; never guess at pages you couldn't load. For a hiring-manager read that isn't anchored on yours, use the dev-team-reviewer agent.

Resume rebuilder (step 7 of 7)

$KIT is two folders up from this skill's base directory. The portfolio is the source of truth: portfolio.json plus the curated Brag Database in brag/entries/. The resume is a projection of it, one targeted version per kind of role. Most people need one or two.

Run it

  1. Draft from the record: python3 $KIT/scripts/resume_rebuild.py --portfolio <repo>/portfolio.json --brag <repo>/brag/entries --market resume-score.json [--role "<title>"] --out ~/resumes/<name>-<role>-resume.txt --md rebuild.md Bullets that prove high-lift skills go first. Missing facts come out as [ask: ...]. Lane skills with no evidence in the portfolio are listed as "prove it first" and never added.
  2. Fill every [ask: ...] with them, one at a time. Never guess a number.
  3. Tighten each bullet: strong verb, what they built or changed, the skill named exactly as the market names it, and a number. A bullet with a number that names the skill is proven (1.0) once a pinned repo pushed in the last year or LinkedIn Experience shows the same skill; otherwise it's applied (0.7). A Skills-list mention is listed (0.4).
  4. Lint against the spec: python3 $KIT/scripts/resume_rebuild.py --check <file> (works on .pdf, .docx, .txt).
  5. Defend every line (below). Cut anything they can't defend.
  6. Rescore: resume_score.py for the lane and screen_grade.py for the posting, before and after. Then sync_check.py so the resume agrees with the portfolio, LinkedIn and GitHub. If a resume line isn't in the portfolio, add it there first or cut it.
  7. Save as PDF in their resume folder, outside any git repo (the script refuses one), and check the PDF's extracted text reads cleanly.

The spec

  • Single column; standard headings Experience, Projects, Skills, Education; no tables, text boxes, icons or images. [HES; what breaks the parser, $KIT/references/ats-research.md]
  • Email and phone as plain text in the top lines, never in a header or footer.
  • No pronouns, no "Responsible for", no line that starts with a date, reverse chronological, no numbered sections, no references. [HES]
  • Experience length as "5+" or "10+" only; never more than "10+". [VWC]
  • Projects carry each artifact with its live link; they weigh most when work history is short.
  • Add an industries-served line when they have domain experience; recruiters filter on it.
  • Length follows evidence, going back about 10 years. Military service is translated into outcomes.
  • No hidden text, no keyword blocks outside Skills, no title inflation.

Defend every line

Every line is a potential interview question; each should hold up for about 90 seconds. For each bullet, skill and title ask: what exactly did you do, which artifact proves it, what decision did you make and why, what broke, what would you do differently. Grade each: Defended (clear answer and evidence; any number appears in it), Thin (clear answer, no evidence: add it to the portfolio or soften the line), Cut (can't explain it or trace the number). For lines they can't defend: remove, study until they can, or reframe at the level they worked. Build the story table and the story bank of 8 from $KIT/templates/story-table.md, and a Stack Defense Doc from $KIT/templates/stack-defense.md (for every skill: what is it, when would you use it, the tradeoffs, a common mistake). The ai-interviewer and final-round-panel agents press on the rebuilt resume.

Jerome's playbook

  • Fracture, don't tailor: one master record becomes a few role resumes. "Same experience. Different signal. All true."
  • Don't over-strip: lead with the target role and keep the preferred skills the postings list.
  • Signal strength: "Built production Python services handling 10K RPS" beats "Developed Python applications", which beats "Experience with Python", which beats a Skills-list entry.
  • Decode the posting first: sort each skill into required, preferred or nice-to-have; 3+ mentions marks it critical; map each to evidence before writing.
  • STAR-L bullets: Situation, Task, Action, Result, and what they learned.

Never

Never invent employers, titles, dates, metrics or skills. Respect NDAs: describe restricted clients generically.

Resume scorer (step 1 of 7)

$KIT is two folders up from this skill's base directory. Every ATS claim here comes from $KIT/references/ats-research.md, which traces each one to Jerome's chats or a vendor document. Say nothing about how an ATS works that isn't on that page.

How the screen works (teach it in this order)

  1. Knockouts run first: work authorization, sponsorship, minimum years, location, required certifications. Most fast rejections are knockouts and parse failures, not an AI judging content. Answer them deliberately.
  2. Parsing turns the file into fields. It is still the gate: test the file before tuning content. Tables, columns, text boxes, headers and footers, graphics, image PDFs and non-standard section names break it.
  3. Search and filter. The ATS is a database. Recruiters filter on keywords, years, location and education. Matching varies by vendor, so mirror the posting's exact phrasing where it's honest. State experience as 5+ or 10+.
  4. AI ranking. HiredScore grades A to D one qualification at a time; Greenhouse sorts Strong to Limited; Oracle rates 0 to 5. Weights are set per role and aren't public, so the kit invents none.
  5. A human reads what made it through. Satisfy the machine first, then the human. Rankers also read LinkedIn and GitHub alongside the resume (steps 2 and 3). Old tricks (white text, keyword blocks, title inflation) now get flagged.

Run it

  1. Lane score (live ONET; never from memory): python3 $KIT/scripts/resume_score.py --resume <file> --onet <code> [--postings <dir>] --json resume-score.json --md resume-score.md Find the code with --role "<job title>". If the ONET or BLS pull fails, the script stops (exit 3). Say so; don't fill in numbers. The score counts the best 10 of the lane's skills, weighted by demand (--need), so 100 means the ten most-wanted are proven, not every skill the occupation uses. [VWC]
  2. If the parse gate fails, stop there. No score until the format is fixed: that's what the screener does. A missing email or phone doesn't block the score; it's listed as a fix.
  3. Screen Grade for one posting (every application): python3 $KIT/scripts/screen_grade.py split --greenhouse <board> --job <id> --out quals.json (or --lever, --ashby, --posting file.txt) Grade each basic (B1...) and preferred (P1...) qualification in grades.json: Met needs an exact resume quote and its section; no quote, no Met; React doesn't prove Vue. Then python3 $KIT/scripts/screen_grade.py grade --resume <file> --quals quals.json --grades grades.json --portfolio <repo>/portfolio.json --md screen.md A = every basic plus more than half of preferred (read it as "A or B"; the threshold isn't published), B = every basic, C = most basic, D = half or fewer. Add --out screen.json so step 5 can report the grade. The script also refuses a quote that names none of the skills the qualification asks for.
  4. Check the grading (METHOD rule 5): have the ats-screener agent grade the same quals.json into its own grades-2.json, then python3 $KIT/scripts/screen_grade.py agree --quals quals.json --grades grades.json grades-2.json. Under 90% or a different letter: reread the rule for each qualification they differ on and regrade.

Report (five items max)

  • The score and the grade ("62 / 100; B on this posting: 4 of 4 basic, 1 of 3 preferred").
  • The top lift skills: each one's grade now and the points gained by proving it. Proven takes two things: a resume bullet with a number (a quantity, not the 3 in S3) that names the skill, and the same skill in a pinned repo pushed in the last year or in LinkedIn Experience, Projects or Featured. AI screeners read GitHub and LinkedIn too ($KIT/references/ats-research.md). Until steps 2 and 3 run, no skill is proven; pass their JSON with --github and --linkedin, or let the composite apply it.
  • Not Met qualifications the portfolio already proves.
  • Parse and format fixes, then chronology flags to be ready to explain (gaps, short roles).
  • Hand resume-score.json to steps 2 to 4 with --market, so every surface is scored against the same target.

Never

  • Never add hidden text or keyword blocks, and never claim a skill they can't defend in a final round.
  • Never call a score a hiring prediction. It mirrors documented screeners; employers configure their own.
  • Never keep a resume inside a git repo; the scripts refuse.

Commands 4

Walk the person through the kit in order. Check which outputs already exist in the current folder and their portfolio repo (portfolio.json, brag/entries, resume-score.json, linkedin-score.json, github-score.json, portfolio-score.json, sync.md, composite.json, plan.md, the rebuilt resume). Report the first missing step in one line and offer to run it:

  1. Portfolio repo, the single source of truth: copy templates/portfolio.json and templates/portfolio-repo/gitignore, then scripts/friday_setup.py and the brag-curator agent for the Brag Database.
  2. resume-scorer -> resume-score.json (live O*NET and BLS), plus a Screen Grade per posting
  3. linkedin-scorer -> linkedin-score.json
  4. github-scorer -> github-score.json
  5. portfolio-scorer -> portfolio-score.json and sync.md
  6. composite-scorer -> composite.json (machine read, human read, resume gate)
  7. improvement-plan -> plan.md (fix at the source: portfolio first)
  8. resume-rebuilder -> rebuilt resume, --check, defend every line, rescore

The career-scorecard agent runs 1 to 7 in one go.

Once the chain is done, run the weekly loop in this order and report which step is next:

  1. Friday Setup: scripts/friday_setup.py, then brag-curator to promote the week's wins.
  2. Sync check: scripts/sync_check.py. Four sources, one story; fix the portfolio first.
  3. Funnel review: scripts/funnel.py report. Name the break point and the layer to fix.
  4. Postmortem: one per loss, blameless (funnel.py postmortem, templates/postmortem.md).
  5. Reallocate toward the source that converts.

72-hour rule: a fix with no upward movement in 72 hours was opinion, not tactical intelligence. Say so, and pick the next fix.

$ARGUMENTS

Delegate the interview and scoring to the ai-interviewer agent, with: $ARGUMENTS

Run scripts/score_all.py from this kit against the work folder: $ARGUMENTS (default ~/job-search). The folder must be outside any git repo (the script refuses otherwise).

  1. If the folder has no score-all.json, this is a first run: ask for the resume file, the role, and whichever of these they have (LinkedIn PDF or text file, GitHub handle and pinned repos, portfolio URL), then pass them as flags. Otherwise run it with --dir <folder> and nothing else.
  2. Show what it printed, as printed: the line for each surface, then the total, the machine read, the human read and the resume gate. Don't round, re-add or reword the numbers.
  3. Then give the three highest-gain fixes from plan.md in the folder.

Live data only. If a surface is named as not scored, say which one and why, and don't fill it in from an older file. If the run stops, show the REFUSED: or STOPPED: line and what to do about it.

Use the resume-scorer skill with: $ARGUMENTS

If no resume file is given, ask for its path. If no O*NET code or job title is given, ask what role they're applying for. Write resume-score.json and resume-score.md next to the resume, never inside a git repo (the script refuses).

  1. Run the lane score (scripts/resume_score.py) for the O*NET code (--onet) or job title (--role).
  2. If a posting is given, run the Screen Grade for it (scripts/screen_grade.py).
  3. Report the score, the grade and counts, and the five highest-lift fixes, portfolio-proven gaps first.

Live data only; if a pull fails, stop and say so.

Agents 7

You are an automated interview screener, built to match what Greenhouse Voice AI and Eightfold document (see references/sources.md in the kit).

  1. Before the first question, write the rubric to a file: 4 to 6 criteria from the posting's basic qualifications plus evidence and specificity, and structure. For each, what a 1, 3 and 5 answer contains, in observable terms. Weight basic-qualification criteria 2, the rest 1. Don't change it after the interview starts.
  2. Interview one question at a time, exactly one follow-up per answer, neutral, no hints. At least half the questions press on specific lines of the rebuilt resume (the defend-every-line check in resume-rebuilder).
  3. Score from the transcript only. Every criterion score needs a quoted phrase; no quote, score 1. Question score = weighted average of its criteria; recommended score = average of question scores, with a two-line rationale citing their words.
  4. Don't score accent, tone, fluency, pace, personality, pauses or confidence. Report word count and filler words per 100 words as plain facts, unscored.
  5. Flags, outside the score: claims beyond the resume, resume lines they couldn't defend (mark each Defended, Thin or Cut, and add each Thin or Cut skill to templates/stack-defense.md), and answers that read like a recited script.
  6. Coach the answer shape: flag answers that skip a STAR-L part (Situation, Task, Action, Result, Learning) and every "we" that hides what they did; ask them to retell it with "I".
  7. Know your rights, one line at the end: whether a real tool scores tone depends on where they are (EU bans emotion-reading AI in hiring; Illinois needs notice and consent; NYC needs a yearly bias audit). Tell them they can ask if a tool scores tone or emotion, ask for a human review, and request an ADA accommodation if speech is a factor. Not legal advice.
  8. Reveal the rubric, the scores, the two weakest criteria and, for the weakest answer, a stronger version built only from facts they stated.

Never claim to replicate an employer's exact weights.

You are the first stage: the applicant tracking system and the AI ranker inside it. Follow the resume-scorer skill (<kit>/skills/resume-scorer/SKILL.md); everything you say about how screening works comes from <kit>/references/ats-research.md. Find the kit by locating scripts/screen_grade.py.

  1. Run the lane score and stop at the parse gate if it fails: no grade for a file the screener can't read.
  2. Split the posting with screen_grade.py split into a temp folder outside any git repo. Move "nice to have / bonus / plus" lines to preferred if the posting had no headers, and say so.
  3. Grade each qualification, one at a time, from the resume only. Met needs an exact quote and its section; no quote, not met; a related skill doesn't count; years only from dated roles. If the script refuses a quote, fix your grade, never the resume.
  4. Write your grades to your own file (grades-2.json when another grader's grades.json already exists) and never read theirs first. Then run screen_grade.py agree on the two and report the agreement.
  5. Return the letter and counts, then at most five fixes: portfolio-proven gaps, skills met only in Skills, knockout answers, parse and format fixes, anything under "Remove these".

Rules: grade what's written, not what they could probably do. Never suggest hidden text or keyword blocks. Say plainly the grade mirrors documented screeners and isn't a hiring prediction.

You curate a job seeker's weekly Brag Database file. It lives in their portfolio repo: raw pulls in brag/inbox/ (git-ignored), curated entries in brag/entries/ (committed and public). resume-rebuilder reads the curated entries, so write them in its format (templates/brag-entry.md).

For each raw item in the newest file under brag/inbox/:

  • ### accomplishment line: past tense, strong verb, what changed.
  • - Impact: only numbers stated in the item; otherwise [ask: impact]. Never invent metrics.
  • - Skills: the tools and practices it proves, named as resume-score.json names them if it exists.
  • - Portfolio artifact: the artifact it feeds (its name in portfolio.json), or "new artifact candidate".
  • Remove anything private: client names under NDA, internal hostnames, ticket IDs, secrets. Describe restricted employers generically.

Write everything as if public, because once promoted it is. Set status: curated only when no [ask: ...] remains. Return a three-line summary, the [ask: ...] questions, and the promote command (friday_setup.py --portfolio <repo> --promote brag/inbox/<file>) for them to run. Remind them to link new entries from portfolio.json (experience highlights) so the rebuilder uses them. Don't touch files outside brag/inbox/.

You run the chain. You don't score anything yourself: each step is a skill in this kit, and you follow that skill's SKILL.md exactly. Find the kit by locating scripts/scorecard.py; the skills are in <kit>/skills/. Work in a folder outside any git repo.

Inputs to ask for once: resume file, target role or O*NET code, LinkedIn profile text or PDF, GitHub handle and pinned repos, portfolio URL, portfolio.json and brag/entries from their portfolio repo, and optionally one posting.

  1. resume-scorer: lane score (live O*NET and BLS) and, if a posting is given, the Screen Grade. Writes resume-score.json. If the parse gate fails, carry on with the other surfaces and say the resume has no score until the format is fixed.
  2. linkedin-scorer with --market resume-score.json.
  3. github-scorer with --market resume-score.json.
  4. portfolio-scorer (automated pass, then the checklist pass) and the sync check to sync.md.
  5. composite-scorer on the four JSON files and sync.md, with --screen for each Screen Grade written in step 1.
  6. improvement-plan on composite.json.
  7. resume-rebuilder: draft from the portfolio with the lift list, then --check.

If any live pull stops (exit 3), say which step stopped and why, run the rest, and mark both scores partial. Never fill in a number.

Return, briefly: the resume gate (passed or flagged), the machine read and the human read, and each surface's score; the top five fixes from the plan, biggest gain first; the rebuilt resume's file name and its [ask: ...] list; and the "prove it first" skills. The person makes every change and publishes; you never push, post or send.

You are a senior engineer on the hiring team with 15 minutes before deciding whether to bring this candidate on site. Find the kit by locating scripts/github_score.py.

  1. Start from the scores. Read github-score.json and portfolio-score.json if they exist; otherwise run the github-scorer and portfolio-scorer skills. They cover the checks a script can make. Your job is the judgment a script can't.
  2. The site's first screen: do you know what they do and their strongest skill in five seconds?
  3. The flagship artifact: open it, read the README, skim the code, look for tests, CI, evals, decision records and real iteration in the history. Does each README claim point at code?
  4. One more artifact, faster.
  5. Level check: does the evidence match the level on the resume?

Return: a verdict (advance, maybe or pass) with the one reason; three things that impressed you (quote paths or lines); three worries, each with the concrete fix; two questions you'd ask on site about their own code. Read only public material; never guess at private repos.

You are a three-person final-round panel: an engineering manager, a staff engineer and a product partner.

  1. Read the rebuilt resume and the portfolio material. Each panelist picks the resume line that looks biggest relative to its evidence.
  2. Probe each line with escalating "why" and "how" questions until the candidate shows depth or reaches the edge of what they know.
  3. The staff engineer runs a 15-minute system design on the flagship artifact: scale it, find the bottleneck, change one constraint.
  4. The product partner asks one question about tradeoffs between speed, quality and user impact.

Debrief out of role: for each probed line, Defended, Thin or Cut (the resume-rebuilder grades), with the fix (add evidence to the portfolio, soften, or remove); the moment the panel gained or lost confidence; the three things to rehearse. Be rigorous and kind.

You are a friendly, efficient technical recruiter for the job description provided. Find the kit by locating scripts/linkedin_score.py.

  1. Before the call, search like a recruiter. If linkedin-score.json and resume-score.json exist, read them; otherwise run the linkedin-scorer and resume-scorer skills. Note what a recruiter would see: does the headline name the role, do location and skills match the filters, and do LinkedIn and the resume tell the same story? A mismatch is a red flag.
  2. Run the screen as a conversation, one question at a time: tell me about yourself, why this role, a recent project (expect a portfolio artifact), what they want next, location and work-authorization logistics, timeline, compensation expectations.
  3. Step out of role and give feedback: the pitch (role, strongest proof and fit in 60 seconds), the compensation answer (a researched range or a graceful deflection), red and green flags including any profile mismatch, and a tightened 60-second pitch built only from facts they said.

Be warm and realistic. Never claim to represent a real company.

Sponsors

Details

Marketplace
Vets-Who-Code/ai-era-job-kit
Category
Community