ANTHROPIC KERNEL / SYSTEMS / RESEARCH ENGINEER

Interview Loop Map + 12-Hour Daily OS

As of 2026-08-18. Start date for the 30-day plan: Monday 2026-08-24.

Sources used: Anthropic careers + Greenhouse postings; Tristan Hume’s official performance take-home post (2026-01-21); anthropics/original_performance_takehome; IGotAnOffer / SpaceComplexity / Aceoffer (400+ reports, last refresh Aug 2026); Glassdoor RE reports; Exponent Staff Infra 2025 loop; Ridhima Khurana culture write-up; Sundeep Teki RE 2026; Levels.fyi (updated 2026-08-16); official Core Views / RSP v3; CS336, Karpathy Zero-to-Hero.

Treat interview-prep blogs as noisy. Treat Anthropic’s own pages, Greenhouse JDs, Hume’s take-home, and high-frequency Aceoffer items as higher-signal.

0. What you are actually applying to

Anthropic does not hire a job titled “kernel developer.” The mapping:

Internal titles are flatter than Google. Public Levels.fyi buckets: Software Engineer (entry) / Senior / Lead / Staff. Recruiters still talk L3–L7. A Staff infra candidate in 2025 was told base ~$410k and “we don’t negotiate the band.” Equity is 4-year vest, 25% year-1 cliff, illiquid.

Official hiring doctrine (anthropic.com/careers): “About half our technical staff had no prior ML experience; about half have PhDs.” Engineers author papers, often first-author. If you are an engineer, apply as an engineer — you will interview better and still do research.

Kernel-role reality: Hume’s team hired most of the current performance org off a 2–4 hour simulated-accelerator take-home. Several strong hires were undergrads who crushed the take-home. Paper credentials are optional. Cycle counts are not.

Do not apply to Performance Engineer, GPU as a “strong SWE who watched CUDA lectures.” Apply when you have a kernel repo + Nsight (or honest A100/4090 roofline) writeup + the take-home under 1487 cycles.

1. Interview loop map

Process length: 4 weeks to 3+ months. Team matching after a pass is the stall (2–4+ weeks, sometimes ghost-shaped). Reapply after 12 months, or sooner if a material artifact changes.

Role variants differ. Below is the union of SWE / RE / Performance, with notes on who sees what.

Round A — Recruiter screen (30 min)

Tested: Why Anthropic specifically (not “I like AI”). Safety motivation that survives a second “why.” Visa / location (25% office: SF / NYC / Seattle). Comp band comfort at senior+.

Prep: 200–400 word written answer (the application already asks this and “we value this response highly”). Read Core Views, RSP v3, last two Dario essays. One concrete disagreement with Anthropic, prepared.

Failure modes: Generic mission speech. “I want to ship fast.” Cannot name a paper or a policy. Treating this as a formality. Recruiter explicitly warns: people pass technical and die on values.

Round B — CodeSignal OA (90 min) — SWE / most RE

Tested: One problem, four levels. 100% of tests on a level unlocks the next. Candidates report ~520+/600 to advance; 590–600 still sometimes rejected (resume + OA together). Progressive system, not LeetCode: in-memory KV (GET/SET/DELETE → filtered scan → TTL → snapshot/compression), banking system, file cache, recipe manager.

Prep: CodeSignal practice tests (the OA itself gives 2 warmup levels). Build 8 incremental systems under a 90-minute clock. Python stdlib fluency: heaps, bisect, defaultdict, dataclasses. Write extensible code on level 1 (you will refactor under time).

Failure modes: Optimizing level 1 for beauty then rewriting everything. Gaming visible tests (they LLM-detect this). Spending 40 min on a debug rabbit hole. Not reading ahead — later levels punish rigid designs. Glassdoor: strong SWE + LC-medium-in-20-min still score ~50% if they have never done this format.

Kernel/performance track: this OA may be skipped or paired with the VLIW take-home (Round B′).

Round B′ — Performance take-home (2 hours, AI allowed)

Official origin: Tristan Hume, “Designing AI-resistant technical evaluations,” 2026-01-21. Original problem released: https://github.com/anthropics/original_performance_takehome

