When Most of the Code Is AI-Written

Current practice, 2026

A team saying most of its code is now AI-written sounds like engineering got smaller. It did not.

I run an org where that sentence is true. Most of the code that lands in our repos now comes out of a model, and the engineering did not get smaller. It got harder to see, because the part that shrank was the part everyone could count.

That number measures keystrokes

The "percent AI-written" figure counts the lines that landed in a commit from a model versus the lines a human typed. AI is very good at the high-volume work: boilerplate, test scaffolding, CRUD, obvious refactors, first-pass implementations. That is useful. Very useful. A human reads it, accepts it, moves on, and the counter ticks up.

Lines of code were never a great measure of engineering work. AI just made that painfully obvious. If your dashboard says 70 percent of the code came from a model, what it is really telling you is that 70 percent of the typing was never where the value lived.

The short loop is close to solved. The long arc is not.

The agents made this sharper, not softer. They do not just autocomplete now. They plan a task, edit across files, run the tests, open the PR. Inside a well-bounded task, the short loop is close to solved, and I do not expect that to reverse.

But run them across the long arc, sustained work where mistakes compound over many commits, and the success rate falls off a cliff. The model is strong inside the task and weak about which task, in what order, against what architecture. It will build the wrong abstraction beautifully. It will pass every test you gave it and miss the one you did not know to write. It will not tell you the ticket should have been closed instead of implemented.

That dropoff is the whole story. It is why the constraint moved in my org from writing code to reviewing it, and why the queue now backs up at every point in the value stream where a human decision still has to enter.

The hard work is still the hard work

Strip out the typing and here is what is left:

• Is this the right thing to build?
• Does this architecture survive scale?
• Where are the PHI, PII, and data boundaries?
• What integration logic will bite us later?
• What should we accept, rewrite, or delete entirely?

None of those questions got easier. None of them show up in the AI-written percentage, because that number counts typing and these are decisions. In a regulated codebase, the data-boundary question alone is worth more than every line of scaffolding the model produced that quarter.

AI made producing code cheaper. It did not make judgment cheaper. In fact, the faster code gets generated, the more dangerous weak judgment becomes. Complexity does not wait for sprint planning anymore. It accumulates at machine speed, and complexity nobody owns is the most expensive kind.

AI did not shrink the need for senior engineering judgment. It made judgment the whole job. The headline says the machines are writing the code. The fine print says they still cannot tell you which code was worth writing.