The Anthropic
Applied AI interview

Read the deliverables list carefully before applying: this is the most agent-shaped FDE role among the frontier labs. Being able to talk fluently about tool schemas, sub-agent decomposition, context management and where agents fail is directly on-topic rather than a bonus. Anthropic also participates in the broader deployment-capital wave, including the $1.5B Ode venture with Blackstone announced in July 2026.⁶

Anthropic’s guidance (last updated July 2025) sorts the process by stage:⁶²

It also asks for transparency in return, and says Anthropic itself uses Claude in hiring for job descriptions, interview questions, transcription and sourcing, but does not let Claude make hiring decisions.⁶² The contrast with Distyl and Sierra, which build AI into the interview, is the useful lesson: the rule is per company and per stage, so ask. If a recruiter email does not say AI is allowed for an assessment, assume it is not.

import heapq
from collections import OrderedDict
from itertools import count

class Cache:
    def __init__(self, budget):
        self.budget = budget        # level 1: max entries; level 3: max total size
        self.used = 0
        self.d = OrderedDict()      # key -> (value, size, expires_at), least recently used first
        self.expiry = []            # level 2: heap of (expires_at, seq, key); stale rows are skipped
        self.seq = count()          # tie-breaker, so the heap never compares keys

    def _drop(self, key):
        _, size, _ = self.d.pop(key)
        self.used -= size

    def _expire(self, now):         # level 2: dead entries go before anything else is decided
        while self.expiry and self.expiry[0][0] <= now:
            exp, _, key = heapq.heappop(self.expiry)
            if key in self.d and self.d[key][2] == exp:   # skip rows a rewrite made stale
                self._drop(key)

    def get(self, key, now):
        self._expire(now)
        if key not in self.d:
            return None
        self.d.move_to_end(key)     # level 1: a read is a use
        return self.d[key][0]

    def put(self, key, value, now, ttl=None, size=1):
        self._expire(now)
        if size > self.budget:      # level 3: it can never fit, so evicting everything is wrong
            return False
        if key in self.d:
            self._drop(key)         # a rewrite replaces; it is not an insert
        while self.used + size > self.budget:
            self._drop(next(iter(self.d)))                # level 1: evict least recently used
        expires_at = None if ttl is None else now + ttl
        self.d[key] = (value, size, expires_at)
        self.used += size
        if expires_at is not None:
            heapq.heappush(self.expiry, (expires_at, next(self.seq), key))
        return True

The design survives all three because of three decisions made early: time is a parameter rather than a global, a rewrite is a replacement rather than an insert, and eviction is a loop against a byte budget from the start. Cost: get and non-evicting put are O(1) amortised; each expiry costs O(log n) once, and the heap skips rows that a rewrite made stale. Say aloud what you would change for threads (one lock, since a read mutates recency) and for scale (shard by key).

You are not asked to recite policy. You are asked to show you have thought about deployment risk, so your answers should be able to cite the real documents accurately. Four are worth an hour each.

n is live entries; h is heap rows, which includes stale rows that rewrites and evictions leave behind.

The alternatives are worse in a way worth naming. Expiring only when an entry is read is O(1), but dead entries then keep their slots, which is the level 2 bug. Scanning every entry for expiry on each call is correct but O(n) per call. The lazy-deletion heap is the middle path, and its price is the stale-row memory in the last row.

• Reading the clock inside the class

  Calling time.time() in get makes every TTL test depend on timing, and level 2 is graded by tests. Take now as a parameter from level 1, even before anything expires.

• Evicting before expiring

  If the eviction loop runs first, it can throw out a live entry to make room while an expired one still holds its slot. Call _expire(now) at the top of both get and put.

• Counting a rewrite as an insert

  Writing an existing key without dropping it first adds its size to used twice. The cache then evicts entries it did not need to, and the drift grows with every rewrite.

• Evicting before the oversize check

  An item larger than the whole budget will never fit. Check that first. Otherwise the loop empties the cache trying to make room, and then rejects the item anyway.

• Deleting stale heap rows eagerly

  Finding and removing a key’s old row from a heap is O(h). Leave it, and skip it when it is popped by checking that the stored expiry still matches. That is what self.d[key][2] == exp does.