It's 2026, and the hype around memory safety is deafening. The industry consensus seems to be that C and C++ are archaic, "unsafe" languages that we need to abandon immediately. There is a growing chorus pinpointing that the majority of CVEs (Common Vulnerabilities and Exposures, the standard system for cataloging publicly known security flaws), from databases to the Linux kernel and even Git, stem from memory issues like buffer overflows, double frees, and null pointer dereferences.

According to the mainstream, Rust is the holy grail, and everyone must migrate immediately. Even DARPA has launched the TRACTOR program, advocating the use of AI to convert legacy C code into safe Rust.

Don't get me wrong; I believe that for certain systems, Rust and its memory safety guarantees are the right choice. If you are building a high-level modern framework or working on software where absolute control over the hardware isn't the primary bottleneck, Rust is a fantastic language.

The Cost of Abstraction

However, the rush to abstraction misses a fundamental truth: the CPU executing your code doesn't change. At the physics level, the machine is still fetching, loading, storing, and executing. Rust provides safety by making the human feel safe, but abstraction always comes with a cost.

When you hide memory details, you tend to assume the code works "magically." You start to believe that memory management is no longer necessary. This creates a disconnect from the physics of the machine. We see this in web development constantly: because memory is abstracted away, the solution to performance problems is rarely "tune the code" or "understand the processor datasheet." Instead, developers just throw more CPUs and more RAM at the problem because hardware is viewed as cheap.

Why I Am Doubling Down on C

So, why am I going against the grain and sticking with C? It has everything to do with the advent of modern AI.

The capabilities of AI in 2026 are beautiful, and they solve the very problems that made C "difficult" in the past. Just as I now exclusively use Linux for my work, I use AI to bridge the gap between code and hardware.

With AI, you don't need a heavy abstraction layer to be safe; you can use intelligence to understand the deep end. You can ask AI to explain complex concepts, such as:

  • How does the cache hierarchy actually work?
  • How do execution units function and how does data flow through them?
  • How should I allocate memory for maximum cache locality?
  • How does the CPU actually fetch and compute this specific block of data?

AI as the Ultimate Toolchain

In the past, testing C for memory leaks was tedious. Now, AI can write the test scripts for you. It can generate performance evaluation scripts, build tools, and make testing a first-class citizen in your workflow.

This makes C even more powerful than before. You get the biggest win of all: closeness to the physics.

In C, you can do objdump to see the actual assembly generated. You can see exactly how your memory is laid out. Why would you want to hide that away behind a compiler abstraction when AI can help you investigate, monitor, and master those bottlenecks? AI allows you to learn the "hard stuff" at a depth previously reserved for compiler engineers.

Real World Application

For me, this isn't just theory. I've been using this approach to build:

  • A WordPiece tokenizer in pure C.
  • A law processing engine with point-in-time parsing, extracting chunks, converting to tokens, creating embeddings, and storing vectors; using NUMA and MPI for distributed computing of document processing.
  • An implementation of GPT-2 in C with PyTorch-validated inference.
  • A kernel engine for LLM workloads, tuned for CPU with AVX2/AVX-512.

I feel like I am just getting started. And I'm in good company. The world still runs on C. Linux, Git, Nginx, Postgres, SQLite, Node.js, llama.cpp, Intel OneAPI, CUDA, OpenGL, and virtually all embedded systems, from medical devices to avionics to your refrigerator, are mostly C.

With AI satisfying our curiosity and removing the fear of the low-level, C becomes not just a language of the past, but a superpower for the future.