AI is a power tool — with a sharp edge
The interview (and the job) tests whether you use an AI coding assistant effectively and critically — not whether you can avoid it. The skill is directing it well and verifying its output, because it will confidently produce plausible-but-wrong code.
Prompt the assistant well (this is Prompt Engineering applied to code)
- Give it context — the relevant code, the error/stack trace, the expected vs actual behavior, and what you've tried. A vague "fix this" gets a vague fix.
- Ask it to explain first — "walk me through what this code does and where the bug likely is" builds your understanding and surfaces its reasoning (which you can check).
- Constrain the change — "fix the root cause with the smallest change; don't refactor unrelated code."
- Iterate — feed back the new error/output; debugging with AI is a loop.
Verify everything it produces (the non-negotiable)
AI assistants hallucinate APIs, miss edge cases, fix symptoms not causes, and introduce subtle bugs. So:
- Read the diff — understand every line it changed; never merge code you don't understand.
- Run it — tests, the reproduction case, edge cases. "It compiles" ≠ "it's correct."
- Sanity-check its claims — it may invent a function or a flag that doesn't exist.
- Watch for symptom-fixes — it often makes the error go away without fixing the root cause.
Where AI misleads you
- Confidently wrong — fluent explanations of incorrect logic.
- Outdated/invented APIs — especially for newer libraries.
- Overfitting to the snippet — it fixes what it sees, missing the broader system context (state, async, config).
- Plausible-but-subtle bugs — off-by-one, wrong edge-case handling that passes a quick glance.
The mindset
You are the engineer; the AI is a fast, fallible assistant. Use it to move faster on comprehension, boilerplate, and hypotheses — but own correctness. The candidates who impress use AI heavily catch its mistakes.