What "kernel developer" means at Anthropic

Three meanings, all real. You need all three, with different weights depending on the req.

1. GPU / accelerator kernels (the literal job)

A kernel is a function launched on an accelerator: CUDA on NVIDIA, Pallas/XLA on TPU, Neuron on Trainium. Anthropic runs all three. The GPU PE role is the NVIDIA-shaped version of a job that is really "make the accelerator do the matmuls and memory moves that a frontier transformer needs, at a high fraction of peak."

The kernels that matter in 2026:

• GEMM (the 80% of FLOPs). Tensor cores. Layouts. Epilogues. CUTLASS / CuTe / cuBLAS internals as a mental model, Triton as the daily driver, raw CUDA when Triton cannot express the overlap.
• FlashAttention-class attention (IO-aware tiling, online softmax, backward). GQA/MQA/MLA variants. Decoding vs prefill (different bottlenecks).
• Normalization: RMSNorm fused with residual.
• Activations: SwiGLU fused with the GEMM epilogue.
• Cross-entropy / loss in low precision without wrecking the backward.
• KV-cache writes, paged attention, prefix-cache hits.
• Quantization: FP8, INT8, and whatever NVFP4 / MX formats the current SKU speaks. The hard part is not the cast. The hard part is accuracy + throughput + a correctness eval.
• MoE: grouped GEMM, expert-parallel dispatch, dropless vs dropped tokens.
• Collectives adjacent to kernels: all-gather / reduce-scatter overlapped with compute (TP), all-to-all (EP).

You are hired if you can take a roofline, a trace, and a wrong-looking kernel, and come back with a faster correct one and a model of why.

2. The model kernel (the thing the kernels implement)

Researchers will say "the kernel of the model" meaning the inductive bias: decoder-only transformer, residual stream, attention + MLP, RoPE, RMSNorm, SwiGLU, maybe MoE, maybe some linear attention / SSM hybrid. A PE who cannot derive attention, cost it (O(n²d) vs FlashAttention O(n²) IO vs decode O(n)), and know why Pre-LN + RMSNorm + RoPE is the 2024–2026 default will waste pairing time.

You do not need to invent architectures. You need to be the person a researcher can sit with and say "what if we change the attention score to X" and you immediately know whether that is a 5-line Triton change or a six-month kernel rewrite.

3. OS / compiler kernel thinking (the transfer)

Hume's take-home is not CUDA. It is VLIW + SIMD + scratch. The Trainium and TPU stacks are compiler-shaped (XLA, Neuron). The inference runtime role is Rust, accelerator-agnostic. The skill they are selecting is:

Given an execution machine with weird constraints, a correctness spec, and a profiler, reduce cycles without violating the spec. Build tools when the tools are missing.

That is the same skill as writing a Linux scheduler, a register allocator, or a CUDA kernel. CSAPP + a compilers course + a GPU course is the triangle.

Why this is AGI work (not infra-on-the-side)

Scaling is an empirical bet. Useful FLOPs per watt and per dollar decide how far a given cluster goes. A 1.3× end-to-end win on decode is a bigger capability unlock than most papers. Anthropic's own story of the take-home is: they had bought the machines for Opus 3 and did not have enough people who could make them go. Kernel work is on the critical path of the mission, not a support function.

You should be able to say that without sounding like you think GPUs are AGI. The research bet is still algorithms + data + alignment. Efficiency is how those bets get run at the scale where they become real.

What you will not be doing

• Writing product React
• Prompt routing
• Fine-tuning-as-a-service
• "AI engineer" glue

If that is the work you want, this path is the wrong path.