Google replaced one traditional coding round with a Code Comprehension round in its May 2026 pilot. Instead of solving a LeetCode-style algorithm from scratch, you receive a 200-500 line unfamiliar codebase in a CoderPad environment, and you have 60 minutes to read it, find bugs, discuss design decisions, and suggest improvements, all while using Google's own Gemini as an AI assistant. If you have been practicing only algorithmic problem-solving, this round will catch you off guard. Here is exactly what the round tests, why it exists, and how to build the skills it requires before your interview day.
If you want to run a full practice session with real-time coaching as you read and explain code, AI Mock Interview lets you rehearse the narration and code-reading patterns this round rewards.
What the Code Comprehension Round Actually Is
Google's Code Comprehension round places you inside a multi-file production-style codebase and asks you to navigate it with Gemini available in a side panel. The session runs 60 minutes and moves through three distinct phases: bug identification and fixing, core feature implementation within the existing architecture, and performance optimization. You do not start with a blank editor. You start with working code that has intentional flaws and an unfamiliar structure.
The format was first reported by Business Insider in May 2026 and confirmed by Brian Ong, Google's VP of Recruiting, who described the change as updating the process "to be more reflective of how our teams are operating in the AI era." The driver behind the change is concrete: Sundar Pichai disclosed in April 2026 that 75% of all new code at Google is now AI-generated and reviewed by engineers, up from 50% six months earlier. Testing whether candidates can write algorithms by hand no longer reflects the actual job. Reading, debugging, and improving AI-generated code does.
The round is being piloted for junior and mid-level software engineering roles (L3 and L4) starting with Google Cloud and the Platforms and Devices teams in the United States. The full transition across all teams is expected to take 12 to 18 months. Candidates in affected loops encounter this round alongside one remaining traditional coding round, not instead of all coding rounds.
What the Round Evaluates (and Why It Is Not Just About Debugging)
The Code Comprehension round scores three distinct competencies: code reading ability, classical debugging skill, and AI fluency. Each is distinct, and candidates who excel at one without the others will struggle.
Code reading ability: Following execution flow through unfamiliar code quickly. You need to answer questions like "What does this function return when the input list is empty?" or "What is the purpose of this class?" without having written the code yourself and without being given time to run it. This is the skill most LeetCode-heavy candidates lack because practicing on LeetCode means you always wrote the code yourself.
Classical debugging skill: Forming a hypothesis about what is wrong before you start changing anything. Interviewers watch whether you read the error trace and reason about it, or whether you immediately prompt Gemini and accept whatever it suggests. A candidate who immediately says "let me ask Gemini to find the bug" without first forming their own hypothesis is demonstrating that they cannot debug independently, which is a signal interviewers will note negatively.
AI fluency: How effectively you use Gemini as a tool. This includes writing precise prompts ("Find all places in this file where the mutex is acquired but not released" is a good prompt; "fix the bugs" is not), critically reading what Gemini returns, identifying when Gemini is wrong or incomplete, and integrating its output into your own reasoning rather than copy-pasting it blindly. Candidates who over-rely on AI without understanding the output it produces have received negative feedback in early pilot rounds.
The internal document describing the format calls it "human-led, AI-assisted." That phrasing is the interviewer's evaluation rubric in two words: you are in charge, Gemini is a tool.
Technical Deep Dive: Analyzing a Real Interview Scenario (Token Bucket Rate Limiter)
To see what this looks like in practice, consider a common code comprehension snippet candidates encounter: a functional yet flawed implementation of a Token Bucket Rate Limiter.
Python
import time
class TokenBucketRateLimiter:
def __init__(self, capacity, fill_rate):
self.capacity = capacity
self.fill_rate = fill_rate # tokens per second
self.tokens = capacity
self.last_fill = time.time()
def allow_request(self, tokens_requested=1):
now = time.time()
elapsed = now - self.last_fill
# Bug 1: Floating point addition without lock or thread safety
self.tokens += elapsed * self.fill_rate
# Bug 2: Tokens can grow infinitely without a cap check here
if self.tokens > self.capacity:
self.tokens = self.capacity
self.last_fill = now
if self.tokens >= tokens_requested:
self.tokens -= tokens_requested
return True
else:
return False
Step-by-Step Candidate Evaluation & Walkthrough
High-Level Functionality Trace: Explain that this implements a Token Bucket algorithm used for rate-limiting API endpoints. State variables track maximum bucket capacity, token generation speed, available tokens, and the last fill timestamp.
Identifying Critical Bugs & Flaws:
Concurrency & Thread Safety: In a multi-threaded server environment, concurrent calls to
allow_request()create race conditions on shared states likeself.tokens.Non-Monotonic System Time:
time.time()relies on the system wall-clock time, which can drift or jump backward (via NTP adjustments), breaking internal token math.
Refactored & Production-Ready Solution: Propose clean modifications using
time.monotonic()and threading locks:
Python
import time
import threading
class ThreadSafeTokenBucketRateLimiter:
def __init__(self, capacity: float, fill_rate: float):
self.capacity = capacity
self.fill_rate = fill_rate
self.tokens = capacity
self.last_fill = time.monotonic()
self._lock = threading.Lock()
def allow_request(self, tokens_requested: float = 1.0) -> bool:
with self._lock:
now = time.monotonic()
elapsed = now - self.last_fill
self.last_fill = now
# Replenish tokens safely
self.tokens = min(self.capacity, self.tokens + elapsed * self.fill_rate)
if self.tokens >= tokens_requested:
self.tokens -= tokens_requested
return True
return False
The 60-Minute Interview Lifecycle
Unlike a traditional algorithm screen, a Code Comprehension session moves across three structured milestones:
PhaseTime BoxWhat You DoWhat the Interviewer Evaluates1. Code Exploration & Bug Finding15–20 minsRead through 200–500 lines of unfamiliar files. Map execution flow, state changes, and pinpoint hidden logic/runtime bugs.Code reading fluency, independent hypothesis formation, structured narration.2. Feature Implementation20–25 minsImplement a missing functional requirement or integrate a minor service change inside the existing architectural pattern.Code modification quality, adherence to style guidelines, integration without breaking existing tests.3. Optimization & Design Discussion15 minsReview performance bottlenecks, memory leaks, or concurrency constraints. Propose refactoring choices or architectural scalability tradeoffs.System-level thinking, architectural critique, and AI fluency (validating Gemini's suggestions).
Why This Round Blindsides Candidates Who Only Practiced LeetCode
LeetCode practice builds one specific skill: implementing algorithms on a blank slate under time pressure. The Code Comprehension round tests the opposite: understanding code you did not write, in a codebase whose architecture you have never seen, with no algorithm to implement from memory.
The failure mode for LeetCode-heavy candidates is predictable. They read an unfamiliar function and have no mental model for how to orient themselves because they have never practiced reading production code. They cannot explain what a module does without running it. They freeze when asked "why do you think the original engineer made this design choice?" because they have only ever been asked to solve problems with a defined correct answer.
Specific Codebases to Practice On
The best preparation for reading unfamiliar code is reading a lot of unfamiliar code. These three repositories provide the right level of complexity:
React source code (
[github.com/facebook/react](https://github.com/facebook/react)): Start with thepackages/react-reconcilerdirectory to practice complex state management across a large file tree.Kubernetes scheduler (
[github.com/kubernetes/kubernetes](https://github.com/kubernetes/kubernetes)): Thepkg/schedulerdirectory. Read theSchedulefunction to trace control flow involving interfaces and goroutines.SQLite source code (
[github.com/sqlite/sqlite](https://github.com/sqlite/sqlite)): Start withsrc/vdbe.cto practice reading dense state machines with high cognitive load.
Frequently Asked Questions
What is Google's Code Comprehension interview round?
Google's Code Comprehension round is a 60-minute session where candidates read an unfamiliar multi-file codebase in CoderPad, identify bugs, suggest improvements, and discuss design decisions using Gemini as an AI assistant. It replaces one traditional coding round for L3/L4 roles in select US teams.
Do I still need to practice LeetCode for Google interviews?
Yes. Google kept one traditional coding round alongside the new Code Comprehension round to continue evaluating core data structures and algorithms skills.
What does Google evaluate in the Code Comprehension round?
Google evaluates code reading ability, classical debugging skills (forming independent hypotheses before prompting AI), and AI fluency (writing precise prompts and critically validating output).