How to

How to prevent cheating in technical interviews: question design, live follow-ups, pair work and a verified final round

On this page
  1. What does each kind of cheating depend on, and which design takes it away?
  2. How do you write technical questions a hidden assistant can't answer for the candidate?
  3. How should live follow-ups work in a coding round?
  4. Why does pair work beat a silent coding test?
  5. Should you allow AI in the technical interview?
  6. When should the final round be in person or verified?
  7. What backfires?
  8. How do you score so that cheating doesn't pay?
  9. How do you keep it fair and lawful?
  10. Technical interview anti-cheating checklist
  11. Questions people ask

You prevent cheating in technical interviews by designing the interview so that a hidden AI assistant, a second screen or a stand-in has little to offer, not by trying to police the candidate's computer. In practice that means five things, as of November 2026: questions built on the candidate's own work and on your context, revealed in stages; live follow-ups that make the candidate change, break and explain code; pair work instead of silent tests; a final round held in person or with a verified identity check for roles with real access; and a written rule, sent before the interview, on which tools are allowed. Score the reasoning in the follow-ups, and a polished first answer from somewhere else stops paying off.

What the tools are and how they hide is covered in AI interview cheating tools explained; detection software in tools to detect AI use in interviews; signs of reading in how to tell if a candidate is reading answers; and take-homes in how to verify a take-home assignment is the candidate's own work. This page is the interview-design answer for coding, debugging and system design rounds.

What does each kind of cheating depend on, and which design takes it away?

Every form of cheating relies on something in the format. Remove that, and the cheat stops working without anyone having to catch it.

Kind of cheatingWhat it depends onDesign that takes it awayWhat does not work
Live AI assistant on screen or phoneA self-contained question with a generic good answer, and a few seconds to read itQuestions about the candidate's own systems; requirements revealed in stages; follow-ups that change the problemWatching eye movement; asking for a room scan
Second screen or helper off cameraTime to look things up and relay themConversation-heavy pair work where the interviewer interrupts and redirects; short, specific follow-upsRelying on the screen share to show everything
Proxy interviewer or face swapNo link between the person interviewed and the person hiredAn identity step at a fixed stage; the same interviewer at the first and last rounds; an in-person or verified final roundA one-time check of a photo ID at application
Outsourced take-homeA file judged on its ownA live walkthrough and change request after every take-homeCommit history or AI text detectors as proof
Leaked question bankReusing well-known puzzlesYour own scenarios, rotated variants, questions built on the candidate's resumeAsking candidates not to share questions

How do you write technical questions a hidden assistant can't answer for the candidate?

  • Anchor on their own work. "Walk me through the slowest query in the service you described, and what you changed" has no answer anywhere except in the candidate's memory.
  • Use your context, not a classic puzzle. Describe a sanitized version of a real problem on your team, with its constraints. Well-known exercises have been answered publicly many times.
  • Reveal requirements in stages. Give the first requirement, let the candidate start, then add a constraint ("the input no longer fits in memory," "this now runs in two regions"). A prepared answer to stage one is wrong by stage three.
  • Leave one thing deliberately open and see whether the candidate asks. Clarifying questions are part of the skill, and an assistant answering the literal question skips them.
  • Ask for decisions and trade-offs, not definitions. "Which of these two designs would you ship on Friday, and what would you watch on Monday?" tests judgment; "What is a hash map?" tests recall.
  • Include code reading and debugging. Hand over a short piece of your code with a real bug and a failing test. Finding a bug in unfamiliar code, out loud, is slow to outsource.

Examples of rewriting a question (illustrations, not a question bank):

Easy to outsourceHarder to outsource
"Implement an LRU cache.""Here is our cache wrapper and a graph of its hit rate dropping after Tuesday's deploy. What do you check first?"
"Design a URL shortener.""Design link tracking for our product with these three constraints; now the legal team says we can't store IP addresses. What changes?"
"Reverse a linked list.""This function passes its tests but times out in production. Find out why, then make it safe to call from two threads."
"Explain microservices vs. a monolith.""You said your last team split the billing service out. What broke in the first month, and would you do it again?"

How should live follow-ups work in a coding round?

