Software engineering has quietly changed shape. The job used to be "write code from scratch." Increasingly it's read, debug, and improve code you didn't write — much of it AI-generated — using AI as a power tool without trusting it blindly. Google, Meta, and other top companies have redesigned their interviews around exactly this: can you comprehend an unfamiliar codebase fast, spot where an AI-powered feature is broken, and fix it correctly? This concept frames the role the rest of the track prepares you for.
Why this appears in interviews
The classic algorithm-on-a-whiteboard round is being supplemented (or replaced) by code-comprehension interviews: here's a real, unfamiliar codebase with a bug — often in an LLM-powered feature — find it and fix it, sometimes with an AI assistant available. Interviewers are testing the skills that actually predict on-the-job performance now: reading unfamiliar code methodically, reasoning about failure, and using AI tools critically. Understanding what the modern role is keeps you from preparing for the wrong interview.
The shift: from writing to reading, debugging, and directing
- Writing is cheaper; reading is the bottleneck. AI generates plausible code in seconds, so the scarce skill is evaluating it — is it correct, secure, performant, and maintainable? Engineers now spend more time reading and reviewing than typing.
- Most work is on systems you didn't build. You join a team, inherit a large codebase, and are productive to the degree you can navigate and modify it safely — not rewrite it.
- AI features are everywhere. A huge share of new product work wires an LLM into an existing app: a search that now uses RAGRAGRetrieval-Augmented Generation — gives LLMs access to external knowledge by retrieving relevant documents before generating a response.Learn more →, a support flow that now calls an agent. These fail in new ways (nondeterminism, hallucination, prompt bugs) that classic SWE training doesn't cover — which is why this track exists.
- AI is a tool you direct, not an oracle. The AI-era engineer prompts well, then validates — AI-generated code is a confident draft that's frequently subtly wrong. Trusting it blindly is the defining junior mistake.
The mental model: you are the senior reviewer of an eager junior
Treat the AI like a fast, tireless, occasionally-wrong junior engineer. It produces a lot quickly; your job is to specify clearly, review critically, and own correctness. You catch the off-by-one, the missing error case, the security hole, the plausible-but-wrong API call. The value you add isn't typing speed — it's judgment: knowing what to ask for, what to accept, and what to reject.
The AI-era failure surface (why classic SWE isn't enough)
When your feature calls an LLM, you inherit failure modes deterministic software doesn't have, and the whole rest of this track drills them:
- Nondeterminism — the same input can produce different output; a passing test once proves little.
- Silent wrongness — the model returns a confident, well-formatted, wrong answer with a 200 status; nothing throws.
- Prompt/config bugs — the feature is broken not by a code bug but by a bad prompt, a wrong temperature, or a mismatched model.
- Retrieval bugs — a RAGRAGRetrieval-Augmented Generation — gives LLMs access to external knowledge by retrieving relevant documents before generating a response.Learn more → feature returns the wrong documents (often an embeddingEmbeddingNumerical representation of text capturing semantic meaning. Similar texts produce similar vectors, enabling similarity search.Learn more → mismatch), so answers are wrong even though the "code works."
- Integration/format bugs — malformed JSON from the model, truncated output, tool-call errors.
Reading and debugging these requires understanding both classic software and how LLM features work — the union that defines the role.
What you actually need to be good at
- Read unfamiliar code fast — build a mental model of a codebase you've never seen (next concept).
- Debug methodically — form hypotheses from evidence, including in AI-powered code (the debugging concepts).
- Understand how LLM features fail — nondeterminism, prompts, retrieval, structured output, agentsAgent systemsAI systems that take actions, use tools, and complete multi-step tasks by reasoning through a sequence of decisions. (Stage 2–3).
- Use AI tools critically — prompt for help, then validate; never ship unread AI code.
- Know an AI feature works — evaluation and observability, because "it worked when I tried it" isn't proof (Stage 4).
- Design AI features — wire an LLM into a real system with the right tradeoffs (Stage 5 capstone).
What has not changed
Fundamentals still matter — data structures, complexity, clean interfaces, testing, and systems thinking. AI raises the floor on generating code but raises the bar on judgment: you can't review what you don't understand. The best AI-era engineers are strong classical engineers who've added the AI layer and the discipline of critical validation — not people who've outsourced their thinking to a model.
Common interview mistakes
Mistake 1: Trusting AI output blindly. Accepting generated code without reading it is the fastest way to fail a code-comprehension round (and to ship bugs).
Mistake 2: Preparing only for algorithms. The modern round is often "debug this unfamiliar AI-powered codebase," not "invert a binary tree."
Mistake 3: Treating LLM features like deterministic code. Assuming a passing manual test means it works, and ignoring nondeterminism and silent wrongness.
Mistake 4: Rewriting instead of reading. Reaching to rebuild an unfamiliar system rather than understanding and surgically fixing it.
Key vocabulary
- Code comprehension — Reading and understanding unfamiliar code well enough to modify it safely; the core modern interview.
- AI as a tool, not an oracle — Using AI to draft, then validating critically; owning correctness yourself.
- Silent wrongness — An AI feature returning a confident, well-formed, incorrect result with no error.
- Nondeterminism — Same input, potentially different output; why testing LLM features is statistical, not conclusive.
- AI-era failure surface — Prompt/config, retrieval, structured-output, and agent-loop failures on top of classic bugs.