AI Careers

The Anthropic Software Engineer Interview, Round by Round

A four-level coding assessment where level one decides whether you finish level four, a hiring-manager deep dive, an onsite with an LLM practical round, a values round with a real bar - and an explicit policy on when you may use Claude. What candidates report and how to prepare.

The stages

Candidate reports describe a consistent outline: a recruiter call, an online coding assessment, a hiring-manager conversation, an onsite loop of four or five rounds, then reference checks and team matching. End to end it is often reported at around a month to several months, with most of the variance in the last stage. As with any company, details vary by team and change over time - treat this as a map, not a contract.

Two things are distinctive. The online assessment is a single evolving problem rather than a set of unrelated puzzles, and the loop includes a round where you work directly with a language model. Both reward the same skill: building something small that stays easy to change.

The online assessment: one problem, four levels

The assessment is commonly described as a ninety-minute CodeSignal session with one problem split into four levels. Each level comes with unit tests and builds on the code you already wrote. Reported problem families include an in-memory key-value store that later needs filtered scans, expiry and backup; a banking system; a file cache with constraints; and a simulated cloud database.

Roughly twenty minutes per level sounds generous until level three asks for time-based expiry and your level-one design stored bare values in a dict. The single most important decision is made in the first ten minutes: model the data so that it can carry metadata later, pass timestamps explicitly instead of reading the clock, and keep each operation in its own small function.

Candidates also report that a high score is necessary but not sufficient, and that code engineered to pass the visible tests rather than solve the problem is noticed. Write the solution you would want a colleague to extend. The next post in this series works through a full four-level solution.

# Level-one design that survives level four.
# Values carry metadata from the start, and time is an argument, never a global.

from dataclasses import dataclass

@dataclass
class Entry:
    value: str
    expires_at: int | None = None     # unused until level 3 - costs nothing now

    def alive(self, now: int) -> bool:
        return self.expires_at is None or now < self.expires_at

class Store:
    def __init__(self):
        self.data: dict[str, dict[str, Entry]] = {}   # key -> field -> Entry

    def set(self, now: int, key: str, field: str, value: str) -> None:
        self.data.setdefault(key, {})[field] = Entry(value)

    def get(self, now: int, key: str, field: str) -> str | None:
        e = self.data.get(key, {}).get(field)
        return e.value if e and e.alive(now) else None

The hiring-manager conversation

This is reported as a technical conversation about your background rather than a coding round. Expect to be walked through your career step by step and then taken deep on two or three projects. The questions are about decisions: why that architecture, what the alternatives were, what you measured, what you would change.

Preparation looks like preparing a design review of your own work. For each project, know the numbers, know the trade-off you made and what it cost, and know one thing that went wrong. Interviewers in this round are listening for whether you understood the system you built or only the part you were assigned.

The onsite loop

Candidates describe four kinds of round. Live coding happens in a shared environment such as Colab or Replit, on a realistic problem with follow-ups that add scale or concurrency - one reported example parses URLs and counts domain matches, then asks for an async version. Start simple, get it working, then iterate; debugging methodically is part of what is scored.

System design is distributed systems with an LLM in it. Reported prompts include search over about a billion documents with model inference in the path, hybrid lexical and semantic search, a large indexing pipeline, and diagnosing a p95 latency spike. Bring capacity arithmetic and a clear view of where the GPU time goes.

The LLM practical round is the one most candidates have not practised. You work with a model through an API, usually in a notebook: designing prompts, chaining several calls, and using the API efficiently given token costs and rate limits. It tests whether you understand where models fail and how to engineer around that, rather than whether you can write a clever prompt.

The culture round covers alignment with the mission, long-term thinking, awareness of risk and harm, and how you handle disagreement. Come with specific stories and a considered view on AI safety - including where you are unsure.

References, team matching and the Claude policy

Reference checks and team matching run after the loop and are reported as the least predictable stage. Line up references early, brief them on the role, and follow up politely if a week or so passes without news.

Anthropic publishes guidance on AI use by candidates. As reported when it was updated in July 2025: write your own first drafts of your resume, cover letter and application answers, then you may use Claude to refine them; you may use Claude to research the company and practise; take-home assessments allow Claude only where the instructions say so; and live interviews are without AI assistance unless the interviewer says otherwise. Check the current version on Anthropic's careers site before you apply, since the company has said it will keep reviewing it.

The policy is a hint about the whole process. The company wants to see how you think when the tool is not doing it for you - so practise the assessment and the coding rounds with the assistant switched off.

Keep reading

Related articles