Use a ladder of follow-ups on the code the candidate has just written. Each rung asks for something that only the person who understands the code can do quickly:

  1. Explain: "Talk me through line 14. Why that data structure?"
  2. Modify: "Now the function also has to handle duplicates. Change it."
  3. Break: "Give me an input that makes this fail or run slowly."
  4. Extend: "How would you test this? Write the first test."
  5. Compare: "What's one other way to do this, and why didn't you?"

Interrupt kindly and change direction now and then. A candidate who wrote the code picks the thread back up; a candidate relaying answers loses it, waits, and returns with a fluent but generic reply. Write down what you observe, not a conclusion. The follow-up approach for non-technical answers is in how to detect AI-generated interview answers.

Why does pair work beat a silent coding test?

A silent test, where the candidate codes alone while the interviewer waits, gives a hidden assistant the most room. Formats with constant interaction give it the least:

  • Pair programming: the interviewer and the candidate share an editor; the interviewer adds requirements, asks questions and occasionally drives.
  • Code review: the candidate reviews a short pull request from your codebase (sanitized) and explains what they would ask the author to change.
  • Debugging session: a failing test in a small repository; the candidate narrates what they check and why.
  • System design with interruptions: the interviewer changes a constraint every ten minutes and asks what moves.

Most coding interview platforms now let you switch AI assistance on or off and record every prompt; the options are compared in the best technical interview platforms. A full loop with a paired work sample is laid out in the software engineer interview guide.

Should you allow AI in the technical interview?

There are two defensible designs, and employers have published both:

  • AI allowed and assessed. Canva wrote on June 11, 2025 that it now expects backend, machine learning and frontend candidates to use AI coding tools such as Cursor and Claude in technical interviews. It made its problems more complex, ambiguous and realistic, so they cannot be solved with a single prompt, and assesses how candidates break down requirements, make technical decisions, and find and fix problems in AI-generated code. Candidates are told beforehand.
  • AI not allowed unless stated. Anthropic's candidate guidance (last updated July 10, 2025) asks candidates to complete take-home assessments without its AI assistant "unless we indicate otherwise" and says of live interviews: "This is all you–no AI assistance unless we indicate otherwise."

Either works if it matches the job and is stated in advance. What does not work is an unwritten rule. Once the rule is written, "cheating" has a definition: using help the instructions did not allow, or someone else doing the interview. A wider policy for all interviews is in candidates using AI in interviews: a fair policy. For the technical round, a line like this in the invitation is enough:

Technical interview: what's allowed
- Allowed: language documentation, your own notes, [AI coding
  assistant: allowed and part of the exercise / not allowed].
- Not allowed: help from another person, or [AI tools generating
  answers during the session].
- We'll share an editor and talk through the code together;
  expect questions and changes as you go.
- The final round is [in person at our office / on video with a
  short ID check at the start, the same for every finalist].
- Need an adjustment? Tell us beforehand and we'll arrange it.

When should the final round be in person or verified?

The designs above defeat a hidden assistant. They do not defeat a proxy, someone else who interviews under the candidate's name. The FBI has warned that North Korean IT workers "have been observed using artificial intelligence and face-swapping technology during video job interviews," and recommends that employers "Complete as much of the hiring and onboarding process as possible in person" (IC3 PSA I-012325-PSA, January 23, 2025). For roles with production systems, customer data, source code or payments, put one technical round where identity is tied to the work:

  • In person: the final pairing session at an office, with an ID check on arrival.
  • Verified video: a short identity step at the start (the steps are in deepfake candidates in video interviews), run by someone who also saw an earlier round.
  • Continuity: the same person opens the first and last technical rounds, so a change of person is noticed.

Apply it to every finalist for the role, not to candidates who seem suspicious. The trade-offs are in should we bring back in-person interviews?, and the stage plan in the candidate identity verification checklist.

