I Passed the Anthropic CodeSignal OA in 2026: Real Questions and Prep Plan

Quick Facts

I took the Anthropic CodeSignal assessment for the new-grad SWE track in 2026 and solved one progressive system-build across four escalating levels in about 90 minutes, using only the Python standard library. What follows is the complete process and how I prepared for it.

The promote() method was the part I did not see coming — the kind of subtle state bug a Real time AI interview assistant can flag in seconds, which is exactly when I reached for it during the test.

Before my test, I went through every Anthropic CodeSignal post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, and below I walk through the traps that get candidates flagged or rejected, especially the promote() state-change bug and the in-progress-segment edge case.

The Real Questions on My Anthropic CodeSignal Test

Question 1: One Progressive System Build

The problem I got: The test was a single problem that escalated through four levels, not four separate questions. Level one asked me to build a worker time-tracking system. I had to implement a class with four methods. register(worker_id, timestamp, action) records a worker's time: an "enter" opens a work segment, an "exit" closes the most recent open one. get_total_time(worker_id) returns the total tracked time for that worker. promote(worker_id) marks a worker for a raise. calc_salary(worker_id, compensation_rate) returns the worker's total compensated time multiplied by the compensation rate. Each level added a constraint and only unlocked after the previous level's tests passed. The whole thing ran about 90 minutes and allowed only the Python standard library.

My approach: I started by sketching the data model: each worker needs a list of closed segments, a marker for any open segment that has not been closed yet, and a stored rate. The first trap I hit was in get_total_time. My instinct was to sum every segment including the one currently in progress, but the level two tests failed because in-progress time must be excluded. I fixed it by only summing closed (start, end) pairs and ignoring open_start until an exit closes it.

The harder trap was promote(). My first attempt mutated the worker's rate directly inside promote(), like self.workers[worker_id]['rate'] *= 1.10. That felt right, but every test after level three went red. The platform wanted the raise to apply on the worker's NEXT register call, not the moment promote() runs. I added a pending_promotion flag that promote() only sets, and I apply the raise inside the enter branch of register(). Once I deferred the state change, the later levels passed.

class WorkerTimeTracker:
    def __init__(self):
        # worker_id -> dict with closed segments, open start, rate, pending flag
        self.workers = {}

    def register(self, worker_id, timestamp, action):
        if worker_id not in self.workers:
            self.workers[worker_id] = {
                'segments': [],
                'open_start': None,
                'rate': 0.0,
                'pending_promotion': False,
            }
        w = self.workers[worker_id]

        if action == 'enter':
            # Apply a pending raise on the NEXT register entry, not at promote() time.
            if w['pending_promotion']:
                w['rate'] *= 1.10
                w['pending_promotion'] = False
            w['open_start'] = timestamp
        elif action == 'exit':
            if w['open_start'] is not None:
                w['segments'].append((w['open_start'], timestamp))
                w['open_start'] = None

    def get_total_time(self, worker_id):
        w = self.workers.get(worker_id)
        if not w:
            return 0
        # Exclude any in-progress (not-yet-closed) segment.
        total = 0
        for start, end in w['segments']:
            total += end - start
        return total

    def promote(self, worker_id):
        # Does NOT change state immediately. Defer the raise to next register.
        w = self.workers.get(worker_id)
        if w:
            w['pending_promotion'] = True

    def calc_salary(self, worker_id, compensation_rate):
        # Total compensated time multiplied by the compensation rate.
        w = self.workers.get(worker_id)
        if not w:
            return 0
        compensated_time = self.get_total_time(worker_id)
        return compensated_time * compensation_rate


if __name__ == '__main__':
    t = WorkerTimeTracker()
    t.register('alice', 0, 'enter')
    t.register('alice', 10, 'exit')
    t.register('alice', 20, 'enter')   # still open, must be excluded
    t.promote('alice')
    t.register('alice', 30, 'enter')   # pending raise applies here
    print(t.get_total_time('alice'))   # 10, open segment excluded
    print(t.calc_salary('alice', 5))   # 50

Time complexity: O(1) amortized per register and promote, O(k) per get_total_time/calc_salary where k is the number of closed segments for that worker | Space complexity: O(W + S) where W is the number of workers and S is the total number of closed segments.

At least one candidate was flagged for using an Invisible App during the assessment. The tool renders the AI's answer on the same screen the proctoring system monitors, hidden by a basic OS-layer trick. An AI interview tool for live interviews works differently: the answer goes to my phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design.

