What interviewers actually test
Two candidates, the same problem, the same AI, the same correct final code — one passes, one fails. The artifact isn't the assessment. AI-assisted rounds score four things the model can't do for you: strategic clarification, comprehension, verification, and communication — which map exactly onto the series' four-dimension rubric, with the stakes raised because the typing no longer proves you understood anything.
On this page
What interviewers actually test
Two candidates, one solution
Two candidates get the same task, the same assistant, the same hour. Both arrive at the same final code — clean, correct, all tests green. One gets a strong hire signal. The other is a no.
The first spent four minutes restating the problem and confirming one ambiguous requirement before touching the keyboard, wrote down two invariants the solution had to hold, prompted, read the diff out loud (“it’s doing a streaming pass, which is what we want because the input can be large”), added a test for the empty case, and narrated the trade-off when the interviewer raised load. The second described the task, accepted the AI’s implementation, ran the given tests, and said “done.”
Predict, before reading on: the artifacts are identical — so what, exactly, did the interviewer measure that came out opposite? Whatever it was, it wasn’t the code.
The mapping
The documented AI-assisted rubrics (Meta, Google, Canva) name four things they assess. They are not new — they are the series’ standing four-dimension rubric, wearing work clothes:
| AI-assisted round assesses… | …which is the rubric dimension | The behaviour that scores it | | --- | --- | --- | | Strategic clarification — aim before you delegate | Trade-off Awareness | restating the problem, confirming an ambiguity, choosing one-shot vs decompose out loud | | Code comprehension — reason about code you didn’t type | Technical Correctness | naming the invariant that breaks, explaining why the AI’s design fits | | Verification & debugging — prove it, don’t trust it | Evaluation Rigor | preregistered tests/invariants; prompt → review → run → confirm | | Communication during automation — think aloud while delegating | Communication (weighted) | narrating intent, decisions, and trade-offs as you steer |
The whole guide is built on this rubric, so this is the spine: every later chapter strengthens one of these dimensions, and the loop from Chapter 0 (clarify → preregister → prompt → review → run → explain) is simply the rubric run forward in time. Clarify scores trade-off awareness; review scores comprehension; preregister-and-run score rigor; explain runs the whole way and scores communication.
Why the stakes rise
Here is the counter-intuitive part, and the reason these rounds are harder, not easier.
When you wrote every line by hand, the act of writing forced a floor under three of the four dimensions for free. You couldn’t type a function without some comprehension of it. You couldn’t get it running without minimal verification. The labour itself was evidence.
Automate the typing and that floor disappears. You can now ship a correct-looking solution with zero comprehension, zero verification, and zero spoken reasoning — fast. So the interview moved to test exactly the part the automation cannot supply. The model raised the floor on production and, in doing so, made the floor on judgment something you now have to put there deliberately. “Rely solely on prompting → you fail” is not a warning about prompt quality; it is the rubric telling you that the three dimensions writing used to guarantee are now yours to demonstrate on purpose.
This is also why Communication is the weighted dimension of this guide. With the typing gone, narration is the interviewer’s main window into whether comprehension and verification actually happened — and across the whole demand baseline, failure to communicate is the single most common reason strong candidates are rejected.
Reading the signal
The skill this chapter builds is diagnostic: given a behaviour where the final code is fine, name the dimension it exposes. Predict each before you reveal it.
Each is a moment from an AI-assisted round where the final code is fine. Name the rubric dimension the behaviour actually exposes — that's what the interviewer is scoring.
“A candidate ships the AI's solution fast and correct. Asked 'what happens on an empty list?', they re-read the code for thirty seconds before answering.”
“Given an ambiguous spec, a candidate immediately prompts for a full implementation and builds something polished — that solves a slightly different problem than intended.”
“The candidate's code passes the tests they were handed. They declare it done with no cases of their own — then it fails on a boundary the interviewer probes.”
Now explain the pattern. In every case the artifact passed and the signal was negative, because each behaviour skipped a loop stage that supplies a dimension: re-reading to answer skips review (comprehension), polishing the wrong target skips clarify (trade-off awareness), and leaning on handed-down tests skips preregister/run (rigor). The interviewer isn’t grading the code; they’re grading which stages you actually ran.
How this is graded
This chapter is the grading, so apply it to yourself — the rubric is a mirror, not just a checklist someone else holds:
- Technical Correctness — can you, right now, explain why your current AI-assisted habit produces code you understand? If the honest answer is “I usually skim,” that’s the gap.
- Trade-off Awareness — do you decide one-shot vs decompose, and what to delegate vs do yourself, on purpose — or by default?
- Evaluation Rigor — do you define “right” before you prompt, or inherit whatever tests you’re handed?
- Communication (weighted) — could a listener reconstruct your reasoning from what you said while you worked? If you work in silence, the answer is no, and so is the round.
Industry variation
- Frontier labs — comprehension and correctness dominate; some rounds ban the assistant to test reasoning from first principles, so the technical-correctness column is unforgiving.
- Big tech — all four, with comprehension assessed explicitly (Google’s code-comprehension round) and trade-off communication central to the system-design portion.
- Startups — trade-off awareness and velocity: “have you shipped?” rewards aiming correctly and fast, which is clarification plus rigor under time pressure.
- Regulated (fintech, health) — evaluation rigor and provenance are weighted hardest; “how do you audit AI-written code?” is a verification question wearing a compliance hat.
Stretch: turn the rubric on your own loop
You now know the four dimensions and that the loop is how you hit them. Before the next chapter, do the honest version: which dimension is your weakest under time pressure, and which single loop stage — clarify, preregister, review, run, explain — would move it most? Most people find their weakest dimension and their most-skipped stage are the same one. That overlap is your highest-leverage practice for the rest of the guide.
Next: Chapter 2 — Clarify before you code, where the loop starts and the cheapest habit in AI-assisted work — pinning the real problem before you prompt — earns the most.