Meta title: Design take-home coding tests AI can't complete Meta description: How to design a take-home coding assignment that AI tools cannot complete for your candidate — practical patterns that still produce hiring signal.
How to design a take-home coding assignment that AI tools cannot complete for your candidate
Estimated read time: 8 minutes
Many take-home coding assignments written before 2023 are now solvable by a mid-tier LLM in under 10 minutes. If you want to know how to design a take-home coding assignment that AI tools cannot complete for your candidate, the honest answer is that you probably can't — not entirely. What you can do is design an AI-resistant take-home coding assignment where AI is a normal part of the work, and the signal comes from what the candidate does around the AI: the judgment, the context handling, the debugging, the trade-offs they can defend on a follow-up call.
This is a shift in what a take-home is for. It stops being a proof of coding ability in isolation. It becomes a proof of engineering judgment in an AI-assisted workflow — which is closer to the actual job anyway.
Why the classic format broke in the AI era
The classic take-home — "build a small CRUD app in the language of your choice, submit in five days" — assumed the candidate would be the primary author of the code. That assumption held until roughly late 2022. GitHub's 2024 Octoverse report notes that AI-assisted development has become increasingly common across active repositories, and Stack Overflow's 2024 Developer Survey reported that 76% of professional developers are either currently using or planning to use AI tools in their development process, up from 70% in the 2023 survey.
The result: a candidate who submits a clean, working CRUD app has proven very little about their own ability. They have proven they can prompt a model and paste the output. That is a real skill, but it is not the skill most hiring managers are actually trying to test with a take-home.
Two consequences follow. First, in our experience working with technical hiring teams, the false-positive rate on take-homes has climbed sharply — candidates ship work that looks strong and then cannot discuss it. Second, strong candidates are increasingly resentful of long take-homes, because they know the format is broken and they know reviewers half-suspect the work is AI-generated anyway.

