What Happens When Software Writes Software?

Programming has a property that most work lacks: it grades itself. Code compiles or it does not. Tests pass or they fail. A program that crashes announces the fact. This is why software became the first domain in which AI agents were genuinely useful rather than merely impressive.

The progression was fast. In 2021 the tools suggested the next line. By 2023 they wrote functions from a comment. By 2025 an agent could read a bug report, locate the relevant files in an unfamiliar codebase, make a change across several of them, run the tests and open a proposed fix for review. Benchmarks built on real repositories recorded the improvement from a few percent of tasks solved to a majority.

The review bottleneck

The limit now is not writing code but reading it. A reviewer who once examined a colleague's afternoon of work now faces an agent's afternoon of work, which may be ten times larger and arrives with the same confident tone whether it is right or wrong. Teams report spending the time they saved on writing on reviewing, and some report a net loss on tasks where the agent's approach was subtly misguided.

This has produced a new category of engineering practice: designing tasks, tests and constraints so that an agent's output can be trusted without being read in full. It resembles the discipline of managing a large team more than the discipline of programming.

The apprenticeship problem

Senior engineers are made from junior engineers who spent years doing the kind of work agents now do. If that work disappears, the pipeline that produces judgment may thin out. Employers in this scenario describe hiring fewer juniors; universities describe redesigning curricula around reviewing and specifying rather than writing.

Nobody knows yet whether reviewing machine output teaches the same things that writing did. The history of other tools, from compilers to high-level languages, suggests that what counts as fundamental skill shifts rather than disappears. It also suggests that the shift takes a generation to settle.

Who builds, then

The most consequential effect may be on who gets to build software at all. People with a clear idea and no training can now produce working programs. Most will be small, many will be bad, and some will be the kind of tool that no professional would have been paid to build. Whether that broadening of authorship outweighs the costs of maintaining a world of software nobody fully understands is the open question of the next decade.