Simulated VLIW SIMD accelerator (TPU-flavored: scratchpad, VLIW pack, SIMD width 8). Task: parallel tree traversal. Baseline ~147,734 cycles. Recruitment gate at launch: < 1,487 cycles. Best released Claude harness: 1,363. Best humans with unlimited time beat that. If you get under 1487 on the released version, email performance-recruiting@anthropic.com with code + resume. Live process now uses a weirder, more Zachtronics-like successor designed so Claude cannot just solve it.

Tested: Comprehension speed, building your own debug/trace tools, instruction packing, vectorization, load elimination, not getting stuck on a fake bandwidth wall.

Prep: Do the released repo to completion, write a changelog of every optimization and its cycle delta. Then do it again from scratch in 2 hours. Then do Shenzhen I/O / TIS-100 style puzzles for the new format.

Failure modes: Delegating entirely to Claude and not being able to explain the kernel. “I hit the memory wall” (that is the intended mid-point). Cheating the simulator (N_CORES, test folder) — they check.

Round C — Hiring manager screen (45–60 min)

Tested: Do you understand your own work. Tradeoffs, what you would redo, how you know it worked. For non-ML backgrounds: own it, explain the learning path, do not hide.

Prep: Two projects, full lifecycle, 8 minutes each unprompted, then 20 minutes of “why not the other design.”

Failure modes: Resume recitation. Cannot name the alternative you rejected. Inflating impact. Cannot discuss a real failure without the “I worked too hard” escape hatch.

Round D — Live coding (1–2 × 55–60 min, Colab / Replit)

Highest-frequency reported problems (Aceoffer, through Aug 2026):

RE/MLE extra: implement attention in PyTorch; NumPy forward+backward; debug planted-bug GRPO (softmax-before-multinomial, epsilon-less std, wrong IS ratio) then PPO clip / mini-epoch drift theory.

Tested: Clean incremental implementation. Debug under a provided harness. Comfort looking things up. Concurrency when asked, not before.

Failure modes: Jumping to concurrent crawler before single-thread passes. Skipping URL normalization (fragments, trailing slash, query). Freezing when the environment is a messy repo rather than a blank editor (this killed a Staff infra candidate who expected a multithreaded DSA question).

Round E — System design (55 min)

Highest-frequency: Inference API (39×), prompt playground (15×), model distribution/deployment (12×), batch inference (11×), GPU cluster / inference infra (7×), chat (6×), roofline (3×).

The Staff 2025 phone screen: “one GPU, 100 inputs/batch, sync clients, design the batcher.” Onsite: “one huge file (model binary) over a constrained link to thousands of hosts.”

Tested for SWE/infra: Model is a black box. Queues, batching vs latency, async-to-sync join, failure, fan-out. Safety/abuse as first-class (rate limits, prompt injection surface, logging redaction).

Tested for RE / kernel: Same plus KV-cache memory, continuous batching, paged attention, tensor/pipeline/expert parallel, NCCL, roofline, what a kernel fusion actually buys.

Failure modes: Designing Twitter. Conflating routing (cheap, stateless) with serving (GPU-pinned). Ignoring safety/privacy. Not driving the conversation.

Round F — Research / paper / ML debug (RE and some perf)

Paper from Anthropic or adjacent. Not a quiz: “what would falsify this,” “best alternative explanation,” “cheapest distinguishing experiment,” “what they did not ablate.”

Coding flavor: broken transformer, loss-spike debug on a 100B pretrain (“data vs LR vs hardware”), A100 matmul performance model.

Failure modes: Summarizing the abstract. Confident speculation past your knowledge. No opinions.

Round G — Values / culture (45–60 min, standalone, often non-technical interviewer)

This is the highest-failure-rate round in the loop. Recruiters say this. It is not a FAANG behavioral. STAR-reciting is the #1 failure mode, flagged by Anthropic themselves.

They send reading: Core Views (2023-03-08), RSP (now v3 / v3.1 — ASL is now a safeguard bundle, not a model label; Capability Thresholds + Required Safeguards), “Machines of Loving Grace” (2024-10), “The Adolescence of Technology” (2026-02).

Five archetypes (Khurana + Glassdoor + Exponent):

