AI-assisted
interviews.

The old contract was simple and increasingly fake: sit in a room, no tools, reproduce an algorithm from memory. Then the job changed — engineers now spend the day directing AI — and the interview lagged behind, testing a skill (from-scratch recall) that the job no longer prizes. The correction is the AI-assisted interview: bring the assistant, use it openly, and be judged on how well you do so.

This isn't a small tweak; it's a change of subject. A candidate who memorized a hundred LeetCode patterns and one who can steer and audit a model are now being measured on different axes. The rest of this handbook is what those axes are, and the one bit of math that explains why they matter.

Three capabilities the old format couldn't isolate:

Notice the through-line: every one is about working with code you didn't write from scratch — the AI's code, a stranger's codebase, an output you have to trust or reject. The interview has become a test of judgment under assistance, not production under constraint. And the load-bearing skill in all three is the ability to catch what's wrong.

Here's the one model that explains the shift. Suppose the AI produces a correct solution with probability p. A human reviewing on top contributes two things: they catch some of the AI's errors (fixing wrong answers), and they occasionally break a correct answer by "fixing" what was already right. Final correctness is:

AI right and not broken by the human, plus AI wrong but caught and fixed. The human's whole value lives in p_catch and p_falsepos — pure review skill.

And the punchline the interview is built around: a skilled reviewer lifts final correctness above the AI's alone, while a poor one — who breaks correct code and catches little — drags it below what the AI would have produced untouched. An unskilled AI user is net-negative. That's exactly what an AI-fluency rubric is trying to detect, and the runnable model below makes it vivid.

The format is still settling, but a recognizable set of rounds has emerged:

• AI-pairing round. Solve a real task with the assistant on. Assessed on how you prompt, when you push back, and whether you verify — not just whether it compiles.
• Code-comprehension round. Navigate a multi-function codebase you've never seen and locate the bug. Direct prep for real work; see the sibling code-comprehension challenges.
• Eval-design round. Frontier labs increasingly ask: design a test that would catch a subtle failure. Because verifying AI output is now the job, they interview for it.
• Review round. Given AI-generated code with planted defects, find them. This is the review-skill math above, run as an exercise.

Every one rewards the same core: read fast, reason about correctness, and don't trust output you haven't verified. The tools change; the judgment is the point.

Prepare differently than for a classic algorithms loop. The interview-prep and system-design handbooks still teach the content you need to reason about — that hasn't gone away. This format tests how well you apply it alongside a model, so add three practices the old grind skipped:

1. Practice reading, not just writing. Pull unfamiliar repos and race to find the bug. Comprehension speed is now a scored skill.
2. Practice directing and auditing AI. Give precise prompts, then review the output like an adversary — the habit of agentic coding done well.
3. Practice writing tests that catch subtle failures. Eval design is a differentiator; a good verifier is worth more than a fast solution.