Benoit Schillings warns human-written code is reaching its end

Writing syntax is solved. Benoit Schillings, Vice President of Research at Google DeepMind, argues that the era of battling compiler errors and manually writing code blocks is over. Software engineering has evolved through distinct phases. First, developers fought machine limits with assembly language. Next, they fought human memory limits during the internet era by building modular libraries. Now, we have entered the artificial intelligence era, where generating syntactically perfect code is effectively free.

But writing code is not software engineering. The real challenge has shifted. Real engineering means walking into a company with 35 million lines of legacy code and understanding how to modify it safely. It requires high-level system design and architectural foresight. While models like Gemini can produce flawless isolated functions on demand, they still struggle with broad, multi-step codebases. Humans must step up as architects, focusing on systemic implications rather than simple syntax generation.

Self-Play and the Data Saturated Frontier

How do we train models when we run out of human examples? The industry has hit a wall. Roughly 80 percent of new code pushed to GitHub is now machine-generated. This means mining public repositories for human-written training data has reached its natural limit.

To bypass this limitation, Google DeepMind relies on self-play. This technique mirrors the training of Alpha Zero, which became a superhuman chess and Go player by competing exclusively against itself. Code models can now generate their own programming challenges, compile the results, run unit tests to verify the outputs, and evaluate their own architectural decisions. This closed-loop verification allows models to log millions of hours of virtual practice without human intervention.

Free Code and the Security Crisis

When writing code becomes nearly free, the sheer volume of software will explode. This shift has massive economic implications. We are transitioning to a world where we write code but rarely read it. Just as engineers today do not inspect the raw assembly output of C++ compilers, developers will soon stop reading the source code generated by AI models.

This explosion demands active guardrails. Finding security vulnerabilities in existing systems is a reactionary, endless cycle. Instead, researchers are trying to teach models to write correct, secure systems from the absolute start. This requires inductive reasoning—taking concepts from different fields and synthesizing them to predict failure points before they are compiled.

Designing a Language Just for Machines

Perhaps our current tools are the problem. Popular languages like Python were built for human readability. Because humans no longer need to write the code, we can discard these design constraints.

We need strongly typed, mathematically verifiable languages designed specifically for AI. These systems do not need to be human-readable. If we shift the burden of absolute proof onto the model, we can enforce correctness at the compiler level. By letting go of our human biases, we can build software that is inherently secure and structurally sound.