For the last ten years, preparing for a technical interview followed a simple formula: open the Blind 75 or LeetCode 150 list, lock yourself in a room for a month, silently solve problems against the clock, and then get an offer.
In 2026, this formula has become a dangerous trap for developers.
As the review Tech Interviews in the AI Era: The Rules Are Being Rewritten puts it, tech hiring has changed a lot. AI assistants (Cursor, Claude Code, GitHub Copilot) write basic algorithms and typical components in seconds, so checking whether a candidate can type code from memory in silence no longer makes sense.
We are building Skill Rally for this new format, and our main idea is simple: strong engineers with 5+ years of experience risk failing interviews not because they don't know the technology, but because they prepared for the 2021 exam and showed up for the 2026 one.
Below, we use industry data to look at how companies interview now, why experienced engineers freeze in the new rounds, and how P2P mock interviews help you practice for them.
If you look at the Google DORA and Karat reports and the engineering blogs of product companies, one thing is clear: companies now test candidates in two different ways. Neither of them rewards people who are used to preparing alone.
The Australian unicorn Canva said it plainly in June 2025: “Yes, You Can Use AI in Our Interviews. In fact, we insist”. Their logic is practical: almost half of Canva's frontend and backend engineers use AI tools every day, so banning them in interviews means testing skills in an artificial vacuum. At Coinbase, AI wrote only 5.7% of merged code in early 2025 and more than half by the end of the year. Today almost all new code there is written by AI and reviewed by people, and the company rebuilt its interviews around this.
In these interviews, you are expected to open an IDE with an AI assistant. In return, the task is much harder:
Google is more careful. CEO Sundar Pichai said the company will keep at least one in-person interview round to check fundamentals without any help. AI is allowed only in a limited 2026 pilot for some US teams: candidates get Gemini in a new code comprehension round, where they read, debug and explain existing code instead of writing it from scratch. Overall, interviews are moving towards Live Debugging and System Design.
Here you explain every line out loud, look for a vulnerability in an existing pull request, or design a fault-tolerant system while the interviewer keeps asking follow-up questions.
How the evaluation changed:
So why do experienced developers fail the new rounds?
In Karat's article on the AI engineering skills gap (January 2026), one sign of an engineer who still lacks AI-era skills is: "Freeze when AI-generated solutions break".
According to the Google DORA 2025 report, about 90% of tech professionals already use AI at work. We think this is the trap: AI speeds up boilerplate, but it also creates an illusion of skill. When a developer spends months in a "write a prompt → accept the autocomplete → run it" loop, their skill of live debugging under pressure gets weaker.
Imagine a typical section for a Frontend or Fullstack engineer in 2026. You get a search component with autocomplete (in the task's backstory, a junior developer generated it with an LLM), and the interviewer says: "Users complain that when they type fast, the results sometimes still show data from an old request. Find the problem and fix it."
Here is the piece of code the candidate sees:
// Example task for a Code Review / Debugging round
import { useState, useEffect } from 'react';
export function UserSearch({ query }: { query: string }) {
const [results, setResults] = useState<string[]>([]);
const [loading, setLoading] = useState(false);
useEffect(() => {
if (!query.trim()) {
setResults([]);
return;
}
setLoading(true);
fetch(`/api/users?q=${encodeURIComponent(query)}`)
.then((res) => res.json())
.then((data) => {
// The bug is here: what happens if the request for "re" answers AFTER the request for "react"?
setResults(data.users);
setLoading(false);
});
}, [query]);
return (
<div>
{loading && <span>Loading...</span>}
<ul>
{results.map((user, idx) => (
<li key={idx}>{user}</li> // Second red flag: key={idx} for a dynamic list
))}
</ul>
</div>
);
}
AI can "fix" this code in seconds if you ask. But the interviewer does not care about the fixed file. They care about how you find and explain the problems. A strong candidate names them out loud, one by one:
loading stays true forever, and res.json() can throw an exception that nobody catches.loading. If the user clears the field while a request is still running, the loading indicator never goes away.key={idx}. When the list changes, React compares items by index. In a dynamic list, this causes extra re-renders and bugs with the state inside the items. You need a stable key, for example the user's id.One way to fix it:
useEffect(() => {
if (!query.trim()) {
setResults([]);
setLoading(false);
return;
}
const controller = new AbortController();
setLoading(true);
fetch(`/api/users?q=${encodeURIComponent(query)}`, { signal: controller.signal })
.then((res) => {
if (!res.ok) throw new Error(`HTTP ${res.status}`);
return res.json();
})
.then((data: { users: string[] }) => setResults(data.users))
.catch((error) => {
if (error.name !== 'AbortError') setResults([]);
})
.finally(() => {
if (!controller.signal.aborted) setLoading(false);
});
// Cancel the old request as soon as query changes or the component unmounts.
return () => controller.abort();
}, [query]);
Then comes the most valuable part of the answer, the part AI will not say for you: "In a real project, I would add a 200–300 ms debounce so we don't send a request for every letter, and I would use SWR or TanStack Query, because they already solve request races, caching and retries." Trade-offs like these, said out loud, are what make a strong candidate stand out.
You can solve a task like this alone. But the interview tests something else:
null comes in?". A live interviewer does.You can only practice all of this with another person.
A P2P (peer-to-peer) mock interview is a practice interview between two developers who take turns playing the candidate and the interviewer. This is how we built Skill Rally:
To learn how the new rounds work at Meta, Google and Coinbase, read "Frontend and Backend Interviews in 2026: the New AI Round".
In 2026, an interview tests how you think more than how fast you type: how you read someone else's code, find bugs, explain trade-offs and question AI's answers. You can't build these skills alone and in silence with LeetCode. You build them in a live conversation with another engineer.
Skill Rally is launching soon. Join the waitlist to be one of the first to practice with real developers.