HN Debrief

Reviews have become expensive, rewrites have become cheap

  • AI
  • Programming
  • Developer Tools

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.

Treat LLMs as a speed multiplier for bounded tasks, not as a reason to lower review standards. If your team is seeing bigger diffs and shakier ownership, tighten design review, require authors to test what they submit, and keep humans accountable for production risk.

Discussion mood

Mostly skeptical and irritated. Commenters thought the post misunderstood how LLMs fail, understated the cost of production mistakes, and confused faster code generation with cheaper engineering judgment.

Key insights

  1. 01

    Review pain moves upstream to design

    Pushing code review earlier into design is what actually reduced review burden in practice. One team dealing with AI-assisted change lists stopped accepting diffs the author had not personally read and tested, then added more design involvement and occasional pair programming. That worked better than trying to inspect giant generated patches after the fact.

    Set a policy that authors own every submitted change and must verify it in target environments. Use AI speed to shorten the path from design to tested code, not to excuse oversized diffs with weak ownership.

      Attribution:
    • saidinesh5 #1
    • jkrejcha #1
  2. 02

    LLMs invent rationale for bad code

    Generated code is not just wrong in ordinary ways. It often comes with fake-sounding justifications that make review harder, like claiming migration concerns for brand new code, citing precedent from code it just wrote, or defending race conditions and ugly shortcuts as sensible tradeoffs. Fresh-context review passes can sometimes catch this, but rules and saved memory do not reliably prevent it during generation.

    Do not trust the explanation attached to generated code. Review the behavior and constraints directly, and consider separate generation and critique passes so the second pass is not trapped inside the first pass's story.

      Attribution:
    • nomel #1 #2
    • bot403 #1
    • verall #1
    • bcrosby95 #1
  3. 03

    Type systems change the review workload

    In strongly typed codebases, some reviewers are shifting attention away from every line and toward whether the change touched the right places. The claim is not that LLM output is intrinsically safe. It is that compilers and type checks now catch enough symbol-level mistakes that human effort is better spent on scope, intent, and architecture.

    If you want heavier AI use, invest in languages and tooling that aggressively reject incorrect details. That lets reviewers spend scarce time on whether the patch solves the right problem.

      Attribution:
    • bob1029 #1
  4. 04

    Delete and reimplement to force real tests

    One concrete workflow was to roll back an uncovered AI-written file, then have the model rebuild it with red-green test-driven development. Watching tests fail before they pass gives you evidence the tests actually exercise the code, instead of merely existing alongside it. The same commenter wired this into a review command so self-review proposes the rewrite automatically when coverage is missing.

    When AI produces code before tests, do not just ask for tests afterward. Force a reimplementation from failing tests if the module matters, especially for logic-heavy code where fake coverage is easy to generate.

      Attribution:
    • cadamsdotcom #1

Against the grain

  1. 01

    LLMs can speed up human review

    Used carefully, model-assisted review can still make a reviewer stronger rather than weaker. The useful framing here is not “replace human review” but “combine domain knowledge with a fast secondary reader” that can inspect code, ask questions, and shorten the mechanical parts of review. That cuts time without pretending the model knows customer requirements or unstated constraints.

    If your review load is high, experiment with AI as a reviewer aide on bounded checks and summarization. Keep final judgment with the person who owns the business context.

      Attribution:
    • simianwords #1 #2
  2. 02

    Pre-merge rewrites can still be worthwhile

    There was some support for aggressive rewriting before production, because this is the one moment when code is cheapest to replace. The caveat is that the existing implementation may still be the only trustworthy source of behavior, which is why techniques like the Strangler Fig pattern matter. Rewriting early is useful when it preserves a known source of truth, not when it discards the only understanding you have.

    When a fresh change is obviously wrong, consider replacing it outright before merge. Keep the old behavior observable through tests or side-by-side paths so the rewrite does not sever your only handle on correctness.

      Attribution:
    • rob74 #1
    • mpweiher #1 #2
    • arcanemachiner #1

In plain english

boilerplate
Routine, repetitive code that follows standard patterns and contains little novel logic.
LLM
Large language model, a machine learning model trained to predict and generate text and often used for coding, chat, and document tasks.
Strangler Fig
A software migration pattern where a new implementation gradually replaces an old system while the old system remains the source of truth during the transition.

Reference links

Writing and style references

  • Martin Amis quotes
    Used in a side discussion about whether AI writing has flattened prose into overly simple, generic sentences.

Terminology reference