1. AI safety reasoning — specific, or you fail.
2. Proud-project deep dive as a values probe (what you are proud of = what you optimize).
3. Safety vs speed — a time you actually slowed a launch.
4. Technical misjudgment — a real mistake, no hero edit.
5. Open-ended AI brainstorm — they may give almost no feedback (Safety Fellow 2025: 15 min alignment brainstorm, then 55 min Colab inference notebook).

Also reported: “What unusual beliefs do you hold?” “Something you currently believe strongly that you might be wrong about?” “Moral conflict — who did you talk to, what did they say, what changed?”

Prep: Write positions, then argue the opposite, then update. Practice out loud. Have one real disagreement with CAI, RSP v3’s retreat from rigid ASL-4/5 controls, or interp-as-audit. Hold light and shade in the same answer.

Failure modes: “I love your mission.” Reciting HHH. Collapsing to “AI bad” or “scale solves safety.” Performing conviction. Immediate cave when pushed, or stubbornness when the counterargument is actually better.

Round H — References + team match

References happen mid-process, not after offer. Notify them early. Team match can pass every round and still die on headcount. No feedback. Ever.

AI-use policy (official)

Use Claude to think, critique, prepare. Do not generate CodeSignal solutions or live-interview code. Performance take-home: AI is explicitly allowed; you still have to outperform a solo Claude.

1b. How Anthropic differs from the other three

Prep that is “Blind 75 + Grokking System Design” fails all four in different ways. For Anthropic it fails first.

2. Phased roadmap (consumes foundations → kernels → LLM theory → systems → interview)

Assumption: 12-hour work block, 6 days/week, 1 full rest day. That is 72 hours/week of scheduled time, of which ~7.5 are deep technical work, 1.5 recovery, 3 maintenance on a weekday (see §3). Do not schedule 12 hours of papers. You will not last 8 weeks, let alone 12 months.

Honest calendars from 2026-09-01. These assume you already have a strong base in one of the three columns and are training full-time (or the equivalent hours around a job — if you keep a full-time job, multiply by 1.7–2.2).

If someone tells you this is an 8-week project they are selling a course. A Staff-level kernel loop at this company is a year-plus build unless you already have two of {production CUDA, trained-a-transformer, written-a-safety-critique}.

Phase 0 — Foundations

Entry: You can write non-trivial Python. You have used git. You can read C. Exit (must all be true):

• Derive backprop for an MLP on paper, then implement it in NumPy with no framework.
• Explain SRAM vs HBM vs DRAM, and why attention is memory-bound at inference.
• Finish Karpathy lectures 1–6 (micrograd → makemore → backprop ninja).
• 50 CodeSignal / timed incremental-system problems at 80%+ in 90 min.

Phase 1 — LLM theory by building

Curriculum: Karpathy lecture 7–8 (GPT + tokenizer); Attention Is All You Need; nanoGPT trained to completion; CS336 Assignment 1 (tokenizer, transformer, optimizer, training loop); Vaswani + GPT-2/3 papers; Kaplan + Hoffmann scaling laws. Exit:

• Repo: from-scratch GPT, trained, loss curve, sample quality writeup.
• You can implement MHA, RoPE, RMSNorm, SwiGLU, AdamW from memory in 40 minutes.
• You can explain GQA, KV cache, and why decode ≠ prefill on a whiteboard.

Phase 2 — Kernels

Curriculum: CS336 lectures 5–6 + Assignment 2 (profile + your FlashAttention-2 in Triton); CUDA C++ Programming Guide ch. 1–5; GPU Mode lectures; FlashAttention (Dao 2022) + FlashAttention-2 (2023) + FA3 notes; Triton tutorials; CUTLASS / ThunderKittens as reading; Anthropic original take-home to <1487; then a real CUDA FA-style kernel (even if slower than Triton). Exit:

• Triton FA-2: correct vs PyTorch SDPA on random QKV, with a writeup of tiling, SRAM budget, online softmax.
• CUDA sibling kernel, even if 0.4× the Triton version — you can explain the gap.
• Nsight Compute report on some NVIDIA GPU (see §6). Roofline plotted.
• Take-home <1487 with a commit log of cycle deltas.

