The post claims LLMs have flipped an old engineering tradeoff. Review used to be cheap and rewrites expensive, so teams tried to salvage questionable code with comments and small edits. Now, the author argues, regenerating or reworking code is so fast that reviewers should stop spending time on line-by-line cleanup and just replace code that feels wrong.
Most of the reaction was that this only works on toy problems or very early-stage changes. People kept coming back to the same point: a rewrite is only cheap if you already understand the problem, the constraints, and what the code is supposed to preserve. LLMs do not remove that work. They often add to it by producing plausible code that passes superficial checks while sneaking in shortcuts, made-up migration concerns, or local fixes that break surrounding behavior. Several comments said the expensive part has not moved from “writing” to “reviewing.” It has moved from “typing” to “maintaining understanding.” Faster code generation can actually widen that gap.
The practical consensus was narrower and more useful than the post. LLMs help with
boilerplate, small scoped tasks, and some low-level review assistance. They are weak at deciding whether the change should exist, whether the design is right, or whether the code reflects unstated business rules. Teams getting buried in giant AI-assisted diffs are responding by pushing review earlier into design, pairing more, insisting that authors personally read and test what they submit, and leaning on compilers and strong type systems to catch detail mistakes. The mood was not anti-AI so much as anti-fantasy. Nobody objected to cheap rewrites. They objected to pretending cheap rewrites are cheap understanding.