What backfires?

  • Trusting the screen share. Microsoft documents a Windows setting, WDA_EXCLUDEFROMCAPTURE, under which "The window is displayed only on a monitor. Everywhere else, the window does not appear at all" (SetWindowDisplayAffinity, Windows 10 version 2004 and later). A shared screen can look clean while a window sits on top of it.
  • Room scans and eye tracking. They intrude on privacy, catch nervous and neurodivergent candidates, and prove little.
  • Treating a detector flag as proof. A flag from any tool is a reason to ask another question.
  • Banning all notes for everyone. Some candidates need notes or assistive technology as an accommodation; handle requests through your accommodation process.
  • Changing the rules mid-interview. Accusing a candidate of breaking a rule they were never told about is unfair and hard to defend.

How do you score so that cheating doesn't pay?

Weight the scorecard toward what a hidden helper cannot supply: debugging, explaining trade-offs, adapting to a changed requirement and asking the right clarifying question. Give the first, polished solution less weight than the changes made under follow-up. Write anchors that describe what the candidate did ("found the race condition after one hint and explained the fix"), and have each interviewer score independently before the debrief. A copy-ready version is in the software engineer interview scorecard.

How do you keep it fair and lawful?

  • Same format, same stage, every candidate for the role. Do not add checks for people whose accent, name or location makes an interviewer uneasy; that is the road to national origin discrimination (see citizenship status discrimination in hiring).
  • Tell candidates about recording and get consent where state law requires it (is it legal to record a job interview?). If software analyzes video for an Illinois role, the Illinois AI Video Interview Act applies.
  • Record facts, not verdicts. "Could not modify the function when asked to handle duplicates" is evidence; "was cheating" is not.

If a candidate does break the stated rules, or you think someone else took the interview, follow the proxy response playbook. For agency pipelines, see candidate fraud in IT staffing.

Technical interview anti-cheating checklist

[ ] Written rule on allowed tools sent with the invitation
[ ] Questions use the candidate's own work and our own scenarios
[ ] Requirements revealed in stages; one deliberate ambiguity
[ ] Follow-up ladder: explain, modify, break, extend, compare
[ ] Pair work or code review instead of a silent test
[ ] Take-homes followed by a live walkthrough and change request
[ ] Question variants rotated; no well-known puzzles
[ ] Scorecard weights follow-ups over the first answer
[ ] High-access roles: in-person or verified final round, all finalists
[ ] Same interviewer at first and last technical rounds where possible
[ ] Accommodation route offered; recording notice given
[ ] Observations written as facts; concerns escalated, not accused

Facts on employer policies and Windows behavior checked on the companies' own pages as of November 2026. Not legal advice.

Questions people ask

How do you stop candidates from using AI during a coding interview?

You cannot block every tool on a candidate's own computer, so design the interview so that a hidden assistant does not help much: ask about the candidate's own past work, reveal requirements in stages, make them change and debug code live, and score the reasoning in the follow-ups rather than the first answer. Tell candidates in writing whether AI is allowed, and for roles with high access, hold the final round in person or with a verified identity check.

Is screen sharing enough to catch cheating in a technical interview?

No. Windows lets an application mark its window so it does not appear in screen captures at all, a setting Microsoft documents as WDA_EXCLUDEFROMCAPTURE, and a phone or second screen on the desk is never in the share. Screen sharing shows you the editor, which is useful for pair work, but it is not proof that no other help is present.

Should we allow candidates to use AI in technical interviews?

Either choice can be fair if you state it in advance and design for it. Canva said in June 2025 that it expects backend, machine learning and frontend candidates to use AI coding tools and assesses how they break down requirements and fix the AI's mistakes, while Anthropic's candidate guidance, updated July 2025, says live interviews are without AI assistance unless the company says otherwise. Cheating then means breaking the rule you stated, not using AI as such.

Do take-home coding tests still work if candidates can use AI?

Only with a live walkthrough. Treat the submission as material for a 20 to 30 minute discussion where the candidate explains choices, answers why not the alternative, and makes a small change live. Nothing in the file itself proves who wrote it.

Should the final technical round be in person?

For roles with production, data or money access it is the strongest single control. The FBI's January 2025 advisory on North Korean IT workers, who have used face-swapping in video interviews, recommends completing as much of the hiring and onboarding process as possible in person. Where that is not practical, a verified video round with an identity check at the start, run the same way for every finalist, is the alternative.