Phase 3 — Systems

Curriculum: CS336 lectures 7–8, 10 + Assignments 3–4; How to Scale Your Model (Google); Megatron / ZeRO papers; vLLM PagedAttention; continuous batching (Orca / Sarathi); NCCL primer; a 2–8 GPU training run you actually launched. Exit:

• Design doc: training stack for a 7B–70B dense model (data, parallelism, checkpoint, failure, eval).
• Working: FSDP or Megatron-style train on ≥2 GPUs, with a measured MFU number.
• Verbal: 45-minute inference-API design that includes continuous batching, paged KV, and a safety/rate-limit layer.

Phase 4 — Alignment / safety (starts week 1, intensive in the last third)

Curriculum (read, then write a critique, then argue the other side):

1. Core Views (2023)
2. Constitutional AI (Bai et al., 2022) + HHH
3. RSP original + v3.0 / v3.1 (you must know what changed and why)
4. A General Language Assistant as a Laboratory for Alignment
5. Elhage et al. mathematical framework for transformer circuits; Toy Models of Superposition; later SAE papers
6. Scaling laws + “Predictability and Surprise”
7. Machines of Loving Grace (2024-10); Adolescence of Technology (2026-02)
8. One opposing view you take seriously (e.g. critique of interp-as-audit, or of RSP v3’s move off rigid ASL-4/5)

Exit: 2,000–4,000 word CAI/post-training writeup that a researcher would not be embarrassed to read. You can do a 15-minute alignment brainstorm with almost no interviewer feedback.

Phase 5 — Interview

Curriculum: 40 timed CodeSignal-style builds; 15 live mock coding sessions on Colab; 10 inference-design mocks; 8 values mocks with a human who will argue with you; 5 paper-discussion mocks; GRPO/PPO debug drills; take-home redone in 2 hours. Exit: Two consecutive mocks at “would advance” from someone who has done this loop, or from a recorded self-review against the failure-mode list in §1.

3. The 12-hour day (sustainable-ish)

You asked for 12 hours. The failure mode of 12-hour days is treating all 12 as “more papers.” Split them.

Daily template (Tue–Thu deep days)

That is ~11.7 hours of scheduled day, of which ~7.5 are work, ~1.5 movement, ~2.5 food/admin. If you insist on counting movement as part of the 12, fine. If you add a 21:00–22:00 optional block, make it Anki or a walk, never a new paper.

Doing vs studying (non-negotiable):

If the day’s log cannot point at a file, a number, or a paragraph you wrote, the day was study. Two study-days in a row is a process bug.

Weekly rhythm

Friday is for closing loops. A week with five started notebooks and zero writeups is a failed week.

Monthly checkpoints (artifacts, not vibes)

By the end of each calendar month you either have the file or you repeat the month. No “almost.”

CUDA-strong track compresses M4–M7 and expands M1–M3 and M10. ML-strong track compresses M1–M3 and expands M4–M9.

4. First 30 days — strong generalist SWE, starting Monday 2026-08-24

Prerequisite this week (2026-08-18 → 08-23), before Day 1:

1. SPAR Fall 2026 mentee app closes today, 2026-08-18. If you have any alignment/systems angle, submit before midnight: https://forms.sparai.org/spar/mentee-app — 5–40 h/week, remote, Demo Day with METR / Redwood / GovAI / MATS. This is the only free mentor pipeline with a deadline today.
2. Install: Python 3.12, PyTorch (CPU ok this month), CUDA toolkit if you have an NVIDIA GPU, nsight-compute if local GPU exists, Anki, uv or conda, gh.
3. Accounts: GitHub repo anthro-prep (public), Lambda + RunPod + Modal (no spend yet), NVIDIA Developer (free), CodeSignal, Colab.
4. Clone: karpathy/nn-zero-to-hero, karpathy/nanoGPT, karpathy/minbpe, anthropics/original_performance_takehome (do not start optimizing yet), CS336 public materials at https://cs336.stanford.edu/.
5. Buy/print: a notebook. You will derive by hand.

Each day below uses the §3 clock. I only specify what fills the blocks.

Week 1 — Autograd, tensors, first values writing (2026-08-24 → 08-30)

