Engineers across the globe are having an identity crisis. If agents write the code, what will our job be? It’s a discussion that has been going on for months.
One thing is clear: coding is no longer for humans. Coding agents write faster and, yes, better code than humans ever did. That was definitely a controversial statement in November, but it’s reality today. Over my career, I’ve seen many code bases, and despite all the Clean Code posturing online, most code is just… adequate. Teams shipped messy, convoluted systems without test automation. They abandoned a migration to a new framework halfway and ended up maintaining a worst-of-both-worlds solution. They copy-pasted StackOverflow code and approved huge code reviews without reading them. There has always been pressure to ship on time at the expense of quality.
Until now.
Agents, with the right guidance, deliver way better. They can ship a backlog faster than we can fill it up. Writing code has been automated, and those who haven’t come to terms with it yet, will over the coming months.
The more interesting, contemporary debate is on the other side of the coin: if agents write the code, will humans still read it?
A few months ago, my answer would have been “Most likely”. It felt dangerous merging changes into a product without a human in the loop. It is, however, becoming exceedingly clear that reading the code is going the way of the dodo too. The idea of human-in-the-loop becoming human-as-a-bottleneck is just unacceptable. By 2027, most of us will trust the agents enough to handle all the coding autonomously.
That sounds scary today, but it doesn’t have to be. Reading code is just one way of understanding what a system does and what the impact of a change is. We need to uncover better ways.
We’ll expand test automation like never before. When coding is automated, there is no excuse to skip generating tests. Our agents will apply TDD practises to keep the code testable, and our workflows will measure their code coverage while verifying unrelated tests haven’t been changed. That will give us better test automation than what humans could realistically build.
Our code reviews will be completely automated. Most teams already have some automation today, but still stick to the traditional human code review. That will end. Agents will check for bugs and conventions. They will automatically adapt the code in seconds rather than waiting days for approval.
Human testing will come in the form of exploratory testing rather than checking acceptance criteria. Agents can verify whether the system is behaving as specified. Humans will test whether there is functional room for improvement. The role of tester will be much more product-minded.
Humans will come up with other ways of learning and sharing knowledge about the system. Automated documentation, demos, digests or quizzes will keep track of whether we still understand the system. We’ll dive into the codebase from time to time to look for architectural improvements and opportunities for redesign. We will obsess about logging and metrics to get a good feeling for when the machine starts sputtering.
Building software is not a mass production system. Every software product is bespoke, and if Jevon’s Paradox holds, we’ll see an explosion of products. I don’t think we will see Light Out Manufacturing of software any time soon.
But coding is a soon-to-be automated part of software engineering. Just like “compiler” used to be a job, humans will hand off coding to machines that are far better suited for it. We need to prepare for that. The system where humans double-check the agent’s output is a very, very temporary one.
We will need to figure out better ways to guarantee that the system does what it is supposed to do without screening every single output token.
Exciting months ahead!