promote() was the moment I lost the most time. I first mutated state directly inside promote() and watched every later test fail, and it took me roughly 20 minutes to realize the raise had to be deferred to the next register call.

I had already decided against a desktop overlay or invisible app for help, because any answer it produced would sit on the same screen the proctoring system monitors, hidden only by a basic OS-layer trick. So when promote() had me stuck, I used the dual-device tool as the safe channel: a keyboard shortcut auto-captured the problem and pushed it to my phone, where the answer landed off-screen. The laptop stayed on the exam editor the whole time, unchanged, while I worked through the deferred-raise fix myself.

Anthropic's Proctoring Policy for CodeSignal

Anthropic bans all AI tools during the code test, allows only its own internal IDE, and disqualifies anyone caught using outside assistance. The platform layer underneath this is CodeSignal's own record and flag stack, which predates and enforces the ban.

AI Tools Are Explicitly Banned

Anthropic's policy is absolute: no internet access, no AI assistants, and no external IDE during the assessment. Anthropic disqualifies any candidate caught using AI tools.

Only the company's internal environment is permitted, so any app running outside it is a violation. Anthropic has also stated this publicly. Its own note tells applicants "please do not use AI assistants during the application process" and says it wants to "evaluate your non-AI-assisted communication skills," so the ban is a stated position rather than a hidden rule.

CodeSignal Record-and-Flag Stack

CodeSignal records the full camera, microphone, and screen session and computes a Suspicion Score from several signals. It flags similarity to leaked solutions, GenAI writing patterns, telemetry such as typing or speaking, and paste events.

The 2025 proctored cheating-flag rate was 35 percent, double the 2024 rate, and 40 percent for entry-level candidates. An "Integrity Flagged: Yes" result triggers a manual review.

8 Other Confirmed Anthropic CodeSignal Questions

Beyond my own sitting, eight distinct progressive problem families are confirmed circulating in the Anthropic CodeSignal library. Each is a single build that escalates through levels, and you draw one per sitting.

In-Memory Key-Value Store

Per Sundeep Teki's June 2026 assessment guide, confirmed by coditioning, igotanoffer, and techprep, this family starts with SET/GET/DELETE and adds filtered scans, then TTL, then compression. The core API is derivable from the level shape, so here is a working base.

class KVStore:
    def __init__(self):
        self.data = {}

    def set(self, key, value):
        self.data[key] = value

    def get(self, key):
        return self.data.get(key)

    def delete(self, key):
        self.data.pop(key, None)

    def scan(self, prefix):
        return [k for k in self.data if k.startswith(prefix)]

Time complexity: O(1) for set/get/delete, O(n) for scan where n is the number of keys. Space complexity: O(n). Teki names the TTL and compression levels but does not publish the exact signatures candidates must implement, so I describe the pattern rather than invent them.

Banking System

Per Sundeep Teki's guide with igotanoffer and lodely writeups, the banking family opens with accounts and balances, then transfers, then filtered transaction history, then time-dependent interest. A working base for the first two levels follows.

class Bank:
    def __init__(self):
        self.balance = {}
        self.history = []

    def create_account(self, acc):
        self.balance[acc] = 0

    def deposit(self, acc, amt):
        self.balance[acc] += amt
        self.history.append((acc, 'deposit', amt))

    def transfer(self, src, dst, amt):
        self.balance[src] -= amt
        self.balance[dst] += amt
        self.history.append((src, 'transfer_out', amt))
        self.history.append((dst, 'transfer_in', amt))

Time complexity: O(1) per operation. Space complexity: O(accounts + history). The interest level depends on per-account timestamped events that these sources describe only by name, so derive the exact formula from your test's stated rules.

File System Simulator

Per Sundeep Teki's guide, confirmed by igotanoffer and lodely, this family builds create/read, then permissions, then symlinks, then mounting. The first two levels are a simple path map.

class FileSystem:
    def __init__(self):
        self.fs = {}       # path -> content
        self.perms = {}    # path -> permission bits

    def create(self, path, content=''):
        self.fs[path] = content

    def read(self, path):
        return self.fs.get(path)

    def set_perms(self, path, bits):
        self.perms[path] = bits

Time complexity: O(1) for create/read, O(1) for set_perms. Space complexity: O(paths). Symlinks and mounting change path resolution in ways these sources name but do not fully specify, so I keep the base honest and skip inventing the later logic.

Package Manager