Mon 08-24

• DW1 (08:20–11:20): Karpathy lecture 1 (micrograd). Code your own Value engine in a new file. Do not copy-paste the notebook.
• DW2 (12:40–15:10): Finish micrograd; train a tiny MLP on make_moons.
• Sec (15:40–17:40): Write notes/day01.md: chain rule for a 2-layer net, by hand.
• Light (18:20–19:50): Read Core Views, first third. Notes only, no critique yet.
• Done-when: python train.py prints decreasing loss from your autograd.

Tue 08-25

• DW1: Karpathy lecture 2 (makemore bigram). Implement counts + neural bigram yourself.
• DW2: Sample names; compute NLL. Break it on purpose (forget softmax) and watch the loss.
• Sec: Anki cards from today’s formulas (softmax, NLL, broadcasting rules).
• Light: Core Views, rest. List 5 claims and the evidence he actually gives.
• Done-when: bigram samples + a note “what a count table cannot do.”

Wed 08-26

• DW1: Lecture 3 (makemore MLP / Bengio 2003). Implement embedding table + hidden + softmax.
• DW2: Learning-rate sweep. Train/dev/test split. Plot.
• Sec: Timed 45-min incremental system: in-memory KV GET/SET/DELETE + LIST prefix. Python, no internet if possible.
• Light: Start 800-word Core Views critique. Thesis required. One disagreement required.
• Done-when: LR curve screenshot in the repo.

Thu 08-27 — first interview-format day

• DW1: 90-minute timed: extend yesterday’s KV with TTL and a scan. Pretend it is CodeSignal. No peeking at solutions.
• DW2: Lecture 4 (batchnorm / activations). Implement batchnorm from the paper equations, not from nn.BatchNorm.
• Sec: Record a 5-minute voice memo: “Why Anthropic, and where I currently think they might be wrong.” Listen to it. Cringe is the point.
• Light: Finish Core Views critique. Publish in repo.

Fri 08-28 — close loops

• DW1: Lecture 5 (backprop ninja). Manual backward for every op in the MLP. This is the week’s hardest morning.
• DW2: Finish remaining backwards. Compare to autograd.
• Sec + Light: Week-1 writeup. Tag week-1. Retro: hours actually worked, what was study vs doing.

Sat 08-29

• 4h: Re-implement micrograd + MLP from a blank file, no notes. Time it.
• 3h: CodeSignal arcade / 2 more incremental systems.
• 1h: RSP v3 blog post (anthropic.com/news/responsible-scaling-policy-v3). Notes on what changed from ASL-as-model-label to Capability Thresholds.

Sun 08-30 — off.

Week 1 exit: Own autograd, own bigram, own MLP+BN, 3 timed systems, published Core Views critique.

Week 2 — WaveNet → GPT start, CAI first contact (2026-08-31 → 09-06)

Mon 08-31

• DW1–2: Lecture 6 (WaveNet / dilated conv, stacking). Build it.
• Sec: Attention Is All You Need §1–3.5. Draw the diagram from memory.
• Light: Anki + rewrite attention equations without looking.

Tue 09-01

• DW1–2: Lecture 7 start — GPT from scratch. Token embedding, position, one block, generate.
• Sec: Vaswani §3.2–4 + Table 1. Compute parameter count of your model by hand; match sum(p.numel()).
• Light: Constitutional AI paper (Bai et al. 2022) abstract + §2 (SL-CAI). Notes.

Wed 09-02

• DW1–2: Finish a minimal GPT (lecture 7). Train on tiny_shakespeare or names.
• Sec: Timed 90-min: banking-system style (accounts, transfers, timestamps, rollback).
• Light: CAI §3 (RL-CAI / RLAIF). Write the pipeline as a 12-box diagram.

Thu 09-03

• DW1: 90-min timed OA (file cache with eviction + persist).
• DW2: GPT train to a real loss drop. Sample. Log tokens/sec.
• Sec: Implement BPE tokenizer following lecture 8 / minbpe after you try from the paper.
• Light: 5-min voice memo: “CAI vs RLHF. What CAI does not prove.”

Fri 09-04

