By September 16, 2026, DeepSeek engineer Shengyu Liu was publicly describing a future in which AI does much more than help read code or fix bugs: it writes and tunes the GPU kernels that make large AI models run efficiently. His forecast is personal—AI-written kernels could match or surpass his own work within six to 12 months—but a separate NVIDIA experiment shows that a narrower version of this workflow already works.
What Shengyu Liu is forecasting
A GPU kernel is a focused operation that a model executes repeatedly. Matrix multiplication, attention, quantization and expert routing each rely on kernels whose memory access, tiling, numerical precision, thread mapping and synchronization can affect how quickly the system processes data.
Liu says AI’s role in this work has advanced in roughly a year from documentation, code reading and debugging to inspecting CUDA, PTX and SASS—the programming and machine-code layers used to control NVIDIA GPUs—while analyzing instruction stalls and optimizing operators.
His forecast is specifically about AI-written kernels matching or exceeding his own work. He also expects the human role to shift toward directing agents, defining objectives and judging their output rather than manually writing every low-level operation. That is a change in the work process, not a general employment projection.
Why GPU kernels matter to AI speed
Large models do not run as one indivisible program. They execute chains of specialized operations, often across thousands of repeated calculations. A kernel that moves data more efficiently or uses the GPU’s arithmetic units more effectively can reduce the time spent on a critical part of training or inference.
That is why kernel engineering sits below the model interface but remains central to the user experience. Better operator execution can affect how quickly a model begins producing tokens and how much hardware is needed to serve it. The gains depend on the operation, model architecture, numerical format and GPU generation; there is no single DeepSeek-wide speedup that applies everywhere.
DeepSeek’s public software projects illustrate the breadth of this work. TileKernels contains TileLang-based kernels for gating, mixture-of-experts routing, quantization, transpose, Engram and manifold hyper-connection operations. Its listed environment targets NVIDIA SM90 or SM100 GPUs and requires Python 3.10 or newer, PyTorch 2.10 or newer, TileLang 0.1.9 or newer and CUDA Toolkit 13.1 or newer.
The workflow that is already demonstrated
NVIDIA described a verifier-driven experiment using DeepSeek-R1 to generate attention kernels. The model receives a prompt, produces candidate CUDA C++ code, and passes that code to a verifier. If the candidate fails the criteria, the prompt is refined and the loop tries again; an accepted candidate becomes a GPU-optimized kernel for Hopper hardware.
| Workflow stage | What happens | Supported result or condition |
| Prompt | DeepSeek-R1 receives a description of the kernel task | The model generates candidate CUDA C++ code |
| Verification | A verifier checks the candidate against numerical and performance criteria | Failed candidates trigger prompt refinement |
| Iteration | The model receives the modified prompt and generates another candidate | NVIDIA describes a closed-loop run lasting 15 minutes |
| Evaluation | Generated kernels are tested on KernelBench problems | Numerical correctness reached 100% for Level 1 and 96% for Level 2 in the reported experiment |
The numbers are impressive, but they answer a narrow question: whether the generated kernels produced numerically correct results under the stated KernelBench workflow. They do not measure every production workload, GPU architecture or optimization objective.
From writing kernels to directing agents
The practical shift Liu describes is easy to picture. An engineer could define the operator, hardware target and performance criteria, then let an agent generate multiple implementations. The engineer would still need to choose useful objectives, interpret profiler output, reject incorrect results and decide whether a faster kernel preserves the model’s numerical behavior.
That human-machine division is already visible in NVIDIA’s experiment: the model generates code, but the verifier supplies the acceptance test and the workflow determines when a candidate is usable. The hard part is not merely producing source code. It is connecting code generation to reliable measurement and rejecting solutions that are fast but wrong.
Liu’s account also puts a human cost on that transition. The hands-on pleasure of spending an afternoon writing kernels, he says, could give way to supervising an automated search. The craft may change before the underlying need for specialized knowledge disappears.
DeepSeek’s wider optimization ecosystem
Kernel generation is only one layer of DeepSeek’s systems work. DeepGEMM is associated with FP8 matrix multiplication, while TileKernels organizes specialized operations used in model execution. The broader engineering picture includes low-precision arithmetic, mixture-of-experts routing and hardware-aware execution.
That context matters because model efficiency rarely comes from one clever code fragment. Architecture, communication scheduling, memory movement, numerical precision and kernel implementation interact. A generated attention kernel can be useful inside that stack, but its value still depends on the model and hardware around it.
For now, the clearest dividing line is between a demonstrated toolchain and a much broader prediction. NVIDIA has shown a verifier-driven process that generated numerically correct kernels on a defined benchmark. Shengyu Liu expects that kind of assistance to reach the level of his own kernel work within six to 12 months.
