Interview craft and transfer: the skill above the skills

The rejection that wasn’t about knowledge

Chapter 11 closed by calling the interview itself a system — a loop with phases, failure modes, and an evaluator whose rubric you know. Here is that system’s most common failure, in the wild. A friend — a genuinely strong engineer, who’d have aced every technical question in this guide — gets rejected from a loop and asks the recruiter for feedback. It comes back: “solved the problem in silence,” “jumped in without clarifying requirements,” “we couldn’t follow the reasoning.” Nothing about RAG, nothing about agents, nothing wrong with the architecture.

That feedback is the norm, not the anecdote: one published review of ~50 hiring decisions put communication and articulation failures at ~40–45% of rejections, practitioner guides consistently rank them first — ahead of any knowledge gap — and jumping-in-without-clarifying runs close behind. Predict: if the reasoning was right, what exactly was the interviewer unable to grade — and whose job was it to make that gradable?

The craft loop

The same four moves run every round type — coding, design, deep-dive, behavioral:

1. Clarify before solving. Restate the problem in your own words, surface the constraint that changes the answer (“is this latency-sensitive? what’s the feared failure?”), confirm scope. Chapter 11 budgeted five minutes for this; even a coding question earns ninety seconds.
2. Narrate the structure, then fill it. “Three candidate approaches — here’s the trade-off, here’s my pick and why” beats discovering your structure mid-sentence. The senior trade-off sentence (Ch 11) is this move in miniature.
3. Checkpoint. Every few minutes: “that’s retrieval — want me to go deeper here or move to generation?” Checkpoints let the interviewer steer, which converts the interview from exam to collaboration — and following their cue is itself scored.
4. Close the loop. Summarize what you built, name what you’d do next with more time, and quantify anything you claim — behavioral stories included: baseline, change, measured movement, and how you measured it. An unquantified impact story is a named screening failure (“overstated impact without metrics”).

None of this is personality. It’s a protocol, and protocols are practicable.

The round where the AI writes the code

The newest round changes what “coding interview” means: Meta runs a three-panel setup where you pick your model and work a 60-minute multi-file task; Google has announced pilots of “code comprehension” rounds with an approved assistant; companies like Canva hand you realistic, deliberately un-one-shottable problems with the AI required. The assistant’s presence isn’t a perk — it’s the subject. Four things are graded: strategic prompting and clarification, genuine code comprehension, verification and debugging, and communication while you automate. Meta’s guidance is blunt: rely solely on prompting and you fail.

The loop that passes it — and it should look familiar, because it’s Chapter 8’s agent discipline applied to yourself as the orchestrator:

1. Clarify the task like any other (the craft loop doesn’t pause for tooling).
2. Decompose — name the files, the seams, the order of attack.
3. Preregister your theory before prompting: “the bug should be in the pagination offset; this failing test should flip first.” Committing to a falsifiable expectation turns the AI’s output into evidence you can check instead of plausible text you accept — interviewers distinguish exactly this from “prompt theater.”
4. Prompt with a spec, not a wish (Chapter 1, verbatim).
5. Review like the author — because you now are: read the diff, interrogate the parts that surprise you, reject what you can’t defend.
6. Run and verify — tests, edge cases, the prediction from step 3.
7. Explain — narrate what you accepted, what you rejected, and why.

The visible anti-pattern has a shape worth fearing: two hundred pasted lines, green tests, a feeling of great productivity — and one follow-up question you can’t answer. Failing while the code looks fine. The durable skill — durable across every model generation — is governance over automation: you own every line you ship, whoever wrote it.

Transfer: the question you’ve never seen

Every chapter of this guide ended with a stretch problem that introduced something not taught and asked you to reason about it with the chapter’s tools. That wasn’t decoration — it was training for the moment every interview eventually reaches: the question you’ve never seen. The trained response is a bridge: name the gap honestly, then map the unknown onto a structure you own. “I haven’t tuned HNSW — but it’s a recall/latency trade-off, so: golden set, sweep the knob, measure against the p95 budget.” The structures you now own are exactly the maps: every wrong answer localizes to a stage (Ch 4); every config decision wants a golden set (Ch 5); every upgrade has a price (Ch 6, 7); every autonomy question is dials and gates (Ch 8, 9); every adaptation question runs the funnel (Ch 10); every “design X” runs five steps (Ch 11). Bluffing collapses under one probe; bridging converts the same probe into a demonstration of how you learn.

The practice method, briefly and honestly:

• Mocks under real conditions — timed, out loud, with a person or a recording you actually review. Untimed silent practice trains the wrong skill.
• Score against the rubric, with evidence. After each mock, one paragraph per dimension citing what you said — “never volunteered the eval strategy” is actionable; “felt okay” isn’t. You built this habit in Chapter 11’s capstone.
• Spaced retrieval beats re-reading. Return to chapters’ practice problems at growing intervals; re-reading produces fluency that evaporates under pressure (this guide’s whole pedagogy assumes you’ll do the problems).
• Match the prep horizon to the target. Startup loops are portfolio-first — “what have you shipped?” — and reward exactly the kind of public artifact this guide’s companion is. Frontier-style loops realistically take months of preparation including visible work, not a two-week cram. Calibrate honestly.

See it: spot the craft failure

Five moments where the technical content is fine and the craft is the variable. Diagnose each before revealing.

How this is graded

• Technical Correctness — your bridges land on real structure: the mapped-to framework actually fits the unseen question.
• Trade-off Awareness — visible in real time: options narrated with prices as you think, not reconstructed afterward.
• Evaluation Rigor — claims quantified, theories preregistered, AI output verified before shipped — in the interview and in the stories you tell about your work.
• Communication — this chapter’s weighted dimension, and the guide’s closing argument: it is not garnish on engineering skill; the documented rejection evidence consistently ranks it as the differentiating engineering skill.

Industry variation

• Big tech — AI-assisted coding rounds are mainstream; expect multi-file, phased tasks and explicit comprehension probes; cost/latency fluency (Ch 7) shows up in every design round.
• Startups — portfolio-first: shipped artifacts and quantified outcomes outweigh round performance; the companion library you built alongside this guide is precisely the genre of evidence they ask for.
• Frontier labs — paper fluency and research taste enter the loop, safety conviction is screened throughout, and some labs ban AI assistance in rounds — read the loop’s rules before training for it; the prep horizon is months of visible work, not weeks of cramming.

Stretch: the loop that doesn’t end

This guide ends where the dogfooding loop begins. The transfer test that matters isn’t a stretch paragraph — it’s the next real system you build. So run the full circuit once, on something real: take a system you own (or build the companion’s support bot into one), run Chapter 11’s mock on its design, Chapter 5’s golden set on its behavior, Chapter 7’s budget on its bill — and write up what you found where someone can read it. A public, quantified post-mortem of your own system is simultaneously the best interview preparation in this guide and the artifact every “what have you shipped?” conversation wants. The production-systems guide — operating these things when the traffic is real — picks up from there.