Per Sundeep Teki's single-source guide, the package manager family moves from install to dependency resolution, then version constraints, then conflict detection. A recursive install that resolves dependencies first is the working base.

class PackageManager:
    def __init__(self):
        self.installed = set()
        self.deps = {}   # pkg -> [dependencies]

    def install(self, pkg):
        for d in self.deps.get(pkg, []):
            if d not in self.installed:
                self.install(d)
        self.installed.add(pkg)

Time complexity: O(nodes + edges) across the dependency graph. Space complexity: O(packages + deps). Version constraints and conflict detection are named but not specified with exact rules, so build them from your test's stated constraints.

Build System

Per Sundeep Teki's single-source guide, the build system family runs from task scheduling to a DAG, then caching, then parallelism. A topological sort gives the working order for the first level.

from collections import defaultdict, deque

def build_order(tasks, deps):
    graph = defaultdict(list)
    indeg = {t: 0 for t in tasks}
    for a, b in deps:
        graph[a].append(b)
        indeg[b] += 1
    q = deque([t for t in tasks if indeg[t] == 0])
    order = []
    while q:
        t = q.popleft()
        order.append(t)
        for nxt in graph[t]:
            indeg[nxt] -= 1
            if indeg[nxt] == 0:
                q.append(nxt)
    return order

Time complexity: O(tasks + deps). Space complexity: O(tasks + deps). Caching and parallelism are described only as level names, so I leave the exact mechanics to your test's rules.

Text Editor

Per Sundeep Teki's single-source guide, the text editor family goes from insert/delete to undo/redo, then a rope structure, then collaborative editing. The first two levels are an array with an undo stack.

class TextEditor:
    def __init__(self):
        self.text = []
        self.undo_stack = []

    def insert(self, pos, ch):
        self.text.insert(pos, ch)
        self.undo_stack.append(('delete', pos))

    def delete(self, pos):
        ch = self.text.pop(pos)
        self.undo_stack.append(('insert', pos, ch))

    def undo(self):
        if not self.undo_stack:
            return
        op = self.undo_stack.pop()
        if op[0] == 'delete':
            self.text.pop(op[1])
        else:
            self.text.insert(op[1], op[2])

Time complexity: O(n) insert/delete where n is text length, O(1) undo. Space complexity: O(n + undo). Rope and collaborative levels are named but not specified with exact semantics, so I keep the base and skip the later code.

Web Crawler

Per Sundeep Teki's guide, confirmed by igotanoffer, techprep, and lodely, the web crawler family starts with fetch, then parse, then rate limiting, then distributed or async work. A breadth-first crawl over a mocked fetch is the working base.

from collections import deque

def crawl(start, fetch, parse):
    seen = set()
    q = deque([start])
    while q:
        url = q.popleft()
        if url in seen:
            continue
        seen.add(url)
        for link in parse(fetch(url)):
            if link not in seen:
                q.append(link)
    return seen

Time complexity: O(pages + edges) with a memoized fetch. Space complexity: O(pages). Rate limiting and async are named levels; wrap the fetch call with a token bucket and an event loop per your test's stated rules.

Rate Limiter and Stateful TTL Services

Per coditioning and lodely writeups, this family centers on a sliding-window limiter that must be concurrency safe. A deque of timestamps gives a working single-threaded base.

from collections import deque

class SlidingWindowLimiter:
    def __init__(self, limit, window):
        self.limit = limit
        self.window = window
        self.ts = deque()

    def allow(self, now):
        while self.ts and self.ts[0] <= now - self.window:
            self.ts.popleft()
        if len(self.ts) < self.limit:
            self.ts.append(now)
            return True
        return False

Time complexity: O(1) amortized with periodic eviction. Space complexity: O(limit). In a real multi-threaded setting you need a lock around allow, which these sources mention but leave to the candidate.

Worker Time-Tracking Family Already Covered in My Test

The worker time-tracking system I described in my own sitting is one instance of this rotating library. You face one progressive problem per sitting, drawn from the families above.

What Anthropic's CodeSignal Test Format Looks Like

The anthropic coding assessment format is a single progressive build, not four separate questions, and levels unlock only when the current tests pass. The chart below sums up the format at a glance.

Progressive Gate Mechanics

Each level adds a constraint and only unlocks after the previous level's tests pass. The tests are visible before you write code, so you can read the expected behavior and plan your data model up front.

