AI-Native Series · 07
Stop Studying for Interviews — Compile Them
1-minute takeaway — what you'll walk away with
A job description is source code. Parse it, ground it, link it against what you've actually built — and let the linker errors write your prep plan. The compile-the-interview method, term by term.
A job description is source code. Parse it, ground it, link it against what you've actually built — and let the linker errors write your prep plan. ~8 min.
The first résumé was a beautiful pile of unverified claims
In 1482, a thirty-year-old job seeker wrote to the Duke of Milan. His letter — the earliest known CV — was ten numbered claims: I can dry up the water of the moats. I can build unbreakable bridges. I can make cannon. Painting, the thing he's now rather known for, was item ten.
Number of moats Leonardo da Vinci had actually dried at the time of writing: approximately zero. The first résumé in history was already doing the thing résumés do — projecting capability without evidence. What eventually made his name wasn't the letter. It was the notebooks: seven thousand pages of drawings, measurements, and tests. The letter claimed; the notebooks showed.
Five hundred and forty-four years later, most interview prep is still letter-writing: cram the framework docs, memorize the glossary, rehearse adjectives about yourself. I'd like to propose the notebook approach, updated for 2026 — and it starts by treating the job description itself as something you run.
The mental model: a job description is source code
Here's the whole method, simple enough for a 12-year-old:
A JD is a recipe. Don't memorize the cookbook — read the recipe, check your pantry, and go shopping only for what's missing.
And here's the same method with its engineering hat on, which is the version I actually run (it's the animation at the top of this page):
- Parse. A job description is prose, but it encodes a spec. Extract what the role actually demands — the competency clusters, the named tools, the seniority.
- Ground. Make sure every extracted concept is a real thing with a real definition — not a keyword vibe.
- Link. Resolve each requirement against what you've actually built — public repos, running demos, things with commit histories.
- Read the errors. Whatever fails to link is your prep plan. Not "study everything" — build precisely the missing pieces.
Four verbs. The magic is that every one of them is executable — this isn't a metaphor wearing a hard hat. Which brings us to the part where I show my work.
Term by term: the kitchen maps to real machinery
A mental model you can't map to running code is decoration. So here's the mapping, term by term — every row is implemented in an open-source pipeline you can clone and run today:
"Read the recipe" = deterministic parsing. The compiler scores the JD against a curated competency taxonomy — six clusters like agentic system design and modern AI stack, plus a named-tool library. Matching happens at word boundaries, so "rust" never fires inside "trust." Deterministic and offline: same JD in, same profile out, no LLM mood involved.
"Check the ingredients are real" = retrieval grounding. Each extracted concept is then grounded against open sources — Wikipedia and Wikidata for definitions and relationships, ESCO (the EU's open skills taxonomy) for skills. Every node in the resulting knowledge graph carries a real definition and a provenance URL, enforced by contract: no http(s) source, no full node. If retrieval can't resolve a term, the node ships thin and flagged — never faked. A knowledge graph where you can't trace a node to a source is just confident clip-art.
"Check the pantry" = linking against receipts. Now resolve each demanded competency against your public work, like a linker resolving symbols against a library. Evaluation harnesses? Resolves to a repo that scores retrieval with precision@k and gates CI on it. Guardrails? Resolves to a security framework with sign-off checklists. Tool integration? Resolves to a shelf of MCP servers. Each resolution is a clickable receipt, not an adjective.
"Write the shopping list" = the gap report. Whatever's left unresolved is — precisely, provably — what to prepare. Not a syllabus. A shopping list.
Three telescopes: 30 days, 30 years, 300 years
"Sharp" means checking the claim at three zoom levels before betting your prep time on it. So I pointed three telescopes at this method — is it hot, did it survive, is it ancient?
The 30-day telescope (is it hot?). Agentic-AI job postings grew 280% year over year — roughly 90,000 US listings — while traditional entry-level tech hiring shrank. About 34.3% of those postings name LangChain; it's a baseline expectation now, and 57.3% of surveyed teams already run agents in production. Translation: the JDs are converging on a describable, parseable spec. Good news for a compiler.
The 30-year telescope (did it survive?). The 1998 selection meta-analysis found work samples among the strongest predictors of job performance — it has survived every replication war since. Applicant-tracking systems have parsed résumés into keywords since the 1990s; for thirty years, robots have been compiling you and rejecting the binary. (Rude.) This method just runs the compiler in the other direction — you compile them. And knowledge graphs — "things, not strings," 2012 — outlived their hype cycle to become boring infrastructure, which is the highest compliment machinery can earn.
The 300-year telescope (is it ancient law?). For centuries before the résumé, the guilds ran hiring on one rule: to become a master, a journeyman produced a masterpiece — one artifact, judged by people who could not be fooled. The résumé (1482, see above) is the newer and worse invention: claims without a judge. The pattern that survives every century, in every trade, is the same: the artifact outlives the letter.
Three telescopes, one conclusion: bring the artifact, not the adjectives.
The best prep output is an error message
Here's what happened when I ran this on a real posting — a senior "agentic AI engineer" role, the kind the 30-day telescope says is multiplying. The compile pass was flattering: six of seven competency clusters demanded, and most symbols resolved cleanly against public repos — orchestration loops, eval harnesses, an agent-security framework, a shelf of MCP tools.
Then the linker spoke:
$ jd-compile agentic-ai-engineer.md --link ~/repos
resolved: orchestration ✓ evals ✓ guardrails ✓ mcp-tools ✓
ld: undefined symbol — langgraphThe JD said "especially LangGraph." Twice. And my portfolio had zero LangGraph code — because every orchestration receipt I own is a custom-built engine. I had built the machinery the framework abstracts, which sounds impressive right up until you realize it's like showing up to a driving test with a car you built yourself and no license. Genuinely educational! Still no license.
This is the moment cramming would have wasted a week on. The gap report instead prescribed two moves:
- Translate, don't bluff. Every framework primitive maps onto something I'd already built the hard way — the state graph onto a score-carrying loop, the checkpointer onto banked, resumable memory, the human-in-the-loop interrupt onto a hard-stop approval gate. Knowing why each primitive exists is the senior conversation: the checkpointer is there because resumability dies the moment you let wall-clock time leak into a node. I learned that one the hard way, so I get to say it in the interview.
- Build the missing object file. One small artifact in the actual framework — four nodes, a checkpointer, one retry edge, one human gate — shipped public in half a day. The answer to "have you used it?" becomes "yes, here's the repo, and here's what my own engine does that it doesn't."
One error message. One afternoon. exit 0.
Make it SMART, then let it compound
The loop earns its acronym without stretching:
- Specific — one artifact per gap, named in advance ("a four-node stateful workflow with a checkpointer"), never "get better at agents."
- Measurable — re-run the compile; the symbol either resolves or it doesn't. No warm feelings admitted as evidence.
- Achievable — half-day scope. If the gap needs a month, that's not interview prep, that's a career decision; the report just made it visible early. Also useful.
- Relevant — every artifact anchors to a JD line you can quote back verbatim in the room.
- Time-boxed — done before the interview, because the interview is the deadline the compiler can't move.
And here's the part that beats cramming forever: the loop compounds. Every artifact you ship for JD #1 is already sitting in the library when JD #2 compiles. Your gap report gets shorter with every posting you run. Cramming resets to zero after each interview; compiling accrues. That's not a study technique — that's an asset building itself.
Run it yourself (it's all open)
The whole pipeline is open source — deterministic core, no API keys, no LLM required for the compile step:
git clone https://github.com/wjlgatech/FDE-os
cd FDE-os
# 1. drop any job posting into course/target-jds/ as markdown
# 2. compile it → competency profile
python3 skills/jd-compiler/scripts/jd_compile.py compile course/target-jds/your-jd.md
# 3. deepen it → grounded knowledge graph + skills (Wikipedia/Wikidata/ESCO)
python3 skills/jd-compiler/scripts/jd_to_deepen.py course/target-jds/your-jd.md \
--title "The Role" --url "https://the-posting-url"Then do the one step no script can do for you: hold each demanded competency up against your own public work and ask, honestly, does this resolve to a receipt — or to an adjective? Write down every adjective. That list, time-boxed and built, is the best interview prep you will ever do.
The one line to remember
Leonardo needed seven thousand notebook pages to back up ten claims. You need a lot less — because now the notebook checks itself against the job.
Don't study the whole cookbook. Compile the recipe, link your pantry, and go build exactly what's missing.
More in the AI-Native series
All of it lives in the Writing section on the home page.
Part of the AI-Native series. The jd-compiler and everything around it is open at github.com/wjlgatech/FDE-os — you own the Publish button. Sources: Leonardo's letter (Wikipedia) · Stanford 2026 AI Index posting data via JobsByCulture · LangChain State of Agent Engineering · Schmidt & Hunter (1998).