The volume is still you
Published
Lauren Tan posted that codebases were always slop. Her point was that agents can actually raise the average, and that you can get a lot more done with them. It took off, and a lot of people pushed back on it, mostly about maintainability.
I get it, but I think people are arguing about the wrong thing.
When I started my job, we didn't even have a code formatter, so that was the first thing I added. There were random chunks of two tabs and four tabs, useEffects used for everything, and people using mutations where they should've been using queries. It was an absolute mess, and honestly, that was pretty normal.
There's always been a trade-off between good code and velocity, and most teams almost always pick velocity, because that's where the money and the value come from. People ship what my manager called tactical solutions, things that work now that nobody will have time to come back to. Arguing for maintainable code has historically been one of the hardest things to do as an engineer, and it still is today.
So when people say agents will make codebases unmaintainable, I want to ask, compared to what?
I agree with Lauren that writing good code still takes a level of skill and effort. But on average, agents help raise the bar, and they keep raising it as they get better.
A lot of people in that thread were arguing about maintainable code. If you're shipping slop, your code isn't maintainable, but I really think that says more about the engineer underneath than the agent. If an engineer ships a ton of trash, it's still a ton of trash. If an engineer thinks deliberately about their decisions and their workflow and how they reason through a problem, it shows up in their work, and with agents it shows up at a much bigger scale.
Maintainable, well-thought-out code is still an engineer's responsibility. This might just be me, but I'd like to think most of my code is pretty maintainable. I write a lot of code, but it's thought-out ideas and designs, with real forethought about where things are going, and not just "do X, Y, Z and it works." The volume you ship is still you.
What I find most exciting is the steering. I've tried every guardrail on people: formatters, lint rules, more reviewers. Some of it helped, but with timelines and deadlines, people go around them all the time. You get a message asking "Can you approve this?", and if you trust your teammate, you hit approve. That's just how it goes.
Addy Osmani quoted Lauren's post to make the point that working at that scale needs strong verification. I agree, and with agents I can actually build that verification and those best practices into the workflow. I've spent a lot of time silently putting those flows into my org and my teams, and the codebase gets better without the engineers on the other end necessarily knowing.
That's the belief underneath all of this for me. Agents, LLMs, all of it, they're just tools. You're still signing your name on the work that goes in, and you're still responsible for the thing you built. They increase your volume and what you're able to do, but they're not a replacement for you. I know a lot of people think they are, and I wholeheartedly disagree.
Agents didn't change who's responsible for the code. They changed how much of it you can make.