Interview prep skill

Interview Prep — PM Briefing Skill

Purpose

Turn a Job Description into a single study-ready briefing for the candidate. One command in, one HTML report out, covering three things:

1. Company Briefing — company, product, mission/vision, financials, market, news
2. Role ↔ Me Fit — the candidate's CV vs the JD's requirements, strengths, gaps, "explain this" probes
3. Interview Questions + Talking Points — likely questions mapped to what's being probed and a tailored STAR story from real experience

The bar for every line: would this actually help the candidate in the room? Cut generic filler. Be specific to this company, this role, and this resume.

This skill ships PM-flavored (product-management interviews) but the structure works for most knowledge-worker roles — adjust the question categories in Phase 5 to fit.

---

Phase 0 — Set the working folder

Everything this skill reads and writes lives in one working folder. By default this is the current working directory where the skill was invoked. The user can override it by naming a folder when they invoke the skill ("run interview prep on ~/jobs/acme").

DATA_DIR = <current working directory, or the folder the user named>

The candidate puts these in DATA_DIR before running:

• Their resume — any .txt, .md, .pdf, or .docx file (see detection below).
• The Job Description — a .txt, .md, or .pdf file (a *JD* in the name helps).
• (Optional) a Reference Material/ subfolder with their own prepared answers, STAR stories, and "why role / why company / why me" narratives.

See examples/ for templates of each.

---

Phase 1 — Locate inputs & confirm

Read the resume (canonical CV truth). Detect it in DATA_DIR, top-level, in priority order:

1. A file path passed as an argument.
2. Else a file whose name matches *resume* or *cv* (case-insensitive).
3. Else ask which file is the resume.

