Take-home vs live coding in 2026? Neither, in their old form.

The take-home challenge had a 15-year run as the prestige interview format. It looked fair, it looked rigorous, and it gave candidates time to think. Then ChatGPT shipped, then Cursor shipped, then Claude Code shipped, and the floor of "what a competent candidate can produce in a take-home" got rebuilt by foundation models. By early 2026, 71% of engineering leaders surveyed by Karat said AI has made technical skills meaningfully harder to assess — and the format that took the biggest signal hit was the take-home.

Meanwhile the live whiteboard has its own problems. Algorithmic interviews trained on LeetCode were always a weak proxy for on-the-job performance, and now they're an actively misleading proxy: the candidates who grind hardest on artificial puzzles are sometimes the ones who reach for the wrong tool when handed real ambiguity.

So — if you're a hiring manager, head of engineering, or talent leader sitting on a process designed in 2021, this is the article. We'll look at the data, the failure modes of each format, the format that's quietly replacing both, and a sample loop you can copy.

The 2026 data on assessment formats

Karat's 2026 survey of 400 engineering leaders across the US, India, and China is the clearest signal in the public data. The takeaways:

• Take-home signal is degrading fastest. When the gap between "what an average candidate can produce with AI in 4 hours" and "what an exceptional candidate can produce with AI in 4 hours" compresses, the take-home stops being a comparison tool.
• Live interviews are gaining ground because they let the interviewer observe how the candidate works, not just what they produced. The process becomes the signal.
• Hybrid loops outperform single-format loops. 78% of teams that significantly improved hiring outcomes year-over-year run multi-stage assessments rather than a single dominant assessment.
• AI-allowed interviews are winning where they're tried. Chinese engineering teams are roughly twice as likely as US teams to allow AI tools during live interviews, and their accept rates have crept up correspondingly.

What take-homes actually still do well

Take-homes are not dead — they've been demoted. In 2026, the take-home works in three narrow situations:

• Top-of-funnel screen for "can ship anything." A 60-90 minute optional take-home filters out candidates who can't produce a working artifact at all. This is a low-signal screen, but it's directionally useful at high volume.
• Asynchronous portfolio for senior+ roles. Sending a candidate a recent design doc or architectural sketch and asking for written feedback measures something that no live interview can: depth of reading and quality of written critique. This isn't "build something from scratch in 4 hours" — it's "react to something we built, in writing."
• Roles where the on-the-job work is genuinely async. Documentation, technical writing, security review, devrel content. The format and the work match.

The take-home is dead in its 2018 form — a tightly-scoped "build a CRUD API in 4-8 hours" tasked to every candidate, no AI tools allowed (honor system), graded against a rubric of code quality. That format has lost signal, costs candidates significant unpaid time, and drives high-quality applicants out of the funnel. If you still run that loop, the candidates you're losing are the ones who already have offers elsewhere.

Why pure live coding doesn't fix it either

The reflex move when take-homes get gamed by AI is to go fully live, no AI allowed. This swings too far in the other direction. The problems with no-AI live coding:

The mismatch is worse than nothing. A candidate who is excellent at AI-assisted engineering may interview as merely good on a no-AI whiteboard, because the format penalizes the very habit you want them to have. Meanwhile, candidates who optimized for grinding LeetCode — a population skewed toward early-career engineers, not necessarily aligned with senior bar — outperform the format. You hire the wrong end of the curve.

The other failure mode of pure live: anxiety penalty. A 90-minute coding session under direct observation is high-pressure even for strong engineers. The format conflates "can code under pressure with someone watching" with "can code." For senior-IC roles, the first signal is mostly noise.

The format that's quietly winning: AI-allowed live pair-programming

Here's what's working in 2026, in our conversations with hiring leaders at frontier AI labs, mid-stage scale-ups, and well-known engineering-driven companies like Stripe, Anthropic, and Cursor:

The mechanics: a 60-90 minute session, screen-shared, real repo or realistic starter, an ambiguous problem with multiple reasonable solutions. The candidate can use Cursor, Claude Code, or any AI assistant they'd normally use. The interviewer watches and asks questions, not just at the end but during the work.

What you're measuring:

