Skip to content

Essay · PreTested

Why LeetCode and take-home tests stopped working.

By · · 8 min read

Contents

This week an engineering manager at Anthropic said in public what a lot of hiring managers had been thinking: the coding interview is finished. Here is why it broke, what it was ever measuring, and what the first round of a technical hiring process should be instead.

On 27 October 2026, Felix Rieseberg, who has led engineering for Claude.ai and Claude Code Desktop at Anthropic, published a post with a blunt first line.

felixrieseberg.com

Felix Rieseberg · Engineering manager, Anthropic

Hunger beats tenure: Advice for junior engineers

“This month, I laid the traditional coding interview to rest. As a hiring manager at Anthropic, I stopped asking candidates to do them.”
Read the post ↗See it on X ↗

His reason is simple. There is no point in a little React challenge any more, because Claude is better at it than the candidates are. He is not the first hiring manager to get there. He is one of the first to say so from inside the company that built the thing that broke it.

1. The screen was a proxy, and the proxy broke

No one ever thought reversing a linked list was the job. The coding screen lasted twenty years because it was a cheap stand-in for something expensive to measure: does this person understand software well enough to be worth an engineer’s hour?

The stand-in was imperfect, famously so. But it was correlated with the real thing, and it scaled. A recruiter sent a link; a score came back.

A proxy only works while it is hard to pass without the quality it stands for. That stopped being true in about two years.

How the proxy broke
  1. 2023

    AI assistants solve the easy problems and some of the medium ones.

  2. 2025

    They solve nearly all of them, explain the solution, and turn a two-paragraph brief into a working take-home project.

  3. 27 Oct 2026

    A hiring manager at Anthropic stops using coding interviews for his team.

The link between “passed the screen” and “understands the work” didn’t weaken. It went to zero.

Rieseberg puts it as plainly: being able to define a small problem quickly and find an elegant solution “was a weak but useful predictor”, and it is not one any more. He doesn’t expect the interview to come back, and he notes that nobody liked it in the first place.

2. What LeetCode measured, and why it worked for a while

Be fair to the thing before burying it. A timed algorithm problem measured three things at once:

  • whether the candidate knew a small set of patterns;
  • whether they could hold a problem in their head under pressure;
  • whether they had put in weeks of preparation for this specific hoop.

The third was the strongest signal and the least relevant. It predicted conscientiousness and how badly someone wanted the job, which are real. But it selected for people with free evenings to grind problem sets, and that is not the same as the best engineers.

It worked, to the extent it did, because the preparation was costly and the problems were hard to do without understanding. Both have gone. Preparation is now “open the assistant”; the problems are a solved set. What is left is a test of whether the candidate will follow an instruction not to use the tool they use every day at work, which is a strange thing to select for.

3. Take-homes: the same failure, slower

Take-home assignments were supposed to fix the coding screen: a real problem, real code, no stopwatch, the candidate’s own setup. They were better. Candidates hated them anyway. Four to eight unpaid hours per application, times every company in the pipeline, with a one-line rejection at the end. The candidates with options declined first.

Now an assistant produces a complete, tested, documented take-home in well under an hour. The submissions look better than they did in 2022, and they tell you less. A reviewer reading a clean repository can’t tell whether the candidate wrote it, directed it, or pasted the brief and ran the result.

Take-home test vs a 30-minute conversation
QuestionTake-homeConversation
Candidate’s timeFour to eight hours, unpaidThirty minutes
Can an assistant do it?Yes, in well under an hourNot at the speed of a conversation
What you seeA clean repository, author unknownReasons, trade-offs and real examples, in their words
Who drops outThe candidates with other offersThe candidates who can’t explain their work

The only part of a take-home that still carries signal is the conversation about it afterwards. Which is to say: the conversation.

4. The cheating frame is the wrong frame

Most of the response so far has been to put the proxy back: lock the browser, record the screen, watch the candidate’s eyes, run the code through a detector. It is expensive and hostile, and it loses. Detection is a contest against tools that improve every month, played on the candidate’s own machine.

And it answers the wrong question.

You don’t need to know whether the candidate used an assistant. They did, they will at work, and you want them to.

What you need to know is whether they understand what the assistant produced. Can they tell when it’s wrong? Change it when the constraints change? Explain it to a colleague?

Rieseberg makes the same point from the other side. Impact now depends less on years of framework knowledge and more on judgment and the ability to build quickly, and he admits he hasn’t fully worked out how to interview for that. Nobody has. But the shape of the answer is clear, and it isn’t a better lock on the browser.

5. What still works: a conversation about decisions

A live technical conversation has the property the screen lost: it’s hard to hold a good one without understanding. The first answer can come from an assistant in another tab. The second and third, at the speed of talk, can’t. Nor can the real example from their last job that a good engineer reaches for without being asked. Here is what that looks like.

Example · Senior backend · Node.jsFirst round · 30 min

14:02Recruiter —How would you diagnose rising tail latency in a Node.js service when downstream response times are stable?

14:03Candidate —I’d look at event-loop delay first, because if downstream is flat, the time is going somewhere in our own process.

14:05Recruiter —Why that first, rather than the database?

14:05Candidate —The database is downstream too, and you said that’s stable. We had exactly this last year: a JSON.parse on a 4 MB payload blocking every request behind it.

14:07Recruiter —What changes at ten times the traffic?

Rieseberg’s own answer, for his team, is to look for small prototypes in a candidate’s portfolio that show taste and principled thinking, then talk about them. That’s a conversation about decisions too.

Most teams don’t get hundreds of applicants with public prototypes. For them the structured version is the practical one:

  • The same questions for every candidate for the role, written from the job description with the hiring manager.
  • Three or four listen-for points per question, so the interviewer hears whether the ground was covered.
  • Follow-ups that ask why, what breaks, and what changes under a new constraint.
  • A written rubric, 1–10 per section, with the levels described in words.
  • A report that quotes the candidate, with the time they said it, so an engineer can check it in two minutes.

Thirty minutes of that tells you more than a weekend of take-home. And it costs the candidate thirty minutes, which they’ll happily give you.

6. Who runs it, if not an engineer

The obvious objection: a conversation needs someone who can judge the answers, and the whole point of the screen was to save that person’s time.

But a first-round conversation run from a script, with listen-for points and a rubric, doesn’t need an engineer on the call. It needs an engineer for one hour, once, to write the script. After that a recruiter runs it. A good recruiter runs it better: they know the role, they’ve met the candidate, and they aren’t squeezing it in between two incidents.

PreTested interview room: question 1 of 12 for a Node.js test, “How would you diagnose rising tail latency in a Node.js service when downstream response times remain stable?”, marked answered, with the AI assistant showing 4 of 4 listen-for points heard beside the candidate’s video.
During the call in PreTested: the question, its listen-for points ticked off as the candidate covers them, and the candidate’s video.

We run our first rounds this way at ON3 Works, and we built PreTested so that other recruiters can: it drafts the script from the job description, follows the call and ticks off the listen-for points, and scores the transcript against the rubric with quotes as evidence. The method does not depend on the software, though. We wrote it up as a guide: how to run a technical interview without an engineer.

7. What to do with the old tests

Not everything has to go in the bin.

  • Stop using coding tests as the first filter. As a gate they now select for compliance with a no-tools rule, and they cost you the candidates with options.
  • Keep a short paired exercise for a later round, with the assistant allowed. Forty-five minutes, together, on a problem close to the real work. Watch how they use the tool: what they ask it, what they reject, what they check. That is the job now.
  • Shrink any take-home you keep, and talk about it. Two hours, paid if you can, and the interview is the conversation about the decisions in it, not the code.
  • Start with the conversation. Structured, scored, with evidence. It is the one part of the process that got more valuable when the proxy broke.

Rieseberg ends with an open question about interviewing people who build well with AI: “If you have figured it out, I’d love to hear how.”

Our answer: talk to them about their decisions, score what they say, and show your evidence. It’s older than LeetCode, and it still works.

8. Questions

Are LeetCode-style interviews still useful in 2026?
As a first-round filter, no. An AI assistant solves the standard problem set faster and more reliably than most candidates, so a pass tells you the candidate had the assistant open, or did not and spent weeks practising problems they will never meet at work. They can still be a reasonable later-round exercise when done live, together, with AI allowed, as a way of watching how someone works.
What is a good alternative to a take-home coding test?
A structured live technical conversation in the first round: the same questions for every candidate, written listen-for points, follow-ups that ask why and what would break, and a 1–10 score per section with the candidate’s own words as evidence. It takes thirty minutes, cannot be outsourced to an assistant and tells you what the take-home never did.
Is using AI in a coding test cheating?
Only if you told the candidate not to, and then you have tested whether they follow instructions. At work they will use an assistant every day. The useful question is not whether they used one but whether they understand what it produced, which a conversation answers and a submitted file does not.
How do you interview engineers who build with AI?
Ask about judgment rather than output: what they built, what the assistant got wrong, how they knew, what they changed and why. Ask for a prototype or a portfolio and talk through the decisions in it. Felix Rieseberg’s post, linked in this essay, is honest that nobody has fully worked this out yet; a live conversation about real decisions is the best current answer.
Can a recruiter run the technical conversation instead of an engineer?
For the first round, yes, with a script written with the hiring manager, listen-for points per question and a written rubric. Our guide to running a technical interview without an engineer explains how, step by step.

Run your next technical screen yourself.

No waiting for an engineer, no bot talking to your candidates, and a report your hiring manager can check. Start with three interviews free over 30 days, no card needed.