A single failing test on a level blocks the next level, which is why the deferred promote() bug in my sitting killed every later test at once.

ICF vs Standard GCA

Anthropic uses CodeSignal's Industry Coding Framework, not the standard General Coding Assessment that other companies use. The GCA is four independent adaptive questions in about 70 minutes on the same 200 to 600 scale. Anthropic's ICF is one problem with escalating levels, closer to a small system build than a LeetCode set.

One scope note: this guide covers the new-grad SWE track, which uses the four-level, 200 to 600 ICF format above. Anthropic's Research and AI Safety Fellow tracks use a different CodeSignal configuration that candidates and guides report as scored out of 1,000 with a different number of parts, so the four-level 600-scale numbers here do not apply to those tracks.

How Anthropic's CodeSignal Scoring Works

Anthropic's CodeSignal score sits on the current 200 to 600 Assessment Score scale, and roughly 520 or above typically advances you. The chart below maps confirmed scores to outcomes.

The 200 to 600 Assessment Score

The authoritative scale is CodeSignal's Assessment Score, 200 to 600, in force since Spring 2023. The older 600 to 850 range is a retired GCA number and the 480 anchor belongs to the DS Framework conversion, neither of which applies to Anthropic. Treat 200 to 600 as the only scale that matters here.

What Score Advances You

The chart marks 520 as the typical advance line and shows why a perfect 600 is still not a guaranteed pass. Recruiters have cited 480 as a working floor, but most reports converge on 520, and reviewers weigh code quality, extensibility, and edge-case handling, not just the raw number. A clean, extensible solution matters more than squeezing out the last points.

Score Is Visible to You

The score is surfaced to the candidate after submission. A May 2026 candidate saw 590 out of 600 on screen and advanced, confirming the score is visible to you after submission.

Anthropic CodeSignal Exam-Day Strategy

The hardest parts of the test were time management and knowing the right APIs, not algorithm difficulty. The strategy below comes from my sitting and from other confirmed candidates.

Manage Time and Know Your APIs

A candidate who scored 590 out of 600 said the difficulty was picking the right data structures for several functions and keeping pace, not LeetCode-style tricks. The test gives two practice levels before the real one, so use them to learn the editor and then do the same work faster and more accurately.

Plan a front-loaded split rather than an even one: about 10 to 15 minutes on level 1 to set a clean architecture, 15 to 20 on level 2, and 20 to 25 each on levels 3 and 4. Level 1 must be clean because every later level builds on it, so a slow but correct start beats a fast, sloppy one.

The promote() Trap and Recovery

My own stuck moment was promote(). I first mutated the rate directly inside the method and every later test went red, then spent about 20 minutes realizing the raise had to apply on the next register call.

I fixed it with a pending_promotion flag set in promote() and applied in the enter branch. When a level's tests fail as a block, check whether you changed state at the wrong moment.

Clean-First, Partial Credit Counts

Rewriting an early stage halfway through the test is a failure pattern on its own. A clean stage one with partial stage two is a reasonable outcome, because CodeSignal awards partial credit per level. I made a habit of sketching the class structure for three to five minutes and writing my own tests before coding. Anthropic values the simple thing that works, so I wrote clear correct code first and optimized only when a test demanded it.

Why Candidates Fail the Anthropic CodeSignal Assessment

Most failures come from integrity violations and avoidable coding mistakes, not from the problems being unsolvable. The patterns below are confirmed across candidate and platform reports.

Invisible-App AI Detection Ends the Test

Running an Invisible App during the assessment triggered an immediate test shutdown and disqualification.

Invisible AI helper apps are an active detection target in 2026 interviewing, and proctoring stacks are built to catch them. The safest setup keeps the answer off your exam screen entirely, on a separate device the monitoring cannot reach by design.

Hardcoded Outputs Fail LLM Review

Anthropic runs submitted OA code through LLMs to catch test-gaming that standard proctoring misses. Hardcoded outputs, branches written for specific tests, and similarity to leaked solution sets all get flagged. A solution that only passes by gaming the visible tests fails the review even with a high score.

Suspicion Score Flags and Time Loss

CodeSignal's Suspicion Score flags off-screen referencing, which accounted for 35 percent of 2025 flags, and linear typing with no debugging, which accounted for 23 percent. Paste events and GenAI patterns also raise the score. An "Integrity Flagged: Yes" result sends the attempt to manual review and costs you the round.

Edge-Case and Pacing Mistakes

