Vibe Engines is free, interactive AI engineering & system design — runs in your browser. Pick a learning path →
AI-assisted
coding interviews.
For a decade the technical interview banned the very tool you'd use every day on the job. That's ending. In the 2026 loop, an AI assistant is allowed in the room — which quietly changes the whole exam. When the model can write the algorithm, the interview stops asking "can you produce this?" and starts asking "can you work with AI to ship something correct?" The skill under the microscope moves from writing code to reviewing it — and that's a different muscle.
The format flip: from banning AI to expecting it
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.
Who allows AI, who bans it, and what they say
There is no single policy, and the same company can run both formats in one loop. Three named examples, each from the company's own words or its tooling partner:
| Company | Policy | What it tells you |
|---|---|---|
| Canva | In a June 2025 engineering post, head of platforms Simon Newton said backend, frontend and machine learning candidates are expected to use AI tools such as Copilot, Cursor and Claude. The pilot replaced the Computer Science Fundamentals screen. | The problems are ambiguous product challenges (the post's example is a control system for airport takeoffs and landings), not classic algorithm puzzles. Canva still assesses fundamentals, and candidates must "take full ownership of any code they produce." |
| Meta | Runs a pilot of AI-enabled coding interviews on CoderPad. The Meta recruiting team is quoted by CoderPad (October 2025): "It's not 'cheating,' it's how the job is evolving." | Format details such as duration and the model list come from candidate-prep sites rather than Meta, and they change. Ask your recruiter which round is which. |
| Anthropic | Its candidate guidance (updated July 2025) welcomes AI for drafting applications, but live interviews are "all you, no AI assistance unless we indicate otherwise," and take-homes are completed without Claude unless told otherwise. | Candidates are asked to be transparent about their AI use. A "bring your assistant" culture and a "no assistant" interview can sit inside the same company. |
The practical rule: assume nothing, read the invitation, and ask. Whether the assistant is allowed, which one, whether your own tooling is permitted, and whether the screen is shared are all things a recruiter can answer in one email. Using an assistant where the rules say none is the one move that ends a loop for certain.
What it now measures
Three capabilities the old format couldn't isolate:
| Skill | The round that tests it |
|---|---|
| Code comprehension | Dropped into an unfamiliar codebase, find and fix a bug — reading beats writing. |
| AI fluency | Prompt, steer, and critically review the model's output rather than accept it. |
| Judgment | Decide what to build and how to verify it — including eval-design rounds at frontier labs. |
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.
The math: why review, not generation, is scored
Here's a simple model (an illustration, not a measured result) 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 pcatch and pfalsepos — 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.
unskilled reviewer: misses errors, "fixes" correct code → final < raw AI (worse than not touching it)
What good steering looks like: a worked transcript
Suppose the task is "write a rate limiter for an API." Here are two candidates, side by side. The dialogue is illustrative, not from a real interview.
AI: (returns a fixed-window counter)
A: "Looks good." → pastes it, runs one happy-path test, moves on.
Candidate B: "Before code: I want per-user limits, bursts of 10, 5 requests/sec sustained, in one process. Token bucket or sliding window? Tradeoffs in two lines."
AI: (compares them; recommends token bucket)
B: "Token bucket. Write it with an injectable clock so I can test refill. Don't add Redis yet."
AI: (returns code)
B: "Your refill adds tokens before capping, so a long idle gap overshoots the burst limit. I'll add a test for that first." → writes the failing test, then asks for the fix.
Both candidates used the assistant. B stated the requirements before asking for code, chose the design, constrained the scope, made the code testable, and found a real defect by reading it. A did none of those things and would have shipped the fixed-window edge case, where a client sends a full burst at the end of one window and another at the start of the next.
| Rubric line | Strong signal | Weak signal |
|---|---|---|
| Framing | States constraints and success criteria before prompting | Pastes the problem statement verbatim |
| Verification | Writes or runs a test that could fail; reads the diff | Runs the happy path once |
| Pushback | Challenges a design choice with a specific reason | Accepts the first answer, or rejects it without a reason |
| Ownership | Can explain every line and why it exists | "The AI wrote that part" |
| Scope control | Keeps the change small and says what is out of scope | Lets the assistant sprawl into unrequested features |
Practice the verification line on the Read the Codebase, Fix the Bug challenge, and the take-home variant in the FDE Take-Home Playbook.
The new rounds you'll see
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.
How to prepare
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:
- Practice reading, not just writing. Pull unfamiliar repos and race to find the bug. Comprehension speed is now a scored skill.
- Practice directing and auditing AI. Give precise prompts, then review the output like an adversary — the habit of agentic coding done well.
- Practice writing tests that catch subtle failures. Eval design is a differentiator; a good verifier is worth more than a fast solution.
The interview finally matches the job. Your edge isn't recalling an algorithm the model already knows — it's being the reviewer who reliably catches what the model gets wrong. Train the catch rate; that's the number being scored.
When does a reviewer add value — and when do they subtract it?
The AI-fluency rubric is really one equation. The AI is correct with probability p; a human reviewing on top catches a fraction of its errors (p_catch) but sometimes breaks a correct answer (p_falsepos). Watch a skilled reviewer push final correctness above the AI's own, a null reviewer leave it unchanged, and a harmful reviewer drag it below — the exact signal an interviewer is looking for. Change the AI's baseline and the reviewer's skill.
Quick answers
What is an AI-assisted interview?
A technical interview where using an AI assistant is allowed, even expected. Since the AI can write the code, the exam shifts from writing algorithms from memory to working with AI well — comprehension, direction, and review.
What does it measure?
Code comprehension (find a bug in unfamiliar code), AI fluency (prompt, steer, critically review output), and judgment (what to build, how to verify) — plus eval-design rounds at some frontier labs.
Why is review the scored skill?
When the AI drafts the code, your contribution is catching its errors without breaking what it got right. final = p·(1−p_falsepos) + (1−p)·p_catch — a skilled reviewer beats raw AI, a careless one does worse.
How do I prepare?
Practice reading code and finding bugs fast, directing and auditing AI output, and writing tests that catch subtle failures. Content handbooks still teach the substance; this format tests how you apply it with a model.
Which companies allow AI in coding interviews?
It varies by company and by round. Canva said in June 2025 that backend, frontend and machine learning candidates are expected to use AI tools such as Copilot, Cursor and Claude. Meta runs a pilot of AI-enabled coding interviews on CoderPad. Anthropic's candidate guidance, updated July 2025, allows AI for drafting applications but expects live interviews without AI assistance unless the interviewer says otherwise. Always confirm the rules for each round with your recruiter.
Explore the topic
See this alongside everything else on the same subject — handbooks, system designs, challenges and tools, in one place.
More Handbooks
- The Agentic AI Interview HandbookTwenty topics every senior AI engineer should be able to reason about live — from eval pipelines to reliability patterns for generative systems.Read →
- The Senior AI Engineer Interview Handbook60 questions across architecture, production incidents, agentic systems, RAG, evals, cost, safety, and leadership — what staff-level AI interviewers actually probe for.Read →
- 50 Angular Interview QuestionsA visual handbook covering components, change detection, RxJS, signals, routing, forms, performance, and testing — what interviewers actually probe for in senior Angular roles.Read →
- 50 Python Interview QuestionsFundamentals to advanced: data structures, OOP, iterators & generators, the GIL, asyncio, memory, testing, and the standard library — a visual walk through everything a Python interview touches.Read →
- 51 LLM Evals Interview QuestionsGolden sets, LLM-as-judge, regression testing, offline vs online evals, RAG evals, agent evals, red-teaming, and observability — demystified for interviews and production.Read →
- The Agent Evaluations HandbookA self-contained handbook on evaluating AI agents — theory, interactive widgets, and practical guidance. Trajectory evals, tool-use scoring, LLM-as-judge, observability, and reliability for PMs, engineers, and founders.Read →