Addy Osmani argues that the key to agents writing code that is “better on average at scale” is validation, because agents make checking cheap. The tests, benchmarks, specs, and real end-to-end runs that used to make “good code” expensive can now be handled directly by agents, so the focus shifts from line-by-line review to building loops the agent can run on its own, giving it the means to verify its work. He also suggests writing the mistakes an agent has made into shared config, hooks, or tests so the experience compounds. Humans are still accountable for shipping, but they look at evidence rather than just the diff.
Addy Osmani proposes that quality in the agent era comes from validation loops that can run automatically, not line-by-line review, and lays out how to let experience settle into config and tests.
Agents write code "much better on average at scale" is right. The "at scale" part comes from verification. Agents make checking cheap.
The stuff that made "Good Code" expensive (tests, benchmarks, specs, real e2e runs) is now a cheap thing you can ask an agent for. You can improve the checks.
So our work is less "review every line" and more "build loops the agent can run itself". Give the agent a way to verify the work. That loop is where quality comes from.
And make taste compound. When the agent gets something wrong, write it down (shared config, a hook, a test) so it doesn't happen twice. A human still owns what ships but now they're reviewing evidence and not just diffs.
codebases have always contained slop. we have always been okay with this because code rarely needs to be perfect, outside of mission critical "hard" (eg embedded) software. swe is a unique form of engineering because you're often building something that constantly evolves and is almost organic - user tastes change, your mental models evolve, and features come and go. admittedly, i and many others who've been coding for a long time were initially (like back in 2024) skeptical that agents would write production code. "but what about all the slop that would enter our beautiful codebase?". well, even before, we had human slop, and there was a lot of it! if we're being truthful, most people call "code i didn't write" slop. the reality is that 99% of people (i include myself in that number) don't even know what Good Code looks like, let alone be capable of writing it. i would propose that Good Code is: • correct • bug free • fast and cost efficient to run it has always been exceedingly difficult and expensive to write truly Good Code, because for the longest time (maybe @bendlang will change that), code was not something you could cheaply and formally guarantee to have all 3 of these properties. this is why writing hard software is much more difficult and expensive, because depending on the use case, you may only get one chance and so you have to be right from the start. but the vast majority of software we use does not need to be Good Code to provide value to users. in fact, it is very likely that most software we use is not formally verifiable! we accepted some bugs in exchange for velocity and progress, so we rely on tests and o11y instead and have adopted a more incremental approach. this is a good thing! agents help us move faster, and if you're open to the idea, are capable of helping us write better code. it won't be Good Code (that is still expensive), but it is likely to be much better on average at scale. the new craft of swe is to figure out how to do this. it's your job now! if your productivity with and without agents is not significantly different, you're doing something wrong. but it's not too late to embrace it and use it as an opportunity to learn a whole new skill treeView quoted post on X
Source: Addy Osmani · x.com