What Happened When Claude Tried to Write an OS Kernel

Summary

The video documents an experiment in which Claude Code was asked to build a small operating-system kernel in Rust and then tested in the QEMU computer emulator.

What a kernel must do

The narrator uses five functions as a checklist: run programs, keep them isolated, share CPU time, manage memory, and respond to hardware events.

Building the kernel

Starting from a fresh Rust setup, Claude produced about 700 lines of code and booted the kernel in QEMU on its first attempt. The basic shell worked, including handling a deliberate page fault and displaying CPU registers. This initial run took about five minutes.

In a separate sandbox, Claude expanded the kernel with 64-bit operation, paging and a heap, a timer and scheduler, and a keyboard shell. Further requests added user mode, system calls, disk and file-system support, programs loaded from disk, and four emulated CPUs. The final kernel was about 3,800 lines of Rust and took roughly 31 minutes, with an estimated API cost of $5.

Demonstrated features and stress testing

User programs could run in restricted “ring three” mode. Intentionally crashing a program did not bring down the kernel. The scheduler alternated between tasks, and the kernel handled a double fault using a spare stack.

The narrator also ran 250 programs over five minutes on four emulated CPUs, including 100 designed to crash. The kernel stayed up, and reported memory use at the end matched its starting level. All tests were performed in QEMU; the narrator did not test the kernel on real hardware.

Bug found

The kernel’s help text promised a page-fault test, but the test used a non-canonical address, which caused a general-protection fault instead. The kernel reported the fault correctly, but Claude had not run its own test and left the incorrect label in place. The narrator identifies this as the main mistake found.

Comparison with existing work

The narrator compared the generated code with the Rust Blog OS tutorial. At most 2.5% of the lines matched, and those were common Rust or kernel-building boilerplate. The agent made no web searches during the runs. The narrator concludes that the result was likely recalled from learned material rather than copied from that tutorial, while noting that only that one tutorial was checked.

The video also contrasts this small, QEMU-only kernel with Linux, which is vastly larger, and discusses an Anthropic compiler project involving many agents, sessions, and substantial API costs. The broader point is that a kernel that boots and passes selected tests is not necessarily correct: concurrency, code review, and real-hardware testing remain important.

People, software, and references

• Main narrator: Context.md, who describes the setup, runs the tests, and evaluates the results.
• Software being evaluated: Claude Code, which generates the kernel.
• External references discussed: The Blog OS tutorial, Linux, and an Anthropic write-up about a Rust compiler project.

The video is an experiment and testing walkthrough, not a step-by-step build tutorial.