Monday, May 11, 2026

CodeSignal Practice Protocol: Anthropic Fellows Consolidated from Assembly Research · May 2026

CodeSignal Practice Protocol: Anthropic Fellows

Consolidated from Assembly Research · May 2026

What You're Actually Facing

Anthropic uses the Industry Coding Framework (ICF), not the standard General Coding Assessment. Verified from Blind (May 2026):

90 minutes, one system, 4 progressive levels
Python 3.10.6, standard library only
Most common problems: in-memory database (~60% of reports), banking system
Max score: 600 (some reports say 1000 — may depend on variant)
Candidate consensus: "Nothing complicated coding wise, but you have to code VERY FAST"
Proctored: webcam, screen recording, paste detection, AI-generated code detection
Each level builds on the previous — your Level 1 architecture must survive Level 4

What You Need to Pass (Not Ace — Pass)

You passed the written screen on a proposal about Compression Survival Metrics. They want you for your research mind, not your Python. The CodeSignal is a basic competency filter. You need ~480-540/600. That means: complete Levels 1-3 cleanly. Partial Level 4 is fine.

The Five Patterns That Cover Everything

Every ICF problem is a variation of the same skeleton. Memorize this, not syntax:

class System:
    def __init__(self):
        self.data = {}          # Level 1: basic store
        self.history = []       # Level 3: timestamps
        self.backups = {}       # Level 4: snapshots

    # Level 1: CRUD
    def set(self, key, value):
        self.data[key] = value

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

    def delete(self, key):
        if key in self.data:
            del self.data[key]

    # Level 2: filtered query
    def scan_prefix(self, prefix):
        return sorted([k for k in self.data if k.startswith(prefix)])

    # Level 3: TTL
    def set_with_ttl(self, key, value, timestamp, ttl):
        self.data[key] = {"value": value, "expires": timestamp + ttl}

    def get_at_time(self, key, timestamp):
        entry = self.data.get(key)
        if entry and entry["expires"] > timestamp:
            return entry["value"]
        return None

    # Level 4: snapshot
    def backup(self, backup_id):
        import copy
        self.backups[backup_id] = copy.deepcopy(self.data)

    def restore(self, backup_id):
        if backup_id in self.backups:
            import copy
            self.data = copy.deepcopy(self.backups[backup_id])

That skeleton — with variations in naming and domain — is 80% of what you'll see.

The Six Operations You Must Be Fluent In

Not algorithms. Operations. Things your hands do without thinking:

dict lookup: self.data.get(key, default)
dict iteration with filter: [k for k, v in self.data.items() if condition]
sorted output: sorted(items, key=lambda x: x[field], reverse=True)
timestamp comparison: if entry["expires"] > current_time:
deep copy for snapshots: import copy; copy.deepcopy(self.data)
string prefix check: key.startswith(prefix)

If you can type these six patterns without looking anything up, you can pass Levels 1-3.

The Droppable Practice Prompt

Paste this into any LLM to generate a realistic practice test:

Generate an Anthropic Fellows-style CodeSignal practice problem in Python.

Format: one coherent system, 4 progressive levels, 90-minute target.

Level 1: Basic CRUD operations (set/get/delete or create/read/update).
Level 2: Filtered queries, sorting, prefix search, or conditional logic.
Level 3: Timestamps, TTL expiration, scheduling, or historical lookup.
Level 4: Backup/restore, merge, rollback, transactions, or permissions.

Requirements:
- Python 3 only, standard library only
- Provide exact method signatures
- Provide 3 visible test cases per level
- Describe 5 hidden edge cases in prose
- Suggest an internal data model but do NOT provide solution code
- The Level 1 design must be consequential for Level 4

Pick one domain randomly:
1. In-memory database
2. Bank account ledger
3. File storage system
4. Task scheduler with priorities
5. API rate limiter
6. Provenance/citation tracker
7. Experiment run registry
8. Content moderation queue
9. Annotation task manager
10. Package delivery tracker

Time Budget During the Real Test

Level	Minutes	Goal
Read full spec + plan	5-10	Understand all 4 levels BEFORE writing code
Level 1	10-15	Clean CRUD. Dict-based. Submit and verify.
Level 2	15-20	Add queries/filters. Use list comprehensions + sorted().
Level 3	20-25	Add timestamps/TTL. This is where most people stall.
Level 4	15-20	Partial is fine. Get the main operation working. Skip edge cases if time is short.

Critical rule: Read ALL FOUR LEVELS before writing any code. Your Level 1 dict structure must accommodate Level 3's timestamps. If you build Level 1 as self.data[key] = value and Level 3 needs self.data[key] = {"value": v, "expires": t}, you'll waste 15 minutes refactoring.

Three-Day Minimal Prep Plan

Day 1: Pattern Loading

Generate 2 practice problems with the droppable prompt above
Don't solve them — just READ the specs and write the data model on paper
Practice typing the six operations from memory (no looking up syntax)
Time yourself: can you write the skeleton class in under 5 minutes?

Day 2: One Full Mock

Generate 1 practice problem
Set a 90-minute timer
Write the solution. Submit after each level.
When stuck, write comments describing what you WANT to do, then ask the LLM to translate your comments to Python. Study the translation.

Day 3: Edge Cases + Light Review

Use this prompt:

Give me 8 short Python snippets with subtle bugs:
off-by-one errors, mutable default arguments, shallow vs deep copy,
dict iteration during mutation, None vs empty string, timestamp
comparison edge cases. Show the buggy code, ask me to find the bug.

Do one light Level 1-2 run (20 minutes) just to warm up the pattern
Stop. Rest. Sleep.

During the Test: Tactical Notes

Write comments first. # Step 1: check if key exists before writing code. This looks like human planning to the proctor AI.
Run tests constantly. After every 3-4 lines. Don't write 50 lines and hope.
Use simple dicts. No clever data structures. self.data = {} is almost always right for Level 1.
Don't optimize. Brute force that passes all tests scores the same as elegant code that passes all tests. A candidate on Blind: "no need to do algo optimizations, use brute force if it can save 3 minutes."
If stuck on Level 4: implement the simplest version of the main operation. Passing 20/41 hidden tests is better than 0/41.
Do not paste large blocks of code. The proctor flags pastes >15 lines.

What Happens After

If you score ~480+, you advance to a live coding screen with an Anthropic engineer (90 min, more conversational), then a final loop with a Colab-based LLM coding round + research brainstorm. The research brainstorm is where your actual proposal — Compression Survival Metrics, Provenance Erasure Rate — gets evaluated. The CodeSignal is just the gate. Get through it.

Coaching Prompt (for after practice)

Do not solve the problem for me.
Act as a CodeSignal coach.
1. What data structures should I use?
2. What helper functions should I write first?
3. What is the simplest Level 1 implementation?
4. What should I NOT over-engineer?
5. Give me a 90-minute time plan.
6. List 10 edge cases that will break my code.
Then stop.

Debugging Prompt (when stuck)

Here is my code and the failing test.
Do not rewrite the whole solution.
Find the smallest bug.
Explain why the test fails.
Give the smallest patch.
Then give one test that would catch the same bug.

Mind Control Poems

Monday, May 11, 2026