alt Hacker News> Honestly the model that works best for me is treating agents like junior devs working under a senior lead. The expert already knows the architecture and what they want. The agents help crank through the implementation but you're reviewing everything and holding them to passing tests. That's where the productivity gain actually is. When non-developers try to use agents to produce entire systems with no oversight that's where things fall apart.
I tried to approach it that way as well, but I am realizing when I let the agent do the implementation, even with clear instructions, I might miss all the “wrong“ design decisions it takes, because if I only review and do not implement I do not discover the “right“ way to build something. Especially in places where I am not so familiar myself — and those are the places where it is most tempting to rely on an agent.
Replies
With Claude code I live in plan mode, and ask it to hand me the implementation plan at the low level, with alternatives. It's rare for it to not give me good ones: Better than the junior dev. Then the plan it has is already limited enough that, along with its ability to maintain code style, I will see code very similar to what I would have done. There are a couple of things in the .md file to try to make it take a step or two like the ones I would on naming, shrinking the diff, and refactoring for deduplication. It's not going to go quite as fast as trusting it all to work at a large scale, but it sure looks like my code in the end.
This is real and I deal with it constantly in consulting. When you're running teams of teams you physically can't see every mistake or learn every minor implementation detail - that's just the reality of scaling yourself. Doesn't matter if it's humans or agents doing the work.
The way I handle it is the same either way: trust but verify, delegate appropriately, set up checkpoints, and provide architecture and design direction up front so they don't spin their wheels going the wrong direction. The more context you give before they start, the less likely you end up reviewing something that went completely sideways.
It's kind of funny honestly - we talk about agents making "wrong design decisions" and missing context like it's a new problem, but this is literally what happens with human teams too. We trained these models on human output including all the human failure modes, so of course they reproduce them. The difference is just speed and scale.