ls -t "$DATA_DIR"/*.txt "$DATA_DIR"/*.md "$DATA_DIR"/*.pdf "$DATA_DIR"/*.docx 2>/dev/null

Read ALL reference material if present (the candidate's own prepared answers, in their voice — the primary source for drafting answers in Phase 5):

DATA_DIR/Reference Material/*

This may include a STAR/SAR story CSV, a Q&A answer bank, and "why role / why company / why me" narrative templates. Treat these as the source of truth for phrasing, stories, real metrics, and tone. Read every file in that folder each run (new ones may be added). If the folder is absent, skip — draft answers from the resume + research instead.

Find the JD. In priority order:

1. A file path passed as an argument when the skill was invoked.
2. Else a top-level file in DATA_DIR whose name matches *JD* or *jd*.
3. Else the most recently modified top-level .txt / .md / .pdf in DATA_DIR, excluding: the resume file, README.md, SKILL.md, and any interview_prep_* output.

Read the JD with the Read tool (it handles PDFs directly).

Round (optional). If the invocation named a round, capture it — one of: recruiter-screen, hiring-manager, product-sense-case, behavioral, exec-panel. Default = general (balanced all-rounds prep).

Confirm before doing any work. Echo back, in one short block:

• Resume file detected (path)
• JD file detected (path)
• Parsed company name
• Parsed role title + seniority
• Round (or "general")

If the detected JD looks wrong (e.g. it grabbed an unrelated file), or company/role can't be parsed, ask which file to use rather than guessing. Otherwise proceed.

---

Phase 2 — Parse the JD

Extract a structured outline (keep it in working memory, not a file):

• Company name, role title, seniority level, team / org / product area
• Core responsibilities (what they'll actually do day to day)
• Must-have requirements (years, domains, hard skills)
• Nice-to-have requirements
• Domain / industry signals (regulated? consumer? infra? 0-to-1? platform?)
• Any explicit values / culture language worth mirroring

---

Phase 3 — Company research + domain primer brief (web)

Before spawning the subagent, do a quick domain-gap pre-screen from Phase 2's domain signals. Ask: does this JD require deep familiarity with a specific operational or industry domain the candidate hasn't worked in?

Domain-knowledge gap (primer warranted — pass to subagent): The JD requires a vertical/workflow the candidate has no direct experience in. Examples: post-trade investment ops, insurance underwriting, credit risk, healthcare payments, semiconductor supply chain, energy trading, etc. The test: would a smart person who hadn't worked in this domain be noticeably lost in the interview? If yes → primer.

Experience gap (no primer — don't waste the subagent): Years of experience, seniority title, specific tool fluency (Python, SQL), management headcount. These can't be briefed away. Skip.

---

Spawn ONE research subagent (general-purpose) to run all web searches — keep them out of the main context. Hand it the company name, the role, the JD's product area, and the domain-gap brief if one was identified. Ask it to return two sections:

Section A — Company digest:

• What the company does, in one paragraph a smart outsider would understand
• The product(s) and how they actually work (esp. the AI/technical bits)
• Mission / vision / stated values
• Business model + financials: stage, funding rounds & total raised, lead investors, valuation, revenue/ARR if public, profitability; for public companies, recent results
• Market position + top 3-5 competitors and how they differentiate
• Material news from the last ~12 months (launches, raises, leadership, layoffs, pivots)
• 2-3 things that would make the candidate sound genuinely informed / 2-3 risks or open questions

Section B — Domain primer (only if a domain-knowledge gap was identified): A study-guide digest on the gap domain, scoped to what an interviewer from this domain will probe — not a textbook. Must include:

• End-to-end process / lifecycle (the 5-8 key steps, what happens at each)
• Key terminology and acronyms (with plain-English definitions)
• Where AI is currently being applied in this domain and what the open problems are
• The 2-3 things someone unfamiliar with the domain would get wrong or not know
• Regulatory/structural pressures or recent changes that matter

Keep Section B tight — enough to not look clueless and to ask smart questions. NOT exhaustive domain coverage.

Query format: "{company} {product} funding revenue competitors news 2025 2026" and follow-ups for Section A. For Section B: "{domain} how it works AI automation 2025" and "{domain} key terminology processes explained". Prefer primary sources.

If web access is unavailable or thin, degrade gracefully: build from the JD and flag in the footer. Never invent financials, funding numbers, or investor names.

---

Phase 4 — Role ↔ Me fit analysis

Build a requirement-by-requirement matrix: each JD requirement (from Phase 2) vs the resume.

For each requirement:

• Rating: Strong / Partial / Gap
• The specific resume evidence that supports it (name the project + metric)

For each Gap-rated requirement, classify the gap type:

• Domain-knowledge gap → learnable; a primer helps; flag for Phase 6 Tab 4
• Experience gap → structural (years, title, headcount); primer won't help; just reframe honestly

Then:

• Lead-with strengths — the 3-4 strongest matches to open the conversation on.
• Gaps & risks with honest reframes — name the real gaps (domain switch, the years/seniority bar, 0-to-1 startup ambiguity vs big-co, etc.). Only truthful framings — never coach the candidate to claim experience they don't have.
• "Explain this" probes — resume metrics an interviewer will challenge, each with a crisp 1-2 sentence defense. Pull the real numbers from the resume — never invent them.
• Positioning narrative — a 60-90 second "why me for this role" pitch tailored to this company and JD, weaving the strongest evidence into their language.

---

Phase 5 — Questions + talking points

Build a categorized question bank. Categories (PM defaults — adjust to the role):

• PM fundamentals (101) — prioritization, roadmap, requirements, tradeoffs, metrics
• Product sense / design — design a feature, improve X, 0-to-1 thinking
• Execution & analytics — metrics definition, A/B testing, debugging a metric drop
• Technical / AI depth — LLMs, RAG, agents, evals (LLM-as-judge, human-in-loop), latency/cost/reliability tradeoffs, when NOT to use an LLM
• Behavioral / leadership — conflict, influence without authority, failure, exec comms
• Company / role-specific — drawn directly from the JD, product, and research

Round-aware weighting (if a round was given):

• recruiter-screen → motivation, fit, comp/logistics, concise story; lighter on case
• hiring-manager → execution, scope of ownership, collaboration, the resume deep-dives
• product-sense-case → design + metrics heavy; include a worked example structure
• behavioral → STAR-heavy across leadership/conflict/failure
• exec-panel → strategy, vision, business judgment, crisp executive communication
• general → balanced across all categories

For each question, WRITE AN ACTUAL DRAFTED ANSWER — not just a pointer. This is the most important part of the section. For every question:

• A short Probing: line (what they're testing) + a STAR: tag for the story used.
• Suggested answer: — 3-5 bullets in the candidate's own first-person voice, ready to say out loud, grounded in their real stories and metrics, and adapted to the target company.

Draw the answers from the Reference Material (read in Phase 1) first, if present — that folder contains the candidate's already-prepared answers, phrasing, and stories. Reuse and adapt:

• A STAR/SAR CSV → resume-deep-dive answers and the canonical metric explanations.
• A Q&A answer bank → "tell me about yourself", why-role, strengths, weaknesses, where-do-you-see-yourself, why-PM, etc. Swap company-specific lines (mission, why-company) to the target company using Phase 3 research — never leave another company's name in.
• "Why role / why company / why me" templates → the motivation answers.

Only when no reference content maps to a question, draft a fresh answer from the resume + research. Even then, write a real answer — never leave a question with just a STAR pointer.

Match the candidate's voice from the reference files (warm, first-person, concrete, metric-led). Use their real numbers exactly; do not invent.

Pre-build 4-5 reusable STAR stories (Situation / Task / Action / Result, tight) from the resume + reference material. These back the answers.

Close with strong questions for the interviewer, tailored to the company and round.

---

Phase 6 — Build the combined HTML report

Write a self-contained HTML file via a Python Path.write_text() script (no external deps).

CSS — palette & fonts

:root {
  --bg:#FFFDF9; --ink:#111827; --ink2:#374151; --ink3:#6B7280; --ink4:#9CA3AF;
  --rule:#E5E0D8; --rule2:#EDE9E2; --surface:#FFFFFF;
  --pos:#15803D; --neg:#B91C1C; --acc:#4338CA;
  --pos-s:#F0FDF4; --neg-s:#FEF2F2; --acc-s:#EEF2FF;
  --amber:#92400E; --amber-s:#FFFBEB; --dark:#0F172A;
}
body { border-top:3px solid var(--acc); }

Fonts: Inter (400/500/600/700/800) + JetBrains Mono (500). Use JetBrains Mono for company name, role title, and question numbers. CSS content uses literal Unicode characters (·, →, ↓), never HTML entities.

Layout rules (REQUIRED)

• Full-width: the content container fills the screen — max-width: 1400px (or wider), width: 92vw, generous side padding. Do NOT use a narrow ~860px column. On wide screens, lay cards/stats out in multi-column grids so horizontal space is used, not wasted.
• Tabs, not a long scroll: the three areas are tabbed, not stacked <details>. A tab bar at the top with three buttons (Company Briefing · Role ↔ Me Fit · Questions), and a small self-contained JS toggle (onclick switches the active panel; only one panel visible at a time; first tab active on load). No external JS libraries.
• Font sizes — nothing below 12px, anywhere. Base body ≥ 16px. Headings larger. Audit every font-size (eyebrows, badges, table headers, pills, footnotes) — minimum 12px. Prefer 13–14px for secondary text.
• Bullets and tables over paragraphs: default to <ul> bullets and <table> grids. Reserve prose paragraphs for genuinely narrative content (the BLUF and the 60-90s pitch). Company overview, product mechanics, mission, news, strengths, gaps → bullets or tables.
• Minimal-chrome / no filled-box look. Avoid generic AI card styling — no colored-left-border "accent cards", no dark filled BLUF boxes, no amber filled warning boxes, no boxed question cards. Prefer clean hairline-separated entries: bold title (color the title text by severity — red=gap, amber=watch/caution, green=strength), body below, a thin border-bottom rule between entries, no left bar, no filled background.
  • BLUF: an accent-colored "BLUF" label + larger text, set off by a top accent rule and a bottom hairline — NOT a dark filled box.
  • Warnings: a red/amber bold lead-in word + text on a hairline row — NOT a filled box.
  • Questions: hairline-separated entries (border-bottom between questions) — NOT boxed cards.
  • Stat cards (number tiles) and tables may keep light borders; those aren't the cliché.

Structure

• Header — eyebrow "Interview Prep", company (mono), role + round, date.
• BLUF — 2-4 sentences (prose is fine here). The single most important framing + the top 3 things to nail + the one biggest gap to manage. Bold the key items. Sits above the tabs.
• Tab bar — three or four buttons; the active one styled with the accent color.
• Tab 1 — Company Briefing: overview, product/how-it-works, mission/vision (bullets); financials (stat-card grid + a table); market & competitors (table); recent news (bullets); "sound informed" + risks (bullets).
• Tab 2 — Role ↔ Me Fit: the requirement matrix as a table (rating badges: green=Strong / amber=Partial / red=Gap); lead-with strengths (bullets); gaps+reframes; "explain this" probes; the 60-90s positioning narrative (prose).
• Tab 3 — Questions + Talking Points: grouped by category; each question shows a real drafted answer (3-5 first-person bullets) plus a compact probe + STAR tag; then the 4-5 pre-built STAR stories; then questions for the interviewer (bullets).
• Tab 4 — Domain Primer (only if a domain-knowledge gap was identified in Phase 3/4): A study-guide tab for the gap domain. Open with a one-sentence callout: "Study guide — [Company] interview only." Then include: end-to-end lifecycle table (step / what happens / key institutions / where AI fits); key terminology table; a "what changed recently and why it matters" section; a cheat-sheet block (read this the morning of). Scope it to what an interviewer from this domain will probe — not a full domain education.
• Footer: generated date, data sources used, and any web/verification caveats.

Output path:

DATA_DIR/interview_prep_<company-slug>_<YYYY-MM-DD>.html

(<company-slug> = lowercased company, spaces → underscores, alnum only.)

---

Phase 7 — Independent review (think 2 levels up)

Before showing the candidate anything, spawn ONE independent checker subagent. Give it only the JD text and the generated HTML file path — not the reasoning that produced it — so it reviews cold. Frame it as a senior hiring leader / interview coach, two levels up.

It must check:

• Company section — does it actually match this company/JD? Anything generic, wrong, or hallucinated, especially financials, funding, valuation, investors, competitors? Flag any unverifiable claim.
• Fit section — does it reflect the real JD requirements (not invented ones)? Are the claimed strengths honest and evidence-backed? Are gaps named candidly rather than spun?
• Questions — genuinely role- and round-appropriate? Are STAR stories correctly matched to what each question probes?
• Gaps — anything obvious a smart interviewer would probe that's missing entirely?

It returns a short verdict: PASS or CONCERNS, with a specific, actionable fix list.

Apply all material fixes, then regenerate the HTML. If a concern can't be resolved (e.g. a financial figure genuinely isn't public), reflect it honestly in the report and note it. Carry the reviewer's verdict into Phase 8.

---

Phase 8 — Present

Open the report with a file:// link. One-line status:

✅ {company} · {role} · {round} | {N} questions across {M} categories | Fit: {X strong / Y partial / Z gap} | Reviewer: {PASS/CONCERNS} | {data caveats}

Note any unavailable data sources (web thin, financials private, etc.).

Close with a single line: "Say make PDF to export a print-ready version."

---

Phase 9 — PDF Export (on request only)

Only run this phase when the candidate explicitly asks for a PDF ("make PDF", "export to PDF", "I need a PDF"). Do not run automatically.

The core problem: the HTML uses tabs (display:none on inactive panels) and loads Google Fonts from the network. Both break headless PDF rendering — only the active tab prints, and fonts fall back to Times New Roman.

Steps:

1. Build a print-optimised HTML copy using a Python script (do not modify the original HTML file):

import re, pathlib

src = pathlib.Path("<original HTML path>").read_text()

# Remove Google Fonts links (no network in headless)
src = re.sub(r'<link rel="preconnect".*?>\n', '', src)
src = re.sub(r'<link href="https://fonts\.googleapis\.com.*?>\n', '', src)

# Swap to system font stack
src = src.replace("font-family: 'Inter', sans-serif",
                  "font-family: -apple-system, BlinkMacSystemFont, 'Helvetica Neue', Arial, sans-serif")
src = src.replace("font-family: 'JetBrains Mono', monospace",
                  "font-family: 'SF Mono', 'Menlo', 'Monaco', 'Courier New', monospace")

# Force all tab panels visible
src = src.replace('.tab-panel { display: none; }', '.tab-panel { display: block; }')

# Inject print CSS before </style>
print_css = """
*, *::before, *::after {
  -webkit-print-color-adjust: exact !important;
  print-color-adjust: exact !important;
}
@page { size: letter; margin: 1.8cm; }
body { font-size: 13px !important; }
.tab-bar { display: none !important; }
.tab-panel { display: block !important; border-top: 3px solid #4338CA;
             padding-top: 20px; margin-top: 28px; page-break-before: auto; }
.tab-panel:first-of-type { border-top: none; margin-top: 0; padding-top: 0; }
.container { width: 100% !important; max-width: 100% !important; padding: 0 !important; }
tr { page-break-inside: avoid; }
.entry, .star-card { page-break-inside: avoid; }
.stat-grid { grid-template-columns: repeat(4, 1fr) !important; }
"""
src = src.replace('</style>', print_css + '\n</style>')

pathlib.Path("<tmp path>").write_text(src)

2. Render with a headless Chromium browser. Try, in order, whichever is installed: Brave, Google Chrome, Chromium, or Microsoft Edge.

# macOS paths shown; adjust for your OS / browser
BROWSER="/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
# fallbacks: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
#            "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
# Linux: google-chrome / chromium / brave-browser on PATH

"$BROWSER" \
  --headless=new --disable-gpu --no-sandbox \
  --run-all-compositor-stages-before-draw \
  --virtual-time-budget=2000 \
  --print-to-pdf="<output PDF path>" \
  --print-to-pdf-no-header --no-pdf-header-footer \
  "file://<tmp path>"

3. Delete the temp HTML file immediately after the PDF is written.

Output path: same folder as the HTML, same filename, .pdf extension:

<same folder as HTML>/interview_prep_<company-slug>_<YYYY-MM-DD>.pdf

Confirm with: file size (expect 500KB–2MB for a full report) and page count.

If no Chromium-based browser is found, tell the candidate which browsers the skill looks for and ask them to install one (or open the HTML and print to PDF manually).

---

Philosophy

• Specific beats comprehensive — one sharp insight about this company beats ten generic bullets.
• Honest fit, always — surface real gaps with real reframes; never coach a fabricated claim.
• Every question carries an answer hook — a question without a STAR pointer is half done.
• Real numbers only — pull metrics from the resume; mark unknown financials as "not found."
• The cold reviewer is the quality gate — if it says CONCERNS, fix before presenting.
• Domain primers bridge gaps, not experience — auto-generate when the domain is learnable; skip when the gap is structural. Scope to what an interviewer will probe, not a full domain education. One tab, read-it-once depth.