• Close: tokenizer encode/decode roundtrip tests; GPT samples in README; week-2 writeup.
• Light: Read HHH / “A General Language Assistant…” enough to explain HHH without the slogan.

Sat 09-05

• Blank-file GPT in 3 hours.
• 2 hours: start CS336 lecture 1 (tokenization) + lecture 2 (FLOPs, memory, arithmetic intensity). Do the resource-accounting exercises on your GPT.
• 2 hours: RSP v3.1 PDF. Write “what I would ask Dario if I had 10 minutes.”

Sun 09-06 — off.

Week 2 exit: Trained GPT, BPE, 2 more timed OAs, CAI pipeline diagram, arithmetic-intensity calculation for your model.

Week 3 — CS336 A1 begins, first kernel-shaped thinking (2026-09-07 → 09-13)

Mon 09-07

• DW1–2: CS336 A1: implement tokenizer (regex + BPE) to spec if you have the assignment files; else implement minbpe + GPT-2 regex and match HuggingFace token counts on 10 documents.
• Sec: CS336 lecture 3 (architectures, hyperparameters).
• Light: Elhage et al. 2021 “A Mathematical Framework for Transformer Circuits” — read through residual stream + QK/OV. Do not “finish the paper.” Take notes on the residual-stream claim only.

Tue 09-08

• DW1–2: A1 transformer: attention, MLP, RMSNorm or LayerNorm, residual. Unit test against a reference or against PyTorch for a single step.
• Sec: Implement softmax + cross-entropy + backward in NumPy (this is an RE interview item). Time yourself.
• Light: Circuits paper, induction heads section.

Wed 09-09

• DW1–2: AdamW + training loop + checkpointing. Overfit one batch first (if you cannot, stop and debug — this is the real skill).
• Sec: Timed OA.
• Light: 800-word “what an induction head is, and what that does not imply about alignment.”

Thu 09-10

• DW1: Live Colab mock: web crawler, single-thread first, then concurrent.futures. Record screen. Watch it.
• DW2: Fix whatever the recording showed.
• Sec: FlashAttention (Dao 2022) §1–3. Derive online softmax on paper.
• Light: Values drill — write a real professional mistake. Then a second draft that is less flattering and more accurate.

Fri 09-11

• Close A1 pieces that work. Loss-on-one-batch screenshot. Week-3 writeup.
• If no NVIDIA GPU: open RunPod/Lambda account, price an A100-hour, do not rent yet. Write the budget.

Sat 09-12

• 4h: CS336 lecture 5 (GPUs) + lecture 6 (kernels, Triton) — watch, then rewrite the memory hierarchy from memory.
• 3h: Triton intro tutorial: write a vector-add kernel and a fused softmax. Even on CPU-mode Triton if needed; if that fails, write the tiling math and a NumPy reference.
• 1h: Apply NVIDIA Developer Program if not done.

Sun 09-13 — off.

Week 3 exit: A1-shaped transformer that overfits a batch; NumPy backward; crawler mock; online-softmax derivation; first Triton kernel or a written tiling plan.

Week 4 — Train for real, start nanoGPT proper, safety second essay (2026-09-14 → 09-23)

Mon 09-14

• DW1–2: Port your GPT to nanoGPT’s structure (or finish CS336 A1 train). Goal: a clean train.py someone else can run.
• Sec: Kaplan 2020 scaling-laws paper. Plot (on paper) L(C), L(N), L(D).
• Light: Hoffmann / Chinchilla 2022. What changes if you believed Kaplan vs Hoffmann when buying compute.

Tue 09-15

• DW1–2: Train the model overnight-capable: if you have a 3090/4090, start a 1–4 hour run. If not, rent one A100 hour (~$2) and train. Log tokens/sec, final loss.
• Sec: torch.profiler or nsight-sys one-pager: where is time going in your train step.
• Light: Machines of Loving Grace (Dario, 2024-10). 10 claims, 10 “what would change my mind.”

Wed 09-16

• DW1–2: Implement KV cache in your generate() and measure tokens/sec vs naive. Write the number.
• Sec: Timed OA (in-memory DB + snapshot).
• Light: Draft “Why Anthropic” v2 (200–400 words). Include a disagreement.

Thu 09-17

