Google's AI-Assisted Coding Interview: Catch the Cached 503 the Model Will Ship

Google's 2026 AI-assisted coding interview does not grade a green test run. The new code-comprehension round scores whether you reject a patch that compiles. I planted a sticky 503 in a promise cache. The model's first fix still shipped the outage.

I have not sat the Google pilot. I'm going off Business Insider's May 7 reporting and Google's own April 22 Cloud Next note. The drill below is what I would run the night before a sanctioned AI-assisted loop, not a stealth overlay for a round that still bans tools.

What does Google's AI-assisted coding interview actually score?

Business Insider reviewed an internal document and got a Google spokesperson on the record. Starting in the second half of 2026, junior and mid-level software roles on selected US teams (Cloud, plus platforms and devices) get an approved assistant during a code comprehension round. The assistant in the pilot is Gemini. Candidates are expected to read, debug, and optimize an existing codebase. Interviewers score "AI fluency": prompt engineering, output validation, and debugging.

Brian Ong, Google's VP of recruiting, told BI the pilot exists "to be more reflective of how our teams are operating in the AI era."

That maps to a number Google already published. On April 22, 2026, Sundar Pichai wrote that 75% of all new code at Google is now AI-generated and approved by engineers, up from 50% last fall. If three quarters of the diff is model-authored, the interview that still asks you to invert a binary tree from a blank buffer is testing a job that is shrinking.

The document's phrase is "human-led, AI-assisted." You own the hypothesis. Gemini types. You decide whether the types were allowed to land.

This is not unique to Google. CoderPad's October 30, 2025 writeup of Meta's pilot quotes Meta recruiting saying it is not cheating, it is how the job is evolving. BI also names Canva and Cognition as companies that already let candidates use AI in technical interviews. Google search autocomplete for ai assisted coding interview currently suggests Meta, Microsoft, Canva, prep, mock, and reddit as follow-on queries. People are searching the format by name.

If your loop does not say AI is allowed, none of this is permission to sneak a second window onto a shared screen. The sanctioned round and the stealth overlay are opposite products. Mixing them up is how people get offers pulled.

Why does caching the in-flight promise look correct?

Here is the kind of 40-line module I would expect in a code-comprehension pad. It looks like a reasonable answer to "don't stampede the origin."

const cache = new Map();

async function fetchJsonCached(url, fetcher) {
  if (cache.has(url)) return cache.get(url);

  const pending = fetcher(url).then(async (res) => {
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return res.json();
  });

  cache.set(url, pending);
  return pending;
}

Two parallel /user reads hit fetcher once. That part is right. The bug is the rejected promise staying in the Map. A single 503 becomes the answer forever.

I asked a model to "fix the cache so a 503 does not break later requests." The first patch looked like this:

async function fetchJsonCached(url, fetcher) {
  try {
    if (cache.has(url)) return cache.get(url);
    const pending = fetcher(url).then((res) => res.json());
    cache.set(url, pending);
    return pending;
  } catch {
    return { error: true };
  }
}

Three mistakes, all the kind that still compile:

1. The try/catch does not wrap the awaited promise, so it never sees the 503.
2. res.ok is gone, so a 503 body gets parsed as success JSON.
3. The 503 payload is still sticky in the Map. The next call never reaches the network.

That is the failure mode the round is built to catch. The model optimized for "don't throw." The interviewer is scoring "don't poison the cache."

How do you prove the 503 is still sticky?

Do not argue with the model. Replay the outage.

function sequenceFetcher(responses) {
  let i = 0;
  let calls = 0;
  const fetcher = async () => {
    calls += 1;
    const next = responses[Math.min(i, responses.length - 1)];
    i += 1;
    return next;
  };
  return { fetcher, getCalls: () => calls };
}

function jsonRes(status, body) {
  return {
    ok: status >= 200 && status < 300,
    status,
    json: async () => body,
  };
}

Contract 1, buggy module: first call 503, second call should have been 200.

const seq = sequenceFetcher([
  jsonRes(503, { error: "upstream" }),
  jsonRes(200, { id: 7 }),
]);