1. Problem decomposition. Does the candidate read the requirements, ask clarifying questions, and break the problem into pieces — or do they jump straight to prompting the model? The strongest signal in the first 10 minutes.
2. Tool judgment. When do they use the AI? When do they not? Strong candidates use AI for boilerplate and rote translation, then take over for the parts that need taste or context. Weak candidates either avoid the tool (penalty for ignoring obvious leverage) or defer to it for decisions it can't make well.
3. Verification habits. When the AI returns code, what do they do with it? Strong candidates read it, sometimes reject it, almost always test it. Weak candidates accept and move on.
4. Communication under ambiguity. Do they think out loud? Do they articulate the tradeoff between two approaches? This is the same skill that runs design reviews on the job.
5. Recovery from a wrong turn. Every realistic problem has one. How quickly do they notice they're stuck, and how do they unstick themselves? The most predictive signal of all.

For more on what to actually screen for in engineering hires, see our breakdowns of hiring senior engineers in 2026 and how to hire forward-deployed engineers.

A sample 2026 coding interview loop

Here's a loop we've seen working at engineering-driven scale-ups. Total candidate time: ~4.5 hours. Decision in 7-10 business days.

1. Recruiter screen (30-45 min). Conversational. No coding. Filter for fit, motivation, level, comp expectations.
2. Hiring manager + prior-work conversation (60 min). Deep dive into one project the candidate is proud of. The bar: they should be able to explain the system they built, the tradeoffs they made, what they'd do differently, and what the next layer of detail looks like under questioning.
3. Live AI-allowed pair-programming (90 min). The format described above. Ambiguous prompt, real repo or close to it, candidate's choice of tools. Rubric scored on the five dimensions above — not "did the code work."
4. Systems design (60 min). Verbal + whiteboard. A scoped real-world design problem the candidate would actually face in the role.
5. Bar-raiser / values interview (30-45 min). Run by someone outside the hiring team, focused on independent calibration and culture-add (not culture-fit, which excludes).

Optional addition for very senior roles: send a short async design memo prompt 24 hours before the on-site. Two pages, written response. Reviewed and discussed in the systems design session. This is the take-home format that still works — small, focused, written, used as a discussion starter not a pass/fail gate.

How to retire your old take-home without breaking your pipeline

If you're currently running a long-form take-home and want to migrate, the order matters:

1. Make the take-home optional. Convert it into a "if you'd like to share a portfolio piece or take-home, we'll review it" line. Track conversion rate of submitters vs non-submitters. You'll find the submitter rate is lower than you think.
2. Introduce the AI-allowed live session as a parallel track. Run it on half your candidates for 6-8 weeks. Compare hire rate, decline rate, and 6-month performance ratings between the two tracks.
3. Read the decline reasons. The candidates you're losing in the take-home track are giving you the most important data. "Too much unpaid time" and "another company finished my loop in 1 week" are the two answers we see most.
4. Rewrite your rubric. If the new format measures process, the rubric has to score process. "Code passes tests" stops being the dominant rubric line.
5. Train interviewers. Live AI-allowed sessions require interviewers who can resist the urge to grade output and learn to grade approach. Run two calibration sessions per interviewer before they're live.

What about junior, returner, and career-switcher hiring?

The advice above is calibrated for mid-to-senior IC hiring — the population that's most expensive to mis-hire. For junior roles and career-switcher pipelines, the calculus shifts:

• Junior: Short take-home challenges still have some signal — you're filtering for "can ship anything" rather than comparing top candidates. Keep it under 90 minutes. Allow AI explicitly. Grade for working code + ability to explain it in a follow-up.
• Returners: Lean heavier on prior-work conversation. A returner with 8 years of pre-break experience has more meaningful signal in their last shipped system than in a 90-minute coding exercise. See our guide on returning to tech after a career break.
• Career-switchers: The take-home is genuinely useful here because the candidate has chosen to invest the time and it demonstrates skill they've built in the absence of professional context. Pay for it if the take-home runs longer than 2 hours.

For the broader question of which candidates to screen for, our take on employer branding strategies covers the front-of-funnel side of the same problem.

The hiring leader's bottom line

If you remember nothing else from this article: match the assessment to the actual work. In 2026, the work involves AI tools. The assessment should too. Anything else introduces a signal mismatch that either lets weak candidates through (gamed take-homes) or rejects strong candidates (no-AI whiteboards).

The teams hiring fastest with the highest 6-month performance ratings are not the teams running the most rigorous old-format process. They're the teams that redesigned the loop to look like the job. Sometimes a process change is the biggest hiring-system upgrade you can ship this quarter.