Custom Kernels for All: How Codex and Claude Are Rewriting the Future of AI Performance

For years, squeezing real speed out of a graphics processor was a job for a small, elite group of engineers. They wrote something called a custom kernel, a hand-tuned block of low-level code that tells the hardware exactly how to do its math. It is slow, painful, specialist work. Most companies simply could not afford it, so they accepted whatever performance the standard software libraries handed them.

That bottleneck is starting to crack. In February 2026, work published under the banner “Custom Kernels for All from Codex and Claude” pointed to a bigger shift: AI coding models are now being used to write and tune these low-level kernels. Not as a demo trick, but as a real path to making high-performance computing available to far more teams.

The headline sounds narrow and technical. The implication is not. This is a story about who gets to control performance in the AI era, and what happens when the hardest, most guarded layer of the software stack becomes something a normal developer can reach for.

What a Custom Kernel Actually Is (In Plain English)

Think of a graphics processor, or GPU, as a huge team of workers. Each worker is fast but simple. A program written for a GPU has to divide the job into thousands of tiny tasks that run at the same time.

A kernel is the instruction sheet for that team. It says which worker does what, when they read from memory, when they write back, and how they stay out of each other’s way. A custom kernel is a hand-written instruction sheet built for one specific job, rather than a generic one designed to handle everything.

The reason people bother is simple math. A well-tuned kernel can finish a task far faster than a general-purpose one, because it wastes fewer trips to memory and keeps the hardware busy. In AI, where the same few operations repeat billions of times, small gains at this level turn into large savings in cost, energy, and waiting time.

The catch has always been the skill required. Writing kernel code means thinking in threads, memory hierarchies, and hardware quirks. Few engineers can do it well. Fewer still can do it well across different chip families. That scarcity is why performance tuning has long been a moat for big labs and a wall for everyone else.

The Shift: AI Models Writing the Lowest-Level Code

What the Codex and Claude work signals is a change in who can do this work. Codex and Claude are AI coding assistants, systems that read and write software. Historically, the safe advice was to let them handle boilerplate and leave performance-critical code to humans.

That advice is aging fast. Modern coding models have absorbed enormous amounts of public code, documentation, and performance discussions. They can reason about memory access patterns, suggest faster loop structures, and produce kernel variants that a human then checks. On top of that, they can generate many candidates quickly, and speed work rewards trying many candidates.

Put simply: the scarce resource in kernel tuning was never ideas. It was the human hours needed to write, test, and compare versions. AI collapses that cost. A task that once took a specialist a week of careful iteration can be explored in a day by a small team supervising a model.

Why “for all” is the important part

The phrase custom kernels for all is the real story. It reframes kernel writing from a black art into a routine engineering task. If the pattern holds, the winners are not just the frontier labs. They are the mid-sized AI companies, the research groups, the robotics startups, and the enterprises running inference at scale who never had a kernel team.

Consider what becomes possible when performance tuning stops being a special project:

• Smaller teams compete on speed. A startup can tune its own models instead of paying a premium for someone else’s optimized stack.
• Hardware choices open up. Tuning code for a specific chip is expensive; automating it makes switching chips realistic. That weakens lock-in and strengthens competition among chip makers.
• Cost curves bend. Faster kernels mean fewer chips doing the same work. For anyone paying per hour of compute, that is a direct line to the bottom line.
• Energy use drops. Efficiency at the kernel level translates into real electricity savings across data centers.

Why This Matters for the Future of AI

There is a tempting but wrong way to read this news: as a nice productivity boost for engineers. The deeper point is that AI is starting to improve the machinery that runs AI. That is a feedback loop.

The software layer is now the fastest-moving advantage

Chip design takes years. Software takes weeks. When AI can write and refine performance code, the fastest gains in AI capability may come not from new silicon but from better software running on existing silicon. That shifts the balance of power. Companies with strong engineering culture and good evaluation pipelines gain leverage over companies that simply buy the most hardware.

It lowers the floor for entry

Every technology that becomes cheaper and easier spreads wider. Custom kernels moving from specialist craft to assisted workflow means more people building faster AI systems in more places, universities, hospitals, regional firms, public sector teams. That is usually good for innovation, and it is also a governance question, because capability that spreads cannot be recalled.