Small spec misses break levels. In my sitting, get_total_time had to exclude in-progress segments, and calc_salary was overlap duration times compensation, not raw tracked time. Rewriting an early stage mid-test wastes the minutes you need for later levels, so ship a clean base and move on.

How to Prepare for the Anthropic CodeSignal in 5 Days

Your CodeSignal link usually arrives within three to five days of the recruiter screen, and you get five to seven days to finish it. Submitting within about 48 hours is reported to help, so I treated the window as a buffer and spent five focused days building the right habits.

Orient (Days 1-2)

I confirmed the test shape before writing any code: one progressive ICF build in about 90 minutes, Python standard library only, under full camera, mic, and screen recording with a hard AI-tool ban. The confirmed question families are all escalating system builds, not the discrete trick questions other companies favor.

I skipped standalone LeetCode-style algorithm drilling on purpose. Every confirmed Anthropic problem is a progressive system build with visible tests, and the documented failures are integrity slips and edge-case misses rather than weak Big-O, so that prep would not have paid off.

Drill (Days 3-4)

In the days before the OA, I used the Prep Agent from InterviewFox over WhatsApp and sent it the confirmed Anthropic question patterns, and it sent back a personalized drill plan. It was one practical tool among several in my prep, not the whole strategy.

I drilled timed ICF builds in the Python standard library only, sketching the class structure first and anticipating extensions like TTL or metadata at level one. Writing my own tests for each level trained me to read the spec literally, which is what the progressive gates reward.

Simulate + Buffer (Day 5)

On day five I ran one full timed build at the real 90-minute limit and the ~520 advance bar, then kept the rest of the day as a low-intensity buffer. I reviewed only and added no new material, so I walked in sharp without last-minute risk.

What Happens After You Submit the OA

After you submit, two or three engineers review your code over four to five business days before any decision. The wait and the next stages are confirmed across candidate and platform reports.

The 4 to 5 Day Engineer Review

Two or three engineers review code quality, edge cases, and production readiness, then decide. A rejection comes with no feedback and often as a generic no-reply, with rejections batched weekly. About ten days of silence is a strong sign you did not pass, so plan other applications in parallel.

What Comes Next

A pass leads to live coding of about 55 minutes, then system design on LLM infrastructure and GPU scheduling, then a behavioral and culture round focused on AI safety. The full loop runs up to five or six stages, so the OA is the first gate, not the last.

Anthropic's LLM-Based Code Integrity Review

As covered above, Anthropic screens every submitted solution with LLMs to catch test-gaming that standard proctoring cannot see: this LLM review is the differentiator most other guides never mention.

How the LLM Review Works

A high score from passing tests does not protect you if the code looks gamed. Write honest, extensible code and the review works in your favor.

Why 600 Is Not a Guarantee

A perfect 600 still goes through the LLM integrity review, so the maximum score is not an automatic pass. Clean structure, real edge-case handling, and no test-gaming are what actually carry you forward. The number opens the door, but the review decides.

FAQ

What is the anthropic coding assessment format in 2026?

It is one progressive problem with four escalating levels, not four separate questions. You get about 90 minutes and Python standard library only.

How long is the anthropic online assessment and when does the link arrive?

The recruiter screen leads to a CodeSignal link in three to five days. You then have five to seven days to finish the test.

Is there a separate anthropic fellows codesignal track?

Public sources describe the new-grad and early-career SWE OA using the same CodeSignal ICF format. No separate fellows-specific assessment is documented in the sources I found.

What do anthropic codesignal reddit threads say about the score cutoff?

Reddit and Teamblind reports put the typical advance line near 520 out of 600. One Blind candidate reported 590 and advanced, while a perfect 600 still gets an LLM integrity review.

What score do I need to pass the anthropic codesignal test?

Roughly 520 or above on the 200 to 600 scale typically advances you. A 600 is not an automatic pass because of the LLM review.

Does Anthropic really ban AI tools during the code test?

Yes. Any outside AI assistance ends the test and disqualifies you. Only the company's own internal IDE is allowed.

Can I use an AI tool or invisible app during the Anthropic CodeSignal OA?

Desktop overlay tools put the AI's answer on your computer screen, rendered as a hidden layer above the browser with a basic OS-layer trick. Proctoring software keeps adding detection capabilities as AI tools grow more common, so that on-screen exposure is a risk you cannot assume is safe.

InterviewFox instead pushes the answer to your phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design, so the dual-device setup removes the answer from your screen entirely.