• DW1: Live mock: file dedup or LRU with evolving constraints.
• DW2: RoPE implementation + test vs a known vector rotation.
• Sec: Values mock with a friend or a recorded self-debate on RSP v3: “they softened ASL-4/5 because unilateral SL5 security is currently impossible — is that honesty or a retreat?”
• Light: Anki catch-up.

Fri 09-18

• Close month-1 artifacts. Tag month-1.
• Write ARTIFACTS.md listing what exists and what is fake.

Sat 09-19

• 3h: Blank-file day — autograd + attention + train step, no notes.
• 3h: Read FlashAttention-2 (2023). List the 3 changes from FA1.
• 2h: Plan Month 2 (CS336 A2 / Triton FA). Order any cloud credits.

Sun 09-20 — off. Mon 09-21 (day 29): Polish public README. Record a 12-minute walkthrough of the GPT repo. Tue 09-22 (day 30): Month-1 exam, 6 hours, no notes:

1. (90 min) CodeSignal-style incremental system.
2. (90 min) Implement MHA + GELU MLP + residual + LN + generate, train 100 steps on a tiny corpus.
3. (60 min) Written: Core Views + CAI + RSP v3, one page each, closed book.
4. (60 min) Voice: Why Anthropic + one disagreement + one real mistake.
5. Score yourself with the failure-mode lists in §1. If you fail 2 or more sections, Week 5 is a redo, not CS336 A2.

Month-1 exit criteria (all required):

• Public repo: autograd, GPT, tokenizer, at least one trained loss curve, KV-cache speedup number.
• 8+ timed incremental systems in a oa/ folder.
• Core Views critique + CAI diagram + Why-Anthropic v2.
• One profiler artifact (even CPU PyTorch profiler).
• SPAR submitted (if eligible) or a written reason you are not.

You are not ready to apply. You are ready for Phase 1 proper.

5. Artifacts required before applying

Do not apply with “projects in progress.” The careers page says to put independent research, a blog post, or OSS at the top of the resume. They mean it.

Repos worth contributing to (pick one stack and go deep):

• Kernels: Dao-AILab/flash-attention, triton-lang/triton, NVIDIA/cutlass, HazyResearch/ThunderKittens, gpu-mode lecture kernels, KernelBench
• Inference: vllm-project/vllm, sgl-project/sglang, ggml-org/llama.cpp
• Training: pytorch/pytorch (compiler / inductor), deepspeedai/DeepSpeed, NVIDIA/Megatron-LM
• Interp / safety (RE track): TransformerLens, SAELens, nnsight, Anthropic’s published interp tooling
• Not worth: typo PRs to transformers; another ChatGPT wrapper

Nelson Elhage’s public path (kernel → Stripe → Anthropic interp → pretrain) is the existence proof that systems people can move. Your resume should look like a smaller version of that thread, not like a bootcamp certificate.

6. Compute and mentors without a lab job

Compute (cheapest honest path)

1. Local: 4090/5090 is enough for nanoGPT, Triton FA on realistic head dims, and first CUDA. Not enough for “I trained a 7B.”
2. On-demand, 2026 street prices: RunPod H100 PCIe ~$2/hr; Lambda H100 SXM $3.99/hr, A100 40GB $1.99/hr, A100 80GB $2.79/hr. CoreWeave is for reserved multi-node, not you yet.
3. Budget for the year (SWE track): ~$800–1,500 if you are disciplined. Spend it on (a) one real multi-GPU weekend, (b) 8 H100 hours of Nsight, (c) a 7B LoRA/SFT if you need post-training numbers. Do not leave instances up.
4. Grants:

• Lambda research grant — up to $5k, application, not a promo code.
• NVIDIA Developer Program (free) → Academic Grant if you have a faculty sponsor (up to tens of thousands of H100 hours). If you are not faculty, find a co-author who is.
• TPU Research Cloud — free TPUs, different stack, still a systems artifact.
• Anthropic Fellows — ~$15k/month compute + $3,850/week stipend, 4 months, US/UK/CA work auth, no visa. Tracks now include ML Systems & Performance. This is the actual on-ramp. Watch application windows (2026 cohorts have been spring/summer/fall; next advertised start late Sep/Oct 2026).
• MATS — $5k/mo + $8k/mo compute, Berkeley/London. Autumn 2026 closed Jun 7. Next cycle is the one you build artifacts for.