It makes portability a real strategy

If tuned code can be regenerated for a new chip family in days rather than months, then “which hardware do we run on?” stops being a decade-long commitment. Markets work better when switching costs fall. Expect buyers to demand more from vendors, and expect vendors to compete on how easy they make it to leave.

The human role becomes review, not typing

The most durable change is in job design. Kernel work becomes less about writing every line and more about specifying intent, setting up benchmarks, and judging results. That is a different skill, closer to a senior reviewer than a code typist. Teams that build that muscle early will move faster than teams that keep treating low-level performance as a specialist-only zone.

Practical Implications for Businesses

Most organizations are not writing GPU kernels today. That does not mean this trend passes them by. Here is where it shows up in practice.

1. Cloud and inference bills

If a meaningful share of your AI spend goes to inference, kernel efficiency is a direct cost lever. Every percentage point of speed recovered is money not spent. Ask your vendors whether they are using AI-assisted tuning, and ask your own engineers whether they have benchmarked alternatives.

2. Vendor negotiations

Performance claims are about to get harder to verify. When anyone can generate a tuned kernel, benchmark results matter less on their own and more in the context of your workload. Insist on tests that mirror your data and your traffic patterns.

3. Build-versus-buy decisions

Work that was previously “too specialized to do in-house” deserves a fresh look. If the cost of custom tuning falls, some projects you outsourced may become worth owning again, and the reverse is also true, so revisit the assumption rather than the conclusion.

4. Talent strategy

The engineer who can read a model’s suggested kernel and know instantly whether it is correct is more valuable than ever. Hire for depth in systems and hardware reasoning, not for memorized syntax. Pair that depth with people who can design rigorous tests.

The Risks Nobody Should Skip

Speed does not equal correctness. Kernel code is unforgiving: a subtle memory bug can produce answers that look plausible and are quietly wrong. In consumer software that is annoying. In a medical model or a financial system, it is dangerous.

Three guardrails matter most:

• Test against a trusted reference. Every AI-generated kernel should be checked against a slow, obviously correct version on many inputs.
• Measure, do not trust. A model’s claim of a speedup means nothing until it is benchmarked on your hardware, your data shapes, and your real workload.
• Keep humans in the loop on the hard parts. Memory safety, numerical precision, and edge cases are exactly where assisted code needs expert eyes.

There is also a subtler risk: uniformity. If everyone tunes with similar models trained on similar code, teams may converge on similar solutions and miss unconventional approaches. Diversity of method is a form of resilience.

Actionable Steps to Take Now

You do not need to start a kernel project tomorrow. You do need to stop treating this layer as off-limits.

• Benchmark one real workload end to end. Pick your most expensive recurring job and find out where time actually goes. Many teams are surprised to learn it is not where they assumed.
• Run a small pilot. Have a coding assistant propose optimizations for a well-understood piece of performance-critical code, then review and test it the way you would review a junior engineer’s work.
• Build an evaluation harness before you need it. Correctness checks and repeatable benchmarks are the real infrastructure of AI-assisted performance work.
• Update your review process. Define who signs off on low-level AI-generated code, and what evidence they must see.
• Revisit hardware assumptions annually. As tuning gets cheaper, yesterday’s locked-in decision may become tomorrow’s avoidable cost.

The Bigger Picture

The story here is not really about kernels. It is about a pattern that keeps repeating: AI tools take a skill that used to be scarce, expensive, and guarded, and turn it into something a broader group of people can attempt with supervision. Writing, translation, design, and now low-level performance engineering have each moved along that path.

Each time, two things happen. The old gatekeepers lose pricing power. And the total amount of work attempted goes up, because the cost of trying fell. That second effect is usually larger than the first. More teams tuning more code for more chips means faster, cheaper, and more varied AI systems, built by more kinds of organizations than before.

Custom kernels for all is a technical milestone with a strategic meaning. The performance layer of AI is becoming contestable. For businesses, that means new options and new obligations: cheaper compute, more vendor choice, and a much shorter list of excuses for not measuring what your AI actually costs to run.

The teams that treat this as a process problem, testing, benchmarking, reviewing, will capture the gains. The teams that treat it as magic will get fast code they cannot trust. The difference will show up on the balance sheet.