Performing without the crutch

The vocabulary, defined once

Before the advice, here are the exact words this lesson leans on, each spelled out so nothing below is a mystery. Read these once and the rest of the page is self-explanatory.

• AI coding assistant — an editor plug-in (Copilot, Cursor, Codeium, Amazon Q) that watches what you type and writes code for you. You press Tab and a whole function appears. Useful for real work; in an interview it means the tool, not you, is producing the answer.
• Autocomplete — the lighter version of the above, built into nearly every editor. As you type col it offers collections.Counter; you accept and move on. It quietly trains you to recognize API names rather than recall them.
• Recall vs recognition. Recognition is "I'd know it if I saw it" — what autocomplete and multiple-choice tests measure. Recall is "I can produce it from a blank page" — what an interview with AI off measures. They are different skills, and only practice that withholds the prompt builds recall. This single distinction is the heart of the whole lesson.
• "From memory." Writing code with nothing in front of you but the problem — no docs, no autocomplete ghost text, no AI sidebar. The phrase appears throughout this guide; it always means "produce it, don't recognize it."
• Muscle-memory syntax. The mechanical bits your fingers should type without thought: the colon and indentation after for x in items:, the brackets of a list comprehension [f(x) for x in xs if cond], an f-string f"{name}: {score}". These are fast to relearn but embarrassing to fumble live, because fumbling them signals the AI was doing the typing.
• Standard library (stdlib). The toolbox that ships with the language — no install needed. In Python: collections (Counter, defaultdict, deque), heapq (priority queue), itertools, bisect. Interviewers expect you to reach for these by name.
• Whiteboard / CoderPad constraints. A whiteboard round is literally a marker and a wall: no Run button, no syntax checker, no copy-paste, limited space, and you cannot easily insert a line you forgot. CoderPad (and HackerRank, CodeSignal) is a shared web editor the interviewer watches in real time — often with AI features disabled and sometimes with paste blocked. Both strip away the safety nets your IDE normally provides.
• Dry-running. Tracing your code by hand on a small input — playing computer with pen and paper, writing each variable's value as it changes — to find bugs without a Run button. In an AI-off round this replaces "just run it and see."

Why companies are doing this

It helps to understand the why, because it tells you exactly what they are trying to measure — and therefore what to practice. A take-home or AI-on screen can no longer tell a strong engineer from someone who pasted the prompt into a chatbot; the two produce identical submissions. So companies moved the signal somewhere AI can't quietly stand in for the candidate:

• Restore signal. They want to see your reasoning unfold — how you decompose a problem, choose a data structure, and recover from a wrong turn. AI hides all of that.
• Stop undetectable cheating. Remote AI-on rounds were trivially gameable. Bringing the round on-site or locking down the editor removes the back channel.
• Protect domains where fluency is the job. At an HFT, latency-critical code is written and reasoned about by hand daily; they hire for raw fluency on purpose.

The practical upshot: these rounds reward visible problem-solving plus unaided fluency. That is precisely the pair of muscles a year of AI-on coding lets atrophy, and precisely what the drills below rebuild.

Amazon disqualifies. HFTs (Citadel, Jane Street, Two Sigma, HRT) keep finals onsite. Google, Apple, Microsoft, Cisco are bringing onsites back specifically to defeat AI cheating. Cursor's own coding screen forbids AI beyond autocomplete. If you've been studying with Copilot or Cursor on, your raw fluency has atrophied — these rounds will expose it.

The core templates, on the page

"Memorize 10 templates" is hard to act on if you've never seen them written down. So here are three of the highest-frequency ones, fully spelled out. The goal is not to memorize these characters — it's to internalize the shape so that, given any variation, your hand already knows the skeleton and you only fill in the problem-specific parts. Cover the code, re-derive it on paper, then check. Repeat until you can produce each in under three minutes from nothing.

Binary search — find a target in a sorted array. The two traps everyone fumbles cold: the loop condition (<=, not <) and the midpoint update (move past the checked index).

def binary_search(nums, target):
    lo, hi = 0, len(nums) - 1      # hi is the LAST valid index, inclusive
    while lo <= hi:                  # <= so a 1-element range still gets checked
        mid = (lo + hi) // 2          # integer divide; midpoint of the window
        if nums[mid] == target:
            return mid               # found it
        elif nums[mid] < target:
            lo = mid + 1             # target is to the RIGHT; skip mid
        else:
            hi = mid - 1             # target is to the LEFT; skip mid
    return -1                       # not present

BFS on a graph — shortest path in an unweighted graph, level by level. The two things to never forget: a deque (fast pop from the front) and a visited set marked when you enqueue, not when you dequeue (otherwise a node can be queued twice).

from collections import deque

def bfs(graph, start):           # graph: dict node -> list of neighbors
    seen = {start}                # set: O(1) membership test
    q = deque([start])            # deque: O(1) popleft
    order = []
    while q:
        node = q.popleft()        # front of the queue = next level out
        order.append(node)
        for nxt in graph[node]:
            if nxt not in seen:
                seen.add(nxt)     # mark on ENQUEUE to avoid duplicates
                q.append(nxt)
    return order

