The Anthropic Coding Interview

The technical screen is one CodeSignal problem with four locked levels and ninety minutes on the clock. Level one is SET, GET, and DELETE on an in-memory key-value store. The grader's unit tests are visible before you write a line, and each level unlocks only after every hidden test for the one below it turns green. Roughly 520 out of 600, with at least three of the four levels fully passing, is what advances you.

Level four bolts file compression and capacity limits onto the same store you wrote at level one, and the level-one methods still have to pass. You build a small working system, the requirements keep arriving, and the code that survives is the code you can extend without tearing it down. A version that compiles and clears the first case is the warm-up. The grading lives in everything that comes after it.

The live bank is famously small. Candidates report roughly six recurring problems, and most people walk in already knowing what they will be asked. That changes how you prepare. Breadth is not the lever, because there is barely any breadth to cover. Follow-up depth and clean execution under changing scope are what gets tested, so grinding three hundred algorithm problems is close to the wrong preparation for this loop.

The Anthropic angle

Recruiters say it on the phone before the screen even starts: practical, not LeetCode. The prompts are work-like build tasks, the kind of object-oriented code you would ship, framed as a base requirement plus follow-ups that keep landing. There is no graph trick to spot and no template to pattern-match against. The first solution that runs is the starting line. The grading starts in earnest when the interviewer adds the next constraint to the thing you just built, then the next, watching whether your design absorbs each one without a rewrite. Time pressure runs lower than a Meta or OpenAI loop and you write less total code, but every decision has to hold up when you defend it from first principles.

How the Round Runs

Most pipelines route through the CodeSignal online assessment first, a four-level "industry coding framework" problem auto-graded out of 600. Some teams swap in a sixty-minute live screen instead, where a single engineer shares a Python editor with you and the web crawler is the dominant prompt. Past the screen sits a virtual onsite of about four rounds, typically two live coding sessions plus a system design round and a values round. The counts flex by team and level, so read the grid below as the common case rather than a fixed spec. Anthropic keeps its process quiet, so treat any single number here as the shape candidates report most often, not a guarantee.

• Platform: CodeSignal, code runs. The OA and many live rounds run in CodeSignal, with Colab and Replit-style shared editors also reported. Screen-share over Google Meet, camera typically on. Your code executes against tests throughout; there is no whiteboard pseudocode.
• The OA: 4 levels, 90 min, ~520/600. One stateful build-then-extend problem. Each level unlocks only when all hidden tests for the prior level pass, and clearing at least three of the four levels is the bar. Running out of time before the last level is the common way candidates miss.
• The onsite: ~4 rounds, run it live. Roughly two one-hour coding sessions with escalating follow-ups, plus a system design round in a Google Doc and a dedicated values round. The onsite coding is harder than the screen: constraints stack faster and the expected polish is higher.
• Language: Python expected. Python is the primary language and the standard library is rewarded. Other languages have been allowed (one candidate used C#), so it is expected rather than forced. Plan around Python unless your recruiter says otherwise.

The Anthropic angle

The company that builds Claude tells you not to use Claude in the interview. Anthropic's candidate guidance is blunt: this is all you, no AI assistance unless they indicate otherwise, and take-homes carry the same rule. Anthropic also reportedly screens for code tuned to clear the visible tests rather than genuinely solve the problem. That is part of why the level-one methods still have to work after level four adds new behavior. Test-gaming shortcuts tend to break the later levels. Confirm the policy with your recruiter, then plan to work from memory in a shared editor with your camera on.

What They Actually Ask

Five clusters cover almost everything reported. The dominant one is the stateful in-memory system that anchors the CodeSignal OA. Picture a key-value database. It starts with SET and GET, grows into prefix scans, then timestamped writes that expire on a TTL (time-to-live) window, then compression and capacity tracking. The banking ledger is the same shape from a different angle: account creation and transfers first, then transaction history, top-spender rankings, and interest. Same-family variants surface as inventory systems, chat-message history, file caches, and package managers with dependency resolution. A frequency list is not something Anthropic releases, so the percentages below are estimates drawn from a small and highly repetitive bank. Read the ordering, not the decimals.

Concurrency is the theme that separates this loop from a FAANG one, and a Premium question is its single most-cited problem. You start with a correct synchronous crawl, then the load-bearing follow-up lands: make the crawl concurrent. From there the round digs into a bounded thread pool, then asyncio. The finish is a real analysis of Python's GIL, the global interpreter lock that lets only one thread run Python code at a time. You explain when threading still helps an I/O-bound crawl and when multiprocessing is the right tool instead.

How Code Is Graded

The most-repeated signal across reports is that a passing first solution is only the starting line. What gets evaluated is everything around correctness. Clean modular structure and sensible APIs. Decomposition that absorbs new constraints without a rewrite. Edge cases you handle on your own initiative, complexity choices you can defend, and how calmly you refactor when the interviewer expands the scope mid-problem. After you solve cleanly with the standard library, expect to be asked to re-implement the data structure from scratch and justify the tradeoff.

The Anthropic angle

Do the simple thing that works is one of Anthropic's seven stated values, and it doubles as how they grade code. Clean and modular beats clever and dense. The signal is whether your interfaces flex as constraints pile up. Do you handle the empty and boundary cases before anyone prompts you? Do you reach for a test to prove new behavior rather than eyeballing it? In live rounds the stack-trace problem is reported to expect you to write your own test cases, with no grader handing them over. They also weigh how you think and communicate as well as the final answer, so narrate the tradeoffs as you make them. A correct first pass buried under special cases and missing its tests can still miss the round.

How to Practice for This

The muscle this loop tests is building a small thing end to end, under time, with tests and clean structure. That is a different skill from matching a graph problem to a memorized template, and it is the reason the algorithm-grind plan transfers so poorly here. Practice by building. Implement a key-value store with timestamped versions, then bolt on TTL expiry, then on-disk serialization that survives delimiters inside the keys, then a lock for concurrent writers. Each layer should land the way the round lands it: as a new requirement on code that already works.

Then do the web crawler from a blank file: synchronous first, a thread pool second, asyncio third, and be ready to talk through the GIL without notes. Re-implement a Premium question under the hood and make it thread-safe. Take the stack-trace profiler and write your own test cases before you call it done. Run each one against a timer, make it execute, and prove the new behavior with a test you wrote rather than one you were given. The four lessons ahead are each anchored on one of these builds.

What This Section Covers

Four paid lessons follow, each one anchored on a build you implement with the follow-up gates stacked the way the round stacks them. Where a lesson rests on a base structure, the foundational version lives in the free course, so these pages stay on what is specifically Anthropic.

Common questions