Not by humans. Not by AI.
On April 22, 2026, Sundar Pichai, CEO of Google, said that 75% of all new code at Google is now AI-generated and approved by engineers, up from 50% the previous fall. On September 23, a survey of 800 U.S. developers and engineering leaders ranked reviewing and validating AI-generated code as the top bottleneck in their pipelines. This paper credits the first figure as a real achievement in producing code. It then names the assumption both figures share: that the hardest problems in software are problems of how much code can be written, and how well. They are not. They are problems with code itself, and changing who writes it does not change what it is.
At Google, the share of new code generated by AI went from roughly a quarter in October 2024 to half by the fall of 2025 and three quarters by April 2026. Pichai described the workflow as agentic: engineers now supervise systems that write, rather than writing themselves. This paper credits that trajectory plainly. In two years, the cost of producing a line of code has fallen further than most of the discipline expected.
Five months later, a survey from the code-quality company Qodo, conducted by Censuswide among 500 U.S. developers and 300 engineering leaders at organizations using AI meaningfully in development, showed where the cost went instead:
Put the two together. The industry has made writing code nearly free and made knowing what that code does the scarce resource. That is not a tooling gap to be closed next quarter. It is what happens when the unit of work stays the same and the rate of producing it goes up.
If more code were the answer, the measurements taken as AI-generated code scaled would show the hardest problems receding. They show the opposite, or at best no change.
None of these results describes a bad model. Syntax is correct more than 95% of the time. What does not improve is everything that depends on context the author of the code did not have: the rest of the codebase, the threat model, the production environment, the priorities of the person who will run it. Better models write better code. No model can write code that knows what it will meet.
Every line of code is a decision about a situation that does not exist yet. It is written at authorship and run at execution. Between the two, the hardware changes, the data changes, the load changes, the user's priorities change, and the attacker changes. The code does not. It carries its author's assumptions into every situation it will ever meet.
That is why code needs more code. Drivers, hypervisors, compatibility layers, frameworks, orchestrators, monitors and patches each exist to reconcile a decision made early with a situation discovered late. A hypervisor is the clearest case: a layer of code whose job is to cover the gap between code written for one machine shape and the machine actually present. Before generative AI reached scale, CISQ estimated the cost of poor software quality in the United States at $2.41 trillion for 2022, with accumulated technical debt of about $1.52 trillion.
The human version of this story is old. In 1975, Frederick Brooks observed that adding people to a late software project makes it later. In 1986, in “No Silver Bullet,” he argued that no single advance in technique would deliver an order-of-magnitude gain, because the hard part of software is its essential complexity, not the labor of writing it down. Four decades of better languages, frameworks and practices bore him out. Each made writing code easier. None made code unnecessary.
AI changes the author, not the artifact. A model that writes code produces the same thing a person produces: a fixed route, decided before the facts. It produces it faster, in greater volume, and with authorship no one can fully reconstruct. Era 2 does not replace Era 1. It accelerates it.
| Who decides | When the decision is made | When the situation changes | |
|---|---|---|---|
| Era 1 Human-written code | An engineer | At authorship | Someone writes more code |
| Era 2 AI-generated code | A model, approved by an engineer | At generation, faster | A model writes more code, and someone reviews it |
| Era 3 Intent resolved by Essence® | Declared intent, governed by Meaning Coordinates | At execution, against the machine present | The same intent resolves differently. Nothing is rewritten. |
The discipline has pursued this for sixty years: structured programming, object orientation, type systems, testing, continuous delivery. Each was real progress. None changed when the decision is made. A better-written route is still a route, and it still fails the first time the terrain differs from the map its author had.
Generation is now cheap. Verification is not, as Paper 42 argued in The Verification Tax. The Qodo survey shows where the cost moved: to review. And review is inspection of a decision after it has been made. Governing the AI that writes code is still governing code, after the fact. Detection ≠ Determination.
The fix for code is not better code. It is not faster code. It is not code reviewed more carefully. It is resolving intent at the moment the facts exist.
A route works from the place it was drawn. A coordinate names a destination that can be reached from anywhere. Code is a route. Meaning Coordinates are coordinates: 256 published primitives for intent, a closed set whose value lies in the machinery that applies them, the way the value of the periodic table lies in chemistry.
The person declares priorities, such as time, energy and quality. The principles that govern execution are fixed. When the machine changes, the same intent resolves differently: the same source can be delivered at 4K to a 4K display and 8K to an 8K display, because each architecture is assessed at execution. Nothing is rewritten, because nothing was written.
This is also where Essence's measured results come from. On specific workloads, validated with AWS and Rowan University's Digital Engineering Hub on single GPUs, Chameleon® has run 20–114× faster with up to 99.7% lower power, on existing hardware. The gain does not come from better code. It comes from the absence of the stack that code required.
PowerAptivs are one of Essence’s eight Aptiv types, the type that executes; every Aptiv is built from Meaning Coordinates. Some PowerAptivs contain code. A careful reader will ask whether that is more coding by another name. It is not, and the distinction is the center of this paper.
| Trust level | What executes | Where it is used |
|---|---|---|
| Level 1 Coded Guard | Directive code authored outside the platform, chaperoned and governed by policy enforcement and testing | Legacy or third-party code that must run but cannot yet be converted to Meaning Coordinates |
| Level 2 AI-Governed Guard | AI-driven execution, with Essence controlling critical resources and bounding non-deterministic outputs | Where AI reasoning is needed inside the trust envelope |
| Level 3 Native Guard | Pure Meaning Coordinates. No code. Fully governed, fully ephemeral | The level at which Chameleon's performance results are produced |
A PowerAptiv Action defines what can be done and how it is verified. A Brand is one implementation of it. The Clock Action returns local time; an operating system API, a BIOS read and a network time service are all Brands of it, and Trust Tests keep them honest. Swap the Brand and the expression of intent does not change. Code enters as one interchangeable way to fulfill a declared intent, not as the thing that declares it.
PowerAptivs run on a never-trust-by-default model. Meaning Coordinates govern the code at the instruction level. SecuriSync™ decides whether it can run; Guard ensures it behaves while running. Zero ungoverned code. This is not a hypothetical posture: agentic AI is already being used by white hats, red teams, and black hats alike, and that roster now includes rogue AI acting on its own initiative, without a human operator directing it turn by turn. Guard evaluates what an action does, not who or what proposed it, so the same enforcement holds regardless of which of these is on the other end.
Chaperoned code is how existing software, legacy systems, third-party libraries and APIs, joins the substrate without being rewritten. Elevate wraps APIs and even LLMs so they become Aptivs. That is assimilation, not authorship. The first answer to a new capability is not new code: it comes from declared intent, and from experts encoding what they know as Aptivs. That allows for choice, though. MindAptiv doesn't dictate the solution, and sometimes the answer will be new code: MindAptiv has used Chameleon® to generate new code itself. Some customers require deliverable source code outright (a military application, for instance, where inspectable, deliverable code can be a contractual or sovereignty requirement) and MindAptiv builds to that requirement rather than arguing around it. Even there, an Aptiv remains the better architecture: deterministic and governed by Meaning Coordinates, not a probabilistic agent guessing at intent. The direction of travel is toward Level 3.
Code can live inside Essence. The first answer to a new problem is no longer new code.
Every application ever built was a workaround. Code was the best approximation available for a gap between human intent and machine execution that no one could close directly. Handing the approximation to a faster author does not close the gap. It widens it at machine speed.
The answer to the hardest problems in software is not more code.
Not by humans. Not by AI.