The core design shift for an LLM-resistant technical assignment: from "did you write this" to "can you defend this"
The premise worth adopting is simple. Assume AI assistance. Design the take-home so that AI help is expected, and the evaluation focuses on the parts of the work AI can't fake for the candidate on the follow-up conversation.
This is the same shift many university programs made when calculators became ubiquitous. The problems changed. The evaluation changed. The skill being tested changed.
For an AI-proof coding assessment, four design principles produce assignments that AI tools cannot complete for the candidate in a way that survives scrutiny.
1. Anchor the assignment in a context only the candidate has
Generic prompts ("build a URL shortener") are the easiest for AI to complete end-to-end. Contextual prompts force the candidate to make choices AI can't make for them.
Concrete patterns that work:
- Give the candidate a broken repository — an intentionally flawed 200–400 line codebase — and ask them to identify the top three issues, fix one, and write a short note on the trade-offs of their fix. AI helps with the fix; the diagnosis and the trade-off note reveal judgment.
- Provide a partial system with an ambiguous spec. Ask the candidate to list the three questions they would ask a product manager before writing more code, then implement against their own resolved assumptions. The questions are the signal.
- Ask them to extend an existing feature rather than build from scratch. Extension requires reading, which AI is still weaker at than generation, and it produces a smaller code delta that is easier to discuss line by line.
The pattern: the deliverable includes both code and a short written artifact (a decision log, a set of questions, a diagnosis note). The written artifact is where AI signal degrades fastest, because it requires the candidate to have actually read what they submitted.
2. Require a live walkthrough as part of the AI-era hiring exercise
The single most effective defense against AI-completed take-homes is a 30-minute follow-up where the candidate walks a reviewer through their code, is asked to modify one function live, and is asked to explain a trade-off they made.
This is not an interrogation. It is a working session. Candidates who did the work themselves — with or without AI — handle it easily. Candidates who did not, don't.
Two things to design for the walkthrough:
- Pick one function in their submission and ask them to modify its behavior in a small, specific way. "What if the input format changed to include a timezone?" Watch how they navigate the file, whether they know where the change belongs, and how they reason about downstream effects.
- Ask them why they didn't do something. "Why didn't you cache this?" or "Why did you pick this data structure over a hash map?" The negative-space questions catch people who followed AI suggestions without evaluating alternatives.
If your hiring process can't support a 30-minute follow-up on every take-home submission, the take-home is not doing what you need it to do. Cut it and use a shorter, live-coded exercise instead. You can run live coding interviews with HackerEarth's FaceCode for the live component; a scheduled Zoom with a hiring manager works too.
3. Time-box tightly and make the scope visible
Long take-homes (5+ days, 10+ hours of work) are the format most vulnerable to AI completion. They also disproportionately screen out candidates with caregiving responsibilities, current jobs, or anything approaching a life outside work.
A 90-minute to 3-hour take-home, with the scope stated explicitly, does more work than a five-day project. Candidates who spend 15 hours on a 3-hour assignment produce output that no longer represents their unaided ability, and the extra time doesn't produce better signal — it produces more polish, which is the exact thing AI adds cheaply.
State the scope in the assignment: "This should take a strong candidate roughly 2 hours. If you're spending significantly more, stop and submit what you have with a note on what you'd do next."
4. Evaluate against an explicit rubric, not against a "gut feel" ceiling
Rubric drift is the quiet killer of take-home evaluations. Two reviewers looking at the same submission reach different conclusions, and when AI is in the mix, "this feels AI-generated" becomes a stand-in for "I don't trust this." That is not a defensible evaluation.
An explicit rubric for a take-home coding assignment AI can't complete covers at least four dimensions:
- Correctness against the stated requirements
- Code quality relative to the seniority level being hired
- Quality of the written artifact (decision log, questions, or trade-off note)
- Performance in the walkthrough — specifically, ability to modify their own code and defend their choices
Score each dimension separately. Calibrate with two reviewers on the first five submissions of any new take-home before rolling it out broadly. Rubric-based evaluation is one of the areas where structured platforms help more than most people expect — for a deeper look at how to build rubrics that hold up across reviewers, see our guide to building a technical interview rubric.
What not to do
A few defensive moves get suggested often and don't work as well as advertised.
Aggressive AI-detection tools. Tools that claim to detect AI-generated code have false-positive rates that practitioner reports suggest are high enough to hurt honest candidates. Vendors of AI-detection tools designed for prose, such as Turnitin, have publicly acknowledged that detection accuracy drops on edited or paraphrased content, and code is easier to lightly rewrite than prose. (See Turnitin's guidance on AI writing detection accuracy.) Using detection scores as an evaluation input creates unfair rejections and legal exposure. Don't.
Banning AI use. Telling candidates "do not use AI tools" produces two outcomes: honest candidates follow the rule and are handicapped relative to the job's actual conditions, and dishonest candidates use AI anyway. The rule punishes the wrong people.
Locking down the environment. Proctored, keylogger-monitored take-home environments produce a candidate experience that top candidates walk away from. They also don't work — a second laptop sits next to the first one. Proctoring belongs in high-stakes assessments, not take-homes.
Making the assignment harder. Practitioner experience suggests that increasing difficulty to "outpace" AI often produces problems that AI still solves and that human candidates now fail. The result is a smaller, more frustrated candidate pool with no better signal.
A worked example of an AI-resistant take-home coding assignment
For a mid-level backend engineer role, a take-home that works as of 2026:
Provide a repo with a small REST service (300 lines of Python or Go) that has three problems: one obvious bug, one performance issue that only shows up at scale, and one design flaw that will bite the next engineer to touch it. Ask the candidate to:
- Identify all three issues in a written diagnosis (max 400 words).
- Fix the bug and open a PR-style diff.
- In their submission note, describe how they'd address the other two issues and what trade-offs each fix involves.
- Come to a 30-minute walkthrough prepared to modify their fix live in response to a changed requirement.
Total candidate time: 2–3 hours. AI helps with the fix and possibly drafts the diagnosis, but the walkthrough — where they explain the two issues they didn't fix and defend the trade-offs — is where the actual signal appears.
Frequently asked questions
Can I design a take-home coding assignment that AI tools cannot complete at all for the candidate?
Not reliably, and pursuing that goal leads to worse assignments. The workable version is to design a take-home where AI assistance is expected and the evaluation focuses on judgment, context, and defense of choices — which is what the job requires anyway.
How long should a take-home coding assignment be in 2026?
For most roles, 90 minutes to 3 hours of stated scope, with a 30-minute live follow-up. Practitioner experience suggests longer take-homes correlate with drop-out among strong candidates and with over-polished AI-assisted submissions that don't reflect the candidate's own ability.
Should we tell candidates they can use AI tools on the take-home?
Yes, explicitly. State that AI tools are permitted and expected, and that the follow-up walkthrough will focus on the candidate's ability to explain and modify their submission. This is more honest, produces less anxiety, and doesn't change the signal you get from the walkthrough.
What if a candidate refuses the live walkthrough?
Treat it the way you'd treat a candidate refusing any standard step in the process. The walkthrough is not optional in an AI-assisted world; it's where the take-home actually gets evaluated. If the process is designed so the walkthrough is 30 minutes and scheduled within a week of submission, refusal is rare.
Do AI-detection tools work for code?
Not well enough to use as an evaluation input. Research and practitioner reports suggest false-positive rates are high, honest candidates get flagged, and the tools don't survive an adversarial candidate who edits the AI output. Use structural design — walkthroughs, rubric-based evaluation, contextual prompts — rather than detection.
Key takeaways
- Assume AI assistance in every take-home submission; design for it rather than against it.
- Anchor assignments in context — broken repos, partial systems, extension tasks — that AI can help with but can't fully own.
- Require a 30-minute live walkthrough as a non-negotiable part of the process; it is where the actual signal lives.
- Keep scope tight (2–3 hours) and score against an explicit rubric with at least two calibrated reviewers.
- Skip AI-detection tools, aggressive proctoring, and AI bans — they punish honest candidates and don't stop dishonest ones.
See it in action
The rubric-drift problem described in principle 4 — two reviewers reaching different conclusions on the same submission — is the specific gap HackerEarth Assessments is built to close. Structured rubric scoring across reviewers keeps evaluations calibrated on the diagnosis, code, and walkthrough dimensions separately, so "this feels AI-generated" stops standing in for a defensible score. To see how it maps to the diagnosis-and-extension format described above, book a walkthrough of HackerEarth Assessments.