Sliding window — longest/shortest contiguous run satisfying a condition. Expand the right edge greedily; shrink the left edge only when the window breaks the rule.

def longest_unique(s):           # longest substring with no repeated char
    seen = set()
    left = best = 0
    for right, ch in enumerate(s):  # right edge sweeps the whole string
        while ch in seen:          # rule broken? shrink from the left
            seen.remove(s[left])
            left += 1
        seen.add(ch)
        best = max(best, right - left + 1)  # window size = right - left + 1
    return best

The remaining seven (two pointers, DFS, heap-top-k, 1-D DP, 2-D DP, union-find, topological sort) follow the same study loop: find one clean reference, write it on paper from memory, diff against the reference, repeat until cold-start fluent. Owning these ten skeletons means you almost never start a medium from a blank mind — you start from a known shape and adapt.

A plain-English on-ramp: the three-week rebuild

If "drill cold" feels vague, here is a concrete schedule you can start today. It assumes roughly an hour a day and turns the abstract advice into a routine.

• Week 1 — find the rust. Turn Copilot and autocomplete fully off. Solve one easy + one medium per day. Every single time your hand reaches for Tab or you look up a name, write that name in a gap file. By Friday you have a personalized syllabus.
• Week 2 — burn in the templates. Each morning, blank-page one of the ten templates and time it. Each afternoon, solve a problem that uses that template so the skeleton has a context. Re-review the gap file from week 1 as flashcards.
• Week 3 — simulate the room. Once on real paper (whiteboard sim), once in a plain editor with no plug-ins (CoderPad sim). 30-minute timer, narrate out loud the whole time, dry-run your solution by hand before declaring done. This is the closest thing to the actual round.

Concrete drills for unaided recall

Recall is built by retrieval, not re-reading. These four drills each force you to produce rather than recognize, which is the only thing that transfers to an AI-off room.

• Timed template retrieval. Set a 3-minute timer, pick one of the ten templates blind, write it from memory, then diff against the reference. Anything you missed goes back in the rotation. Do this daily; it's five minutes and it's the single highest-leverage drill.
• Dry-run by hand. Take a solution you wrote and trace it on paper for a tiny input — write out every variable's value as the loop runs. This rebuilds the "execute it in my head" skill that the Run button replaced, and it's exactly how you'll verify code with no Run button live.
• Blank-API quiz. List the stdlib calls you lean on (Counter, defaultdict, deque, heappush/heappop, bisect, sorted with key=). Write each signature from memory. The ones you can't are your highest-value flashcards because they're the ones autocomplete was carrying for you.
• Narrate-only run-through. Solve a medium while speaking every step aloud and writing on paper. If you can explain the plan in two sentences before coding, you've internalized it; if you can't, you were pattern-matching, not understanding.

When you blank: the recovery playbook

Blanking is normal and recoverable — interviewers care far more about how you handle it than about flawless recall. What loses points is freezing in silence. Have a fixed sequence so you never have to improvise under stress:

• 1. Say it out loud. "I'm blanking on the exact heapq signature — let me note the intent and come back." Naming the gap turns an awkward silence into visible, calm problem-solving.
• 2. Comment the intent, keep moving. Write # push (priority, item) onto a min-heap and continue the algorithm. The interviewer is evaluating your approach, not your memory of an argument order.
• 3. Derive from a neighbor you do know. Forget Counter? Build it with a defaultdict(int) and a loop. Forget bisect? You know binary search — write it. A correct, slightly verbose version beats a stalled elegant one.
• 4. Fall back to a brute force, then optimize. If the whole approach won't come, state and code the obvious O(n²), get something working, then discuss how to improve. Working-then-better is a strong arc; stuck-at-zero is not.
• 5. Fix syntax in a final pass. Reserve the last couple of minutes to clean up the bits you flagged. Saying "let me tidy the signature I left as a comment" shows discipline.

Pitfalls that quietly cost offers

• Practicing with autocomplete "just for speed." The most common self-sabotage. If autocomplete is on while you practice, you are training recognition and measuring nothing about recall. Off means off — for the whole practice block, not just the hard parts.
• Memorizing solutions instead of patterns. Cramming 200 specific problems doesn't survive a small twist. Owning ten templates does. Study the shape, not the answer key.
• Never coding on paper until the day-of. Whiteboards punish poor layout — you run out of room, can't insert a forgotten line, can't paste. Practice the physical medium so the constraints aren't a surprise.
• Silent coding. In a watched CoderPad or a whiteboard, silence reads as "stuck." Narration is half the signal; if you only practice typing quietly, you'll go quiet exactly when you most need to talk.
• Skipping the dry-run. With no Run button, untested code is a gamble. Always trace one small example by hand before saying "done" — catching your own off-by-one is a strong signal.
• Assuming the policy. "They didn't say no AI" is not permission. For in-person and HFT rounds, default to off and confirm in writing.
• Hidden cheating tools. Cluely, Interview Coder, and the like got people caught in 2025 — rescinded offers, school discipline. The detection arms race favors the detector. The honest path is also the only durable one.