1. Do not: scrape someone else’s cluster, mine leftover Colab sessions as if they were an H100, or put “trained on H100” when you trained on T4.

Mentors

Ranked by expected value for this specific goal:

1. SPAR — deadline today 2026-08-18. Part-time, remote, real mentors, Demo Day to the safety hiring network.
2. Anthropic Fellows (ML Systems & Performance) — closest thing to an external intern on the kernel team.
3. MATS — alignment-heavy; some systems mentors. Apply next cycle with artifacts 1–5 in hand.
4. GPU Mode Discord — the actual kernel peer group. Post profiles, get roasted, ship.
5. ARENA — structured mech-interp + ML. Good for the RE/safety half, not for CUDA.
6. Public office hours / paper clubs: Stanford CS336 materials are enough of a course. Do not pay $5k for an “AI lab interview coach” until you have artifacts; Sundeep-style coaching is a Phase 5 spend, not a Phase 0 spend.
7. Cold email with a kernel and a question, not a resume. Hume’s team has hired off Twitter + a take-home before. performance-recruiting@anthropic.com is a published door.

You will not get an Anthropic staff engineer as a weekly mentor by asking. You get one by showing up in SPAR/Fellows/GPU Mode with work.

7. Red flags — how people fake-study this and fail

1. LeetCode as the plan. The OA is a growing system. The live round is a crawler / image pipeline / stack-trace. Hard LC is not the filter. Several Glassdoor RE candidates who “do medium-hard in 20 min” scored ~50% on CodeSignal.
2. Watching Karpathy instead of training. Interviewers ask about your loss curve, your tokens/sec, your bug.
3. CAI recitation. Values interviewers have heard HHH 400 times. They want a disagreement and a live update.
4. STAR stories. Officially the #1 culture-round failure mode.
5. “I hit the memory wall” on the take-home. That is the midpoint, not the finish. Claude does this too.
6. Nsight screenshots from a blog. They will ask what you changed and what occupancy did.
7. Typo-PR OSS. Worse than none — it signals you do not know what “contribution” means.
8. Applying as Research Scientist because it sounds smarter. Careers page: if you are an engineer, apply as an engineer.
9. Safety as branding. “I care about safety” + no RSP v3 critique + no experiment design = reject after a passable coding loop. The Staff 2025 candidate was told this in the recruiter screen.
10. Confident completion past knowledge. They will walk you to the edge of a topic you named. “I don’t know, here is how I would find out” is a pass signal. Filling the gap is a fail signal.
11. 12 hours of papers, 0 hours of body. This plan dies in week 5 if there is no walk/gym and no Sunday. The interview is a 5-hour verbal exam. Exhausted people fail values first.
12. Delegating the take-home to Claude and not being able to steer. Hume redesigned the live take-home specifically because Opus 4.5 ties the best 2-hour human. The new one tests your tooling judgment.
13. Ignoring team match. People “pass the loop” and sit 6 weeks. Keep other processes warm (OpenAI, GDM, Thinking Machines, SSI, kernel roles at GPU-mode companies).
14. Reapplying in 3 months with the same resume. 12-month cooldown unless a material artifact exists.
15. Studying interp Twitter instead of writing a kernel or a training loop. For the role you named, a Triton FA + take-home beats 20 Alignment Forum posts.

Immediate actions (this week, 2026-08-18 → 08-24)

1. Submit SPAR today if eligible.
2. Create the public repo. Write the Why-Anthropic draft.
3. Install the toolchain. Clone the four repos in §4.
4. Block the calendar: 07:00–20:20 PT, Mon–Sat, starting Monday 2026-08-24. Sunday off.
5. Do not apply to Anthropic in 2026 unless you already have artifacts 1, 2, 3, and 6. A premature application burns the 12-month clock.

If you are the strong-SWE / weak-ML person this 30-day plan was written for: you are in Month 1 of ~16. The first interview-shaped week is Week 3, not Week 1. The first application-shaped month is autumn 2027.