01 logo

LeetCode Is Dead. Here's What Anthropic Replaced It With

A manager at Anthropic killed the coding interview on his team. The thing taking its place is harder to fake, and much harder to get access to.

By JinPublished 19 days ago • 6 min read

In October 2026, Felix Rieseberg, an engineering manager at Anthropic, posted on X: "At least on the team I lead, programming interviews are dead. I've seen enough to be confident that they no longer provide a useful signal. This month, I removed them from my hiring process."

The post reached 1.8 million views. His reasoning was blunt. Claude is good enough at traditional programming problems that handing a candidate a small React exercise now measures about as much as asking them to hand-write assembly. Rieseberg has led engineering for Claude.ai and Claude Code Desktop, and worked at Notion, Stripe, Slack and Microsoft before that. When someone who built those products says the question stopped measuring what he needs to know, the next question is what replaced it.

Why the old test worked, and why it stopped

LeetCode-style interviews ran on an information asymmetry. New graduates have no production record, so employers need a standard signal that produces a ranking inside 45 minutes. Algorithm puzzles fit. They were public, practiceable, and scored cleanly right or wrong. For years, solving them correlated weakly but acceptably with "can write code that runs."

That correlation was never high. Developers have complained for a decade that solving a puzzle in 45 minutes says almost nothing about writing maintainable, testable, deployable code. Often it only shows you've seen the problem before. During the mobile boom, plenty of people entered the industry by grinding problems and then shipped code that ignored concurrency, allocated a new object per enemy, and worked locally until traffic arrived. The test measured puzzle speed, not engineering judgment.

AI turned a crack into a canyon. When Claude writes a more correct solution faster than most candidates can, the exercise stops measuring the person and starts measuring the AI half of the pair. Rieseberg's phrase: the question is now "as meaningless as testing assembly."

What taste, empathy and principled thinking look like in a prototype

Rieseberg hasn't built a full replacement. His interim approach is to scan résumés and portfolios for small prototypes that show taste, empathy and principled thinking. Each of those words maps to something concrete.

Taste is restraint under constraint. Not "looks good." A prototype with taste doesn't put a message queue behind a personal tool. It might be SQLite and a light framework, with a README saying: single maintainer, low traffic, this is the cheapest thing to run for six months, and here is the migration path if usage grows. The clearest evidence of taste is what you declined to build and whether you can say why.

Empathy starts with knowing who reads your code. Beyond user experience: an API a stranger can call correctly on the first try, an error message that tells the next maintainer where to look, a decision note that keeps whoever inherits the project from stepping into the same traps. A prototype built from a friction you personally hit tends to carry this, because it isn't solving an invented problem.

Principled thinking means making defensible choices when nobody is checking. In a small tool that calls an AI API, you handle rate limits, retries and degradation, and you write down why a failed call returns a cached result instead of throwing. That says more about how you treat reliability than the framework choice does. Its opposite is "it runs, so it's correct." Once AI can make anything run, running proves little. Knowing when a thing shouldn't ship is the scarcer skill.

The fundamentals didn't vanish. They moved somewhere harder to fake.

The easy misreading of Rieseberg's post is that basics no longer matter. The reverse holds. When execution gets cheap, the bar rises to a place that grinding can't reach.

Call it complexity management. Before AI, the difficulty of writing code partly hid this work. The more you wrote, the more likely you were to hit a wall. AI pushed the cost of writing toward zero and left the wall standing in plain view. Judging where it is, and which part to walk around, is now entirely human work.

That work has at least three layers. Boundaries: how much a system should absorb, and which features that could be added shouldn't be. Failure: when AI-written code breaks in production in a way nobody predicted, can you locate the fault at the system level rather than patch the line? Trust: under what conditions does generated logic belong on the production path, and what evidence supports that call?

System design interviews are already moving this way. The good ones no longer ask for a tidy architecture diagram. They ask for bounded decisions under incomplete requirements, and for reasoning behind each choice that isn't "this stack is popular."

The part the upbeat version leaves out

Rieseberg's story has an appealing arc. No waiting out seniority, one good weekend prototype, direct proof. His example is Anthony Morris and Alice Zhao, two recent hires who built a Claude Code interface prototype over a weekend and shipped a first public version in about eight days.

Both things happened. What the story doesn't answer is how many newcomers get the chance to try.

Anthropic's own numbers answer it. In early 2025, junior engineers were 27% of new technical hires. By June 2026, 9%. Their share of the technical org fell from 21% to 14% over the same stretch. These aren't contradictions. They describe one shift: demand for execution contracts while the leverage of one person plus AI expands. Lower barriers and a narrower door can coexist.

It isn't only Anthropic. A Harvard study of 62 million workers found junior developer employment fell roughly 9% to 10% over six quarters after firms adopted generative AI, while senior employment held. SignalFire reported that hiring of people with under a year of tenure at major tech companies dropped 65% against a 2019 baseline.

Some companies push the other way. Vivek Raghunathan, SVP of engineering at Snowflake, says 70% to 80% of its current slots are junior, because eliminating them means no future senior leaders with both judgment and AI-native instincts. That doesn't refute Rieseberg. It confirms him from another angle: Snowflake's reason for hiring juniors is judgment, not typing speed. Raghunathan's own framing is that the scarce skill is "knowing what to build, breaking down problems, and noticing when an agent confidently gets something wrong."

So the conclusion that survives scrutiny is narrower than the optimistic version. The definition of fundamentals is shifting from writing good code to managing complexity, and that shift will not hand a job to everyone who makes it. It relocates the competition.

What a student should actually do

With the old signal gone and the weekend-prototype route facing a narrower door, the useful move isn't finding the new right answer. It's leaving traces of judgment.

One piece of Rieseberg's advice holds up under inspection. Find out what the company or department is trying to achieve, using your manager's manager's goals as a reference. Pick one idea that would visibly change the outcome if it worked. Build a working prototype over a weekend, skipping the PRD, the resource fight and the designer queue. Focus on the one idea, because newcomers tend to bury three good ones among twenty bad ones. The point isn't the prototype. It's externalizing a judgment into something another person can see, try and argue with. Inside a company that gets around seniority. In a portfolio it becomes the item an interviewer will actually ask about.

Weekend prototypes degrade into a new rote form if you treat them as a template. One that carries judgment answers four questions: what friction did you see, what else did you consider, what does the choice cost if conditions change, and what would you do differently now. Write those answers into the README. What you've shown then isn't that you can use AI to make a thing. It's how you work with it, how you review what it returns, and how you hold a position when it confidently produces something wrong.

Core computer science courses deserve more attention, not less. They won't teach you today's tools. They give you the vocabulary for why systems fail and which layer an abstraction leaks through. As AI generates larger systems, that vocabulary gets scarcer, because checking whether a generated system is reliable takes understanding rather than more generation.

Adjust expectations, too. LeetCode felt safe because the rules were clear: grind enough, maybe pass. The new signals carry no such certainty. Taste, empathy and principled thinking are judgments made in ambiguity, and any attempt to standardize them will produce another LeetCode within a year or two. You can't prepare a perfect answer. You can keep building, recording the reasoning, taking feedback and revising. Rieseberg doesn't have a complete answer either. He said he'd like to hear one.

What died with LeetCode is the belief that judgment can be outsourced to a question bank. What's left is the slower work of knowing, when nobody is setting the questions, why you're building this and not that.

tech newsfact or fictionthought leaders

About the Creator

Jin

Writer of reamstories

https://reamstories.com/jin

Enjoyed the story? Support the Creator.

Subscribe for free to receive all their stories in your feed. You could also become a paid subscriber, letting them know you appreciate their work.

Subscribe For Free

Reader insights

Comments

There are no comments for this story

Be the first to respond and start the conversation.

Sign in to comment
    Written by Jin