await fetchJsonCached("/user", seq.fetcher); // throws HTTP 503
await fetchJsonCached("/user", seq.fetcher); // throws HTTP 503 again
seq.getCalls(); // 1. The origin never got a second chance.

Contract 2, the model's patch: even worse, because it returns { error: "upstream" } as if it were a user record. getCalls() is still 1.

The actual one-line repair is not a retry library. Delete the entry when the promise rejects, then let the next caller start a new in-flight promise.

const pending = fetcher(url)
  .then(async (res) => {
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return res.json();
  })
  .catch((err) => {
    cache.delete(url);
    throw err;
  });

cache.set(url, pending);
return pending;

Contract 3, after the delete: first call still throws 503. Second call returns { id: 7 }. getCalls() is 2.

Contract 4, still required: two parallel first calls coalesce. getCalls() stays 1 on a 200. You are not allowed to "fix" the 503 by removing in-flight dedupe. Interviewers notice when you swing from one bug to the stampede.

I ran those four plus the model's sticky-body case as a local Node script, no dependencies, node:assert/strict. Five contracts, all green on the delete-on-reject version.

What should you say out loud while Gemini is typing?

The round is 60 minutes of shared editing. Silence while you wait on a stream is the other way to fail. Narrate the contract before you accept the diff.

I would say, roughly:

I would cache the in-flight promise so two mounts don't double-fetch. I would not cache a rejection. If Gemini's patch drops res.ok or wraps this in an empty catch, I want a replay: 503 then 200. If the second call never hits the fetcher, we reject the diff.

That speech is the score. The code is evidence.

A few other tells I would look for in whatever module they hand you, same 10-minute budget:

Smell in the model's patch	What you replay
Empty catch / return null	The error path now looks like success
Cache written before res.ok	4xx/5xx bodies become canonical JSON
TTL added, rejection kept	You paid for expiry and still serve the 503 for the whole window
Lock around the wrong key	Concurrent URLs share one poisoned slot
Tests only cover the 200	Add the 503-then-200 case yourself

None of those need a framework. They need you to keep a failing fixture in the pad and refuse to delete it.

What this format is not

It is not "the interviewer wants to watch you prompt." Prompt quality is one of three bullets in Google's fluency rubric, sitting next to output validation and debugging. A candidate who pastes the whole file into Gemini and then reads the answer aloud is doing the opposite of "human-led."

It is also not a license for every company. Meta's CoderPad pilot is opt-in and still rolling. Google's is a 2026 pilot on selected US teams. If the scheduler, the recruiter, or the pad header does not say an assistant is in the environment, assume it is not.

The prep that transfers across both the Google comprehension round and Meta's AI-enabled pad is the same muscle: take an unfamiliar repo, keep a failing fixture, and treat the model as a junior who ships the first compile.

I use aceround.app — AI interview assistant when the next round is verbal (system design, "walk me through this diff") and I need to rehearse the explanation under interruption. It does not replace the Node replay above. If you cannot show the 503-then-200 contract in the pad, the spoken version will not save you.

FAQ

Does Google let every candidate use Gemini in the coding round?

No. BI describes a second-half 2026 pilot for junior and mid-level roles on selected US teams, with Gemini as the approved assistant. Do not assume your loop is in that cohort until someone says so.

If the tests pass after I accept Gemini's patch, am I done?

Not if the tests never sent a 503. Add that case. A green suite that only covers 200 is how the sticky cache ships.

Is this the same skill as "turn the model's answer into unit tests"?

Related, different fixture. That version starts from a blank solution. This version starts from a repo that already almost works. Google's comprehension round is the second one.

Should I still practice LeetCode?

Yes, for loops that still ban AI. For loops that allow it, spend equal time reading someone else's 200-line module and listing the contracts you would refuse to drop.

---

What 503-then-200 fixture would you add to the last model patch you accepted at work?

Drafted with AI assistance, then edited. The Node contracts were run locally before publishing. Google pilot details: Business Insider, May 7, 2026. 75% figure: Pichai, April 22, 2026. Meta pilot: CoderPad, October 30, 2025.