For thirty years a software team had two halves, and one of them cost far more than the other.
Developers wrote the code. Testers validated the code. In practice that was a person using the software the way you use it, clicking the buttons, making sure the transactions work, and when something did not work, taking a screenshot and sending it to the developers.
The expensive half was the writing. The most expensive thing in the whole lifecycle was hiring developers. If you paid people to type code by hand, that was the biggest number on the bill, and every decision a company made about software came out of that one fact.
Then the typing got cheap. Not a little cheaper.
A coding agent is the thing that made it cheap, so let me say plainly what one is. You type a sentence in ordinary English saying what you want the software to do. The agent writes the code for it, runs it, sees the errors, fixes them, and keeps going on its own until it decides it is finished. It is not a person and it is not a company you hire. It is a program you talk to, and it works while you sleep.
A good developer used to write around two hundred lines of code in a day. Now the same person opens an agent and twenty thousand lines come back. Measure it a different way and it is five hundred lines a day becoming fifty thousand. Either way you are looking at a hundred times more code arriving from the same person.
The price of the writing half collapsed. The checking half did not move, because nothing about a machine producing the code makes the question of whether it is correct any easier to answer. You still have to know what right looks like. You still have to go and look.
Far more code is arriving at the checking step than used to. And the software you used this morning worked fine, and so did the software you used yesterday. So how bad is it, really?
You cannot tell yet, and that is exactly the danger. Think of a virus in the body. The first day, there are no symptoms. The second day, no symptoms. The third day, no symptoms, and the whole time it is building up. Then one day it takes the person down.
That is where this industry is right now. Millions of lines of code have been written without proper validation and without proper testing, and the defects are sitting inside those lines somewhere, and nobody knows where, because nobody looked. The name for that pile is technical debt, and it is accumulating at a speed the industry has never seen before, because nothing has ever produced code this fast.
You can already see it coming out. Production is the live version of the software, the one real people are using with their real money, and production failures are showing up more often and hitting harder. Amazon mixed up tens of thousands of orders in a single day. Large companies go dark for hours.
So the bill inverted. We do not have a code writing problem, we have a QA problem. The problem is not the coding. The problem is that nobody knows, with any certainty, whether code being generated a thousand times faster is any good, and whether the application built out of it actually works. Writing code is not the problem. Validating code is the problem. That is the job of QA.