How AI Is Reshaping Coding Interviews in 2026

Loick, VP of Global Operations at CoderPad, has a pretty clear answer: for most of what companies actually care about, it wasn't. In a recent conversation with Exponent (youtube.com), he laid out where coding interviews are moving in 2026, and the picture is more interesting than a simple "LeetCode is dead" headline.

The signal problem

Here's the core issue Loick identifies: a classic LeetCode-style problem, a 25-line function solving one algorithmic puzzle, never really mapped to what engineers do at work. AI didn't create that mismatch; it just made it impossible to ignore. "Before AI, a LeetCode exercise was already not the best way to really assess real-life coding skills," he says. "But now with AI it's completely obsolete. You just cannot trust the signal because AI instantly solves it."

What companies want to know is: can this person step into a real codebase, understand what's going on, and improve it? That's a very different skill from inverting a binary tree under time pressure, and Loick argues the industry is finally building assessments that check for the right thing.

The Hacker News thread asking "Will your company be doing LeetCode interviews a year from now?" shows the same tension playing out across the industry: engineers who think the format was always broken, hiring managers defending it as a volume filter, and everyone uncertain what should replace it.

What's replacing it

Two formats are gaining ground fast, according to Loick.

The first is the multi-file project interview. A company drops you into a small but real application, something like a Node.js backend with a React frontend that they built specifically for hiring. Your job isn't to write code from scratch; it's to explore the app, figure out how it works, find the bug, add the feature. The evaluation is watching how quickly you orient yourself in unfamiliar code and whether you follow the patterns already there or ignore them entirely.

The second is what Loick calls the prototype-from-scratch interview, which maps roughly to what the industry has started calling "vibe coding" in a structured context. You get 30 minutes and a blank canvas. The assessors are watching whether you ask the right clarifying questions before writing a line, whether your architectural choices at minute five make iteration faster at minute 25, and whether you treat AI output as a draft to review or a final answer to ship.

Both formats are measuring something that's harder to fake than an algorithmic solution: judgment.

LeetCode as a bouncer, not a judge

Loick doesn't think algorithmic questions disappear entirely. His framing is more precise: they stick around as gatekeepers, not signal generators. A five- or ten-minute basic coding question at the top of the funnel can catch candidates who can't write a loop without AI assistance. Loick estimates the automated screening layer, which now includes AI-graded video responses as well as simple code problems, cuts out roughly half of the volume before a human reviewer ever engages.

The key word there is "estimate." Loick is describing what he observes through CoderPad's platform, not citing an external study, so treat those numbers as informed practitioner perspective rather than published data.

What he's emphatic about: the moment you're past the screen, the tiny algo exercise is useless for distinguishing good candidates from great ones. "This is not where you can really differentiate good candidates between each other."

How to actually prepare

If a friend texted me right now saying they had a CoderPad interview next week, here's what I'd tell them, drawing on Loick's advice.

The screen at the top of the funnel is a vibes check on basics, so dust off the fundamentals before you go in. Loick says it himself: "I use AI most of the time. I review code but I don't write code." If that's you too, spend a few days writing small things by hand. Not to memorize algorithms, just to confirm your fingers still know what a for loop looks like without autocomplete.

For the video or async screening portion, the weird advice is: practice being on camera. Comfort talking through your thinking in a recorded environment is a filter, and it's a learnable one. Talk through problems out loud with someone, record yourself answering questions, watch it back once. That's it.

For the realistic project formats, the actual prep is building things with AI in a way that mirrors how the interview will go. Don't just prompt Claude and accept the output. Try plan mode, review what it proposes, push back on it, then implement. Do that on a project big enough that the codebase starts to get messy, because that's when AI starts to struggle and your judgment fills the gap. Loick puts it plainly: "The bigger the codebase becomes, the harder it is to actually use AI and give it the right context."

On cheating

Loick's take on AI cheating is surprisingly relaxed, and I think he's right. The tools candidates are "cheating" with are increasingly the same tools the job uses. Penalizing someone for using Claude in an interview for a role where they'd use Claude every day is, as Loick frames it, a content problem: "Usually the companies that are experiencing cheating are asking the wrong thing."

CoderPad's detection runs during the no-AI segments specifically. Use AI there and you're out. But Loick's broader argument is that well-designed assessments make cheating structurally unattractive: the risks outweigh the reward because the harder interview stages require you to demonstrate judgment that AI can't sub in for.

The 'be yourself' problem

Loick's parting advice is to show up as yourself, because AI-polished resumes have commoditized surface-level presentation. Everyone's resume now perfectly matches the job description, so companies can't use it to differentiate. The interview is where authenticity does real work.

I'll be honest: I find this advice both true and a little uncomfortable. On one level, it's hopeful. The interview format is shifting toward something that rewards curiosity, judgment, and communication, which are harder to fake than a rehearsed LeetCode solution. If you're a good engineer who learns fast and communicates clearly, that reads better now than it did when the whole process was reducible to pattern-matching on algorithmic problems.

On the other hand, "be yourself" as a competitive strategy assumes that who you are comes through legibly in a 30-minute structured interview on an unfamiliar codebase with an AI assistant you're supposed to be directing. Candidates who've had more access to tools, mentorship, or time to build side projects will show up with a more practiced version of "authentic" AI-assisted engineering. The shift toward realism doesn't flatten those advantages; it may just move where they show up.

Where this goes

Loick estimates roughly 20-30% of companies on CoderPad have moved to fully AI-assisted interview formats, and he sees that number growing as AI agents get better at autonomous code generation. His read is that future interviews will assess orchestration ability: can you break a problem into pieces, direct an agent across a complex codebase, verify its output, and iterate? ReturnZero's piece on coding interviews in the AI age describes the same trajectory.

If that's right, then the skills interviews are converging toward look a lot like what product managers and tech leads have always needed: understanding what to build, communicating it clearly, and knowing when the output you got is not the output you needed. The uncomfortable implication is that companies may end up hiring fewer junior engineers who code, and more junior engineers who orchestrate, before those candidates have any real track record of doing either.