A candidate who can’t explain their own code isn’t new. What’s new is that in 2026 someone can clear a 45-minute algorithm screen without understanding a single line they typed, using nothing more exotic than a second monitor and a browser tab. If your interview loop was designed before 2023, it now measures the quality of a candidate’s tooling, not the quality of their engineering.
TL;DR
- The problem isn’t AI use, it’s unverifiable authorship. You need to know who did the thinking, not which tools were open.
- Five attack patterns dominate: LLM-coached live coding, real-time answer overlays, proxy interviews, AI-polished résumés, and deepfaked video candidates. Each has different detection signals.
- The strongest single filter is a deep “why” follow-up: change a requirement mid-exercise and watch whether the candidate reasons or re-prompts.
- Redesign beats surveillance. Live debugging of unfamiliar code, pair-programming in your real repo, and a take-home plus defense are nearly immune to overlay tools.
- Verify identity once, early, and cheaply: government ID matched against the live face, plus a recorded 60-second intro you can compare across every later call.
- Do not ban AI and do not install invasive proctoring. Both cost you strong candidates and neither stops a competent cheater.
The five things actually happening in your loop
LLM-coached live coding is the most common. The candidate shares their screen, an assistant on a second device or a stealth overlay reads the problem, and the answer arrives in 10-20 seconds. Commercial “undetectable” interview copilots have existed since 2024 and now run as always-on-top windows invisible to screen capture. Screen sharing proves nothing.
Proxy and impersonation interviews are worse, and rarer, but they’re the ones that get someone hired who cannot do the job. A strong engineer sits the technical rounds; a different person shows up on day one, or the same person is being fed everything by a colleague off-camera. In its 2024-2025 advisories the US DOJ documented hundreds of American companies unknowingly employing North Korean IT workers using stolen or borrowed identities. This is not a theoretical category.
Deepfaked video has crossed the threshold where a live face swap runs on consumer hardware at 30fps. AI-polished résumés are the highest-volume, lowest-severity version: a real person with thinner experience, whose CV has been rewritten to match your job description keyword for keyword. All five are one failure: your process rewards output you cannot trace back to a mind.
Detection signals that hold up
Most “tells” you’ll read about are noise. These are the ones that survive contact with real interviews:
| Signal | What it looks like | What to do next |
|---|---|---|
| Latency inversion | Long pause, then a fluent, complete, well-commented answer delivered at once | Interrupt mid-answer with a constraint change |
| Eye-line drift | Consistent glance off-camera before each answer, on a fixed rhythm | Ask a question requiring them to draw or point at a shared screen |
| Register mismatch | Polished textbook vocabulary for concepts, vague language for their own project | Ask about a decision they regret in that project |
| Zero debugging instinct | Code is correct on the first try, but they cannot find a bug you inject into it | Break their solution and ask them to diagnose it |
| Audio-visual lag | Lip sync drift, hair/glasses edge artifacts, unnatural lighting stability | Ask them to turn their head 90 degrees or pass a hand across their face |
| Résumé density | Six roles, all with quantified outcomes, all phrased identically | Ask for the raw numbers behind one metric and how it was measured |
One rule matters more than the list: an assisted candidate is optimized for producing answers, not for handling change. Any perturbation (new constraint, wrong assumption, sudden requirement) breaks the loop between the candidate and their helper. Introduce one perturbation per exercise and score how fast they recover.
Also stop treating speed as a proxy for skill. In an AI-assisted world, the candidate who solves your LeetCode-style problem in four minutes flat is more suspicious than the one who spends twenty minutes talking through tradeoffs.
Redesign the loop, don’t police it
The fastest fix is not a detection tool. It’s an exercise that an LLM cannot complete without the context that lives in your team’s head.
- Live debugging of unfamiliar code. Give them 150-300 lines from a real service with two seeded bugs: one obvious, one a race condition or an off-by-one in a boundary case. Assistants are good at writing code and mediocre at localizing failures inside unfamiliar systems. Budget 30 minutes.
- Pair-programming in your actual repo. A small, real ticket, your conventions, your test suite, your CI. Let them use Copilot or Claude openly. You are scoring how they direct the tool, reject bad suggestions, and navigate a codebase they’ve never seen.
- Take-home plus defense. The take-home is cheap to fake and that’s fine. It’s a filter, not a signal. The 30-minute defense is the signal: “Why this data structure?”, “What happens at 100x load?”, “Delete this abstraction and tell me what breaks.”
- Architecture with a moving target. Fifteen minutes into a design discussion, change a core assumption. Reads go from 1k/s to 200k/s. The write path must now be strongly consistent. Real seniors visibly re-plan; coached candidates restate their original answer with new adjectives.
Score authorship explicitly. Add a line to your scorecard: “Could this person rebuild what they showed me, alone, tomorrow?” Make it a required field. It changes what interviewers pay attention to more than any tooling change will.
Verify identity once, properly
Identity checks belong at the start of the funnel, not at the offer stage where the switch has already happened.
Match a government photo ID against the live face on the first video call, and note the name on the ID. Record a 60-second intro clip in that first call and keep it. Every later interviewer compares against it, which is what catches the classic bait-and-switch between screen and final round. Confirm that the video call name, email domain, and LinkedIn history are consistent, and that the profile has connections and history predating your job posting by years.
For final rounds, require camera on and one unbroken session, and ask a question that forces natural head movement. If you work with a recruiting partner, ask them directly what identity verification they run, whether they’ve ever caught a substitution, and what happened. A partner who has never seen the problem either isn’t looking or isn’t screening at volume.
What not to do
Don’t ban AI. You’ll filter out the engineers who use it well (which is now most of the strong ones) and keep the ones who memorized answers. State a policy instead: AI allowed in take-homes and pairing, disclosed; not allowed in the 30-minute defense, where you’re testing understanding.
Don’t install invasive proctoring. Keystroke logging, eye-tracking, forced room scans, and remote-desktop monitoring have three problems: senior candidates drop out rather than submit to them, they generate false positives against anyone with ADHD or a small apartment, and they don’t catch the second device, which is where the cheating actually happens. You get a worse pipeline and no additional integrity.
Don’t over-index on AI-detection scores. Text classifiers are unreliable on short samples and biased against non-native English writers, which for LATAM, Eastern European, and Asian candidates means systematically penalizing good engineers. Never reject on a detector score alone.
Don’t add rounds. Longer loops lose the candidates with options and give a determined faker more practice. Four well-designed hours beat eight defensive ones.
Frequently Asked Questions
Isn't it fine if a candidate uses AI to solve the interview problem (they'll use it on the job too)?
Yes, and that's exactly why the exercise has to change. On the job they'll use AI inside your codebase, under review, with consequences. Test that: open tools, real repo, real ticket, and score judgment (what they accept, reject, and verify), not whether the final code compiles.
What's the single highest-leverage change if I can only make one?
Add a 30-minute defense round to whatever you already do. No new code, just deep "why" questions about work the candidate already submitted, plus one mid-conversation requirement change. It costs half an hour per finalist and catches the large majority of coached candidates.
How do I spot a deepfake on a normal video call?
Ask for movement the model struggles with: turn the head fully in profile, pass a hand slowly in front of the face, hold a hand next to the cheek. Watch for edge artifacts around hair and glasses, lip-sync drift under fast speech, and lighting that doesn't change when they move. Real-time face swaps degrade under occlusion and extreme angles.
Will these changes make our process feel hostile to good candidates?
Only if you frame it as suspicion. Frame it as realism: "You'll pair with us in our repo on a real ticket, tools allowed." Strong engineers generally prefer this to whiteboard trivia, and it doubles as a preview of the work, which helps close them later.
How much does interview fraud actually cost when it gets through?
Salary is the small part. The real cost is time: these hires surface in month two or three, after they've burned a senior engineer's review cycles, and then you restart a search that takes 30-60 days. On a ten-person team that's roughly a quarter of lost roadmap.
Should we still run take-home assignments?
Yes, but demote them. Treat the take-home as a cheap filter and never as evidence of skill, keep it under three hours, and make the defense mandatory. If you're not willing to run the defense, drop the take-home entirely: an undefended take-home in 2026 tells you nothing.
