What it is, in one paragraph
An AI coding interview (companies call it AI-enabled, AI-assisted or AI-mandatory) is an engineering exercise, usually 60 to 90 minutes, in which a candidate works on a real, multi-file codebase with an AI assistant in the same environment. The candidate reads, modifies, and extends code that someone else wrote, with the assistant available to brainstorm, draft, and explain. The interviewer is grading code quality, judgment, and verification — not prompt engineering, and not algorithm recall. Tests usually gate progression between stages. Companies vary on the specifics (sandboxed environment vs BYO IDE, AI as autonomous coder vs read-only advisor), but the skeleton is consistent.
A short, opinionated history
We have to back up. The reason this format feels so obviously correct now is that the formats it replaces were doing such a poor job of measuring engineering. Three eras, with one job for each:
The whiteboard era (~2005–2015)
You walked into a conference room. There was a marker. You wrote pseudo-code on a wall while a senior engineer watched. Maybe you got to use a corner of a Google Doc. The format optimized for theater: it tested how composed you were under unfamiliar pressure, plus your ability to invert a binary tree in front of a stranger. There is no job that involves doing this. Everyone knew. The industry kept doing it because the alternatives were expensive.
The LeetCode era (~2015–2025)
Whiteboards moved into a browser. CoderPad and HackerRank and the rest gave you syntax highlighting and a runtime but kept the underlying structure: a single function, no codebase, no collaboration, no tools beyond what the sandbox vendor included. LeetCode the platform turned this format into a study system. You memorized 25 patterns and 400 problems and you got better at the specific test the test was testing.
This was a real upgrade over whiteboards. It was also still an artificial test. Engineers who'd grinded through it would arrive on the job and discover that the actual work — reading existing code, working with a team's conventions, integrating tools, deciding what to build — had been measured by approximately none of their interview prep.
The AI-assisted era (2025–present)
Canva moved first, in June 2025, replacing its CS-fundamentals screen with an AI-mandatory product challenge. Meta made it the industry's question four months later. Its internal pitch to candidates was blunt:
"Meta is developing a new type of coding interview in which candidates have access to an AI assistant. This is more representative of the developer environment that our future employees will work in, and also makes LLM-based cheating less effective."— Internal Meta announcement, October 2025
Two motivations, both real. First: their engineers ship with Cursor, Claude Code, and Copilot every day, so the no-AI sandbox had stopped predicting on-the-job performance. Second: an interview that expects AI use is harder to game with hidden tools. The format launched as a 60-minute three-phase project replacing one of two onsite coding rounds. Within a year, Google, Amazon, Stripe, Shopify, LinkedIn, and others had shipped their own variants. The era is here.
Which companies run AI coding interviews in 2026
By October 2026 the format is in active use at Meta, Google, Amazon, Stripe, Coinbase, DoorDash, Instacart, Pinterest, Shopify, LinkedIn, Rippling, Canva, Datadog, Uber, Ramp, Snowflake, Bloomberg, TikTok, Wayfair and Eightfold, and OpenAI has moved its prompts toward production-shaped work. They do not run it the same way. The assistant, the environment and what gets graded differ at each one. What each company runs, with a page per company, is in AI coding interviews by company. The rest of this guide is about what every version has in common.
What good looks like in the room
Variations matter, but here's the common skeleton you can prep against regardless of company:
- Open codebase orientation. First two-to-five minutes — read the layout, identify what's where, find the relevant entry points. The interviewer is watching your reading speed and the questions you ask.
- An entry task, often a bug. Something concrete and small that lets you demonstrate you can find and change something in this codebase. Meta uses this as its phase 1 explicitly. Other companies fold it into the opening few minutes.
- The main build. 25–40 minutes. You implement a feature or extend a system. The AI is your collaborator for boilerplate, alternative approaches, and explaining unfamiliar APIs. You're making the design calls. You're reading every line.
- Escalation. The interviewer adds constraints — bigger inputs, concurrency, edge cases, productionization. This is where staff-level versus senior-level signal lives. Most candidates run out of time here.
- Verification throughout. Tests gate stages. You're expected to write or run them. AI output that you didn't verify and didn't catch is the most common failure mode.
The four skills it actually grades
1. Reading code you didn't write
This is the one nobody studies for. Companies have been grading it implicitly for years (every senior loop includes "walk me through this code") but the AI-assisted format makes it the entry bar. You will be dropped into 500–2000 lines of someone else's code and expected to navigate it under time pressure. If your prep has been single-function LeetCode, this is a wall.
What good looks like: ten seconds in the file tree, a mental model of the layout. You ask the AI specific questions ("read parser.py, where does it handle the buffer?"). You don't ask vague ones ("explain this codebase"). You skim with intent — comments, function signatures, type definitions — instead of reading line by line.
2. Directing an AI assistant
The new skill in the room. Most candidates have used AI coding tools casually; few have practiced using them under interview pressure with someone watching. The gap between casual use and fluent direction is wider than most candidates realize.
Fluent direction is concrete. You give the AI specific tasks ("implement the carry-over buffer in parser.py such that records split across iterations of the async for survive") instead of broad ones. You name files. You name lines. You paste error output back and tell it which line errored. You decline its suggestions without hesitation when they're wrong for your context. You don't apologize to it. You don't have a conversation with it. You direct it.
3. Verifying AI output
The single highest-leverage skill, by candidate-report consensus. Meta's evaluation rubric (per leaked guidance) is explicit:
"Should use AI, but need to show you understand the code. Explain the output. Test before using. Don't prompt your way out of it."— Meta evaluation criteria, internal
Verification, in the room: every block of AI-generated code gets read line-by-line before you accept it. You write a test for the specific claim it's making. When it tells you "this handles the partial-record case," you construct an input that would distinguish a correct implementation from a wrong one and run it. The candidates who fail aren't the ones who can't prompt — they're the ones who paste in code without reading it.
4. Production-shape engineering judgment
Concurrency. Observability. Failure modes. Memory budgets. Scale. The escalation phase of every AI-assisted interview lives here, and it's where staff-level signal becomes legible. What does your solution do when ten thousand callers hit it simultaneously? What logs would you add? What's the rollout strategy? At what input size does it fall over, and what fixes that?
LinkedIn pushes hardest on this dimension. Meta and Shopify weave it into phase three of their respective formats. You can't fake your way through this section with an AI — you have to actually have opinions about production systems.
Why this is harder than what came before
The most common candidate misconception in 2026 is that the AI in the room makes the bar lower. It moves up. Three reasons:
You're producing more code, in less time, in a harder format. Meta's calibration is roughly 120 lines of working code in 60 minutes. That's about three times a typical LeetCode solution. The 60-minute clock didn't move.
You're being graded on skills LeetCode never measured. Reading existing code, navigating a real project structure, integrating with someone else's conventions. None of these were on the LeetCode test. Adding them to the rubric raises the bar by definition.
The AI doesn't reduce the work — it shifts it.What used to be "type 30 lines of an algorithm" becomes "describe the algorithm precisely enough that an assistant can type it, then verify what it produced is actually what you described." That's not less work. It's different work, with a higher ceiling and a more unforgiving floor.
The five biggest preparation mistakes
1. Treating it like LeetCode++
"I'll grind LeetCode AND practice with Copilot." No, actually — you'll spend most of your time on a skill that's no longer the bar, and a fraction on the new skills. Reverse the ratio. The right ratio is roughly 10% classical algorithms (for the no-AI round most companies still keep) and 90% codebase-shaped practice.
2. Overusing the AI in practice
If you let the model write everything during prep, you never build the verification reflex, the architectural judgment, or the muscle memory of writing fast yourself. Practice problems where you write the architecture and the AI writes the boilerplate. Not the other way around.
3. Practicing on toy snippets, not codebases
One-file problems are not representative of the format. If your prep environment doesn't have a file tree with three or more files in it, you're optimizing for the wrong terrain. Read open-source repos. Make tiny contributions. Get comfortable opening someone else's project and finding what matters.
4. Skipping verification practice
Every AI suggestion you accept during prep should be read line-by-line. Every line. If you're not doing this now, you won't do it under interview pressure either — and that's the failure mode the interviewer is most calibrated to catch.
5. Ignoring concurrency and production engineering
This was a side topic in 2020. It's the main course in 2026. Locks, mutexes, async patterns, retry strategies, observability — the escalation phase needs all of these and your LeetCode prep gave you none.
What to actually study
We'll be opinionated about a study plan. If you have eight weeks before your loop, here's what we'd do:
Weeks 1–2: get fluent with one assistant
Pick one — Cursor, Claude Code, Codex CLI — and live in it. Build a real project from scratch. Not a tutorial. Something with at least four files, a test runner, and a meaningful feature. Direct the assistant constantly. Develop opinions about when it helps and when it slows you down.
Weeks 3–5: codebase practice
Multi-stage problems, real repos, every day. Read code you didn't write. Make small modifications. Practice the workflow tour: in 90 seconds, can you describe what this repo is doing? Tools like Nyrion exist for exactly this loop, but if you'd rather not use a platform, take an open-source project and assign yourself debugging tasks from its issue tracker.
Week 6: production engineering specifically
Concurrency primitives in your target language. Observability patterns. Retry semantics. Caching strategies and their failure modes. Read a few high-quality engineering blog posts a day (Stripe's, Anthropic's, Shopify's). Build muscle for the escalation conversation.
Week 7: classical algorithms refresher
One week. Fifty canonical patterns. The no-AI coding round at most companies still maps to LeetCode-style; don't drop it entirely. But one week is the right allocation — you're refreshing, not learning from scratch.
Week 8: full mocks
60-minute mocks against the format you'll actually face. If your loop includes Meta, your mocks are 60-minute three-phase projects. Time them. Record yourself. Re-watch the parts where you wasted time.
Five myths, briefly
"It's easier because the AI helps you."
No. The bar moved up. You're producing more code, reading unfamiliar code, and being graded on verification. The AI helps you go faster; the interviewer calibrated for that and asked for more.
"I just need to learn prompt engineering."
No. You're not graded on prompts. You're graded on judgment, code quality, and verification. Prompt skill is a side effect of practicing, not a thing to optimize for in isolation.
"I don't need LeetCode anymore."
Mostly true. You need 50 canonical patterns for the no-AI round most companies still keep. You don't need problem #423 on hard mode.
"All the companies do it the same way."
They don't. Meta integrates the AI tightly into a sandbox; Shopify lets you bring your own; LinkedIn keeps the AI read-only. Prep against the specific company in your loop.
"The AI does the work for you."
No. The AI types faster than you, knows more APIs than you, and has worse judgment than you about your specific codebase. It's a powerful junior pair-programmer, not a replacement for your reasoning.
Frequently asked, briefly answered
What is an AI coding interview?
A coding round in which you are allowed, and usually expected, to use an AI assistant while you work. Instead of one algorithm puzzle in a blank editor, you get an existing multi-file codebase and a task in parts: fix a bug, build a feature, then handle what the interviewer adds. You are graded on how you read the code, direct the assistant, check what it writes and make the engineering calls. Companies call it AI-enabled, AI-assisted, AI-mandatory or, at DoorDash, AI Code Craft.
Is an AI coding interview one where an AI interviews you?
Usually not, though the name is used for both. Some hiring platforms use it for an automated screen in which an AI asks the questions and scores the answers. At the companies in this guide it means you use an AI assistant to do the work while an interviewer, or an assessment's tests, judge how you used it. Instacart's assessment combines the two: an AI product manager holds back the spec while you build with Claude.
Which AI tool will I get?
It depends on the company. Shopify and DoorDash let you bring your own IDE and assistant. Meta builds the assistant into CoderPad and Stripe into HackerRank, Instacart gives you Claude on CodeSignal, Google gives you Gemini, and Amazon's online assessment has its own assistant built in. LinkedIn's assistant sits in a chat panel and cannot edit your code. Whichever one you get, the same things are graded: read what it writes, test it, and say why.
What questions do AI-assisted coding interviews ask?
Small but realistic systems, built or fixed in parts, rather than puzzles. Reported tasks include a refund workflow engine for late orders at DoorDash, a transaction rule parser at Stripe, a buggy repository at Amazon, a library lending app at Instacart, and an existing service with a bug, a timeout and a pull request to review at Coinbase. Each part raises the bar: bigger inputs, a new requirement, a failure to handle.
How do I prepare for an AI-assisted coding interview?
Get fluent with one assistant on a real project, then practice on multi-file codebases you did not write, in timed stages. Read every line the assistant gives you and test its claims before you accept them, because unverified AI output is the most common way to fail. Keep a week for about fifty classical patterns, since most loops still have a no-AI round, and finish with full timed mocks in your target company's format.
Where this format goes next
We have three predictions, in increasing confidence:
The bar keeps rising. 120 lines today is calibrated for current-gen AI assistants. As they get faster, the line count goes up. The 60-minute clock stays.
Problems shift toward production-shape. Today's phase-three optimizations are still recognizable as algorithm problems with bigger inputs. Tomorrow's will look like real engineering: streaming aggregations, cache eviction strategies, schema migrations under load, small services rather than tutorial repos.
The line between "coding" and "system design" rounds collapses. Within two to three years, expect prompts of the form "implement a recommender system on terabytes of input data" — with a small dataset, real tests, and an AI assistant — replacing what we today call a system design round. Once the assistant types, the bottleneck stops being keyboard speed. It becomes architectural judgment under time pressure. That's the skill the interview should have been measuring all along.
Where to go from here
If you're prepping for a specific company, its guide is linked in the list of companies above.
If you want the numbers, which companies run the round, who picks the AI, and what 438 people did in practice: the state of AI coding interviews, 2026.
If you're trying to decide whether to keep grinding LeetCode:
- Nyrion vs LeetCode — our case for why the grind doesn't translate.
If you're ready to practice the format directly: