Hacker News Reader

Comment by staminade | Hacker News Reader

This is from March 2026, but it does match what I've encountered professionally. Code review was always a significant bottleneck and is even more so with agentic coding. We've had discussions about leaning more on automated review, but it hasn't translated into any practical improvements so far. I think senior engineers find it very difficult to give up on line-by-line review, no matter how much better the agents have gotten.

I think if there is a major change in code review culture, it's not going to happen first in established engineering teams. It'll happen in startups that adopt a no-human-review policy from jump and then maintain it as they mature. I'm sure that's happening, but it's likely invisible to most studies and surveys at the moment. If it proves successful, and such companies start shipping significantly faster, the rest of the industry will be forced to adopt.

View on HN

I would reframe this as: Quality was always a significant bottleneck and is even more so with agentic coding.

Code review is where many of the design & code quality problems are observed/highlighted.

And test creation and maintenance. AI-generated tests will often embed existing bugs as testable patterns that fail when fixed or rely on empty asserts to increase coverage. A human author generally knows better. Coverage is increasingly becoming theater and you have runtime testing eating up CI resources and time with bloated, unnecessary, untargeted testslop that haven't been mutation tested or a human eye assessing if the business logic is actually represented.

It's really the smaller firms which are able to learn quick adaptations that will win out in the long-run of this thing. Legacy firms with institutionalized bureaucracies are relying on gobbling up competitors and creating vertical monopolies while pushing out the worst slop - it's why GH goes down, why Meta products are buggy as hell now, and everything feels like it's unpolished MVPs these days.

This. The ability to know that a vibe coded PR is all right to merge, is a function of both the thoughtfulness and simplicity of the underlying architecture, and the level of ownership that contributors have of the underlying products. Both benefit more nimble teams.

So far this year, of the defects severe enough to warrant a formal RCA process that I’ve dealt with, “AI generated tests asserted that the defective behavior was correct,” was a contributing factor in every single one.

I haven’t had this happen yet, but I was just thinking about this last night. I would be very interested to see if exercising TDD, as difficult as that practice is to actually do, would have a meaningful positive impact on improving this phenomenon. Usually agents model what most humans do, writing tests to pass and assert that the code you just wrote works as you wrote it.

I’ve had decent luck with it as long as I at least stub out the test cases with a test name and a “given … when … then” comment.

Otherwise it seems the AI has a tendency to write the worst kind of TDD antipattern microtests that simultaneously make refactoring impossible while failing to document or even confirm the most important functional requirements.

Once it’s got those stubs it does do a pretty good job of suggesting behaviors I forgot to specify, and other improvements. It’s just “designing” test fixtures from the ground up that seems to put it into “generate plausible-looking slop” mode.

It does. But keep an eye on whether the tests actually run.

It has the same failure mode as dealing with TDD by a human engineer, which includes things like mocking the function under test in the test and then testing the mock, asserting only things that aren't actually exercised by the function under test (like asserting the initial user ID is the same as the final user ID for a function that changes name of a group), not validating side effect behavior (or lack thereof) for a function that's only purpose is the side effect (like appending a log line to a log file), and more!

What changes with TDD is that the important part of the review moves from the mainline code to all the TDD tests and the coverage, and you also need to see a test run from before the code changes with all the new/updated TDD tests failing in addition to just a test run after the changes with all the (at least) new/updated TDD tests passing.

This is part of the reason that I've come to view mocks as a code smell. They're too easy to screw up.

But even more than that, I've found that modules that need to be tested with mocking can often be reorganized to be testable without mocking. And doing so tends to also make the code easier to understand and easier to modify without breaking things in the future.

Mocks/stubs definitely have a smell to them, but especially if you want to do more than just unit tests can be necessary. I've found that setting up the mainline architecture so that components that are allowed to be mocked have a single access path in the code makes it easy to mock at a level low enough that the only thing being mocked is that component and then preemptively building out those mocks into the test framework works decently well. For me, 3rd party services are usually fine to mock, but things like DBs and redis are usually not. I'd rather spend the time to make a test container the devs can run locally so that they can't skip over checks/constraints and the integrations with services/components we have full control over.

That way you can tell at a glance of the test file change just how bad it is. Seeing new raw mocks (eg sinon in the test file at all) instead of the existing mocks is an instant no, and seeing an existing mock getting added requires at least investigation for necessity.

Classic assert true theatre lol

Agentic code review can also be employed, but it's worth noting that, as the so-called "Bitcoin Red Team" (which has been testing all of Bitcoin related software in the wake of the July 30 Coldcard attack) has discovered a very useful thing to consider: American models are absolute trash when it comes to reviewing code with an eye on security, due to their "safeguards." This applies even when the code being scanned for vulnerabilities was just written by the same agent.

Kimi K3 seems to be the favorite there, though I believe some of the other open weight/open source models are being employed a bit as well.

And yes, even that requires human oversight -- but it does a quick rough filter through things so you're not wasting time on the little stuff, allowing you more attention to find the glaring holes.

We shouldn't give up on line-by-line review for serious applications.

My company's leadership is oscillating every few weeks on AI goals. Their most recent story is "we're expecting developer velocity to approximately double over the new 2-3 years as people get better at using AI". But of course that's completely non sequitur. People on my team spend about 10% of their time writing code and 90% doing design and analysis. So if AI doubles our code writing velocity, then it will make us 5% faster overall.

I wish they taught Amdahl's law in business school. Or at the very least the simple concept of "bottleneck".

"The Goal" is a key business book for a reason, but leadership seems to not get the lesson. Or care?

I’m sure they learn it by other names.

The point is that while good to remember, and specifically Fred Brook’s “No Silver Bullet” article about it, there are second order effects.

If coding becomes 100x cheaper, what’s going to happen next? At least to some degree, design and planning was there since coding is expensive. (Not just coding, debugging also got squashed by AI and was an expensive part of the job)

This is why the original comment seems pretty spot on, organizations will learn how to skip more phases, and startups are probably a place where this will be happening faster. (Not clearly though, a lot of big tech are happy tokenmaxxing to try and not stay behind those startups when they come)

Brooks' point was more about accidental vs. essential complexity. You seem to be implying that design was only ever an artifact of "expensive" typing, but design exists to prevent systems from collapsing under different failure states.

If the cost of emitting syntax collapses without adequately resolving the essential complexity then you have not eliminated the design phase and you're just externalizing your failure modes onto downstream teams and systems.

I like the "9 women can't birth 1 baby in one month"

Fred Brooks wrote a whole ass book based on that premise, and people still haven't learned the lesson half a century later.

> We shouldn't give up on line-by-line review for serious applications.

But how many changes are actually serious?

I can have an agent mass-produce security bug fixes, zip through our low-priority backlog, etc.

IMO - we need to get out of our own way.

Building is cheap now. Agents are also really good at following checklists and running tests.

So instead of having individual engineers reviewing code, we need to

* Leave human review for the most impactful changes

* Get better at defining the quality bar

* Continually codify human concerns into rules or systems that can be checked against

A lot of this was touched on a few months ago with Spec-driven development becoming a hot topic when agentic coding started.

We should continue that with spec-driven review, testing, etc.

> I can have an agent mass-produce security bug fixes

I can't figure out what you're trying to say here. Are you saying that this is acceptable? Because I very much don't think it is. You'll have twice the bugs after you're done, and they'll be inhuman ones that you have little chance of catching.

> But how many changes are actually serious?

I mean, "security bug fixes" are not on your list of serious changes? What is?

> the most impactful changes

Quite a lot of our bugs in production have been in seemingly less impactful changes. How do you know what's impactful a priori?

Is your company striving to automate design and analysis, then?

...and they are not using LLMs to help speed up design and analysis?

I'm no booster but this is most of what I currently spend tokens on so it's maybe not as absurd as it sounds. Maybe those gains are possible and without having to sacrifice serious code reviews too.

Which is basically what this study is showing.

> So if AI doubles our code writing velocity, then it will make us 5% faster overall.

This tracks with the actual revenue impact of AI adoption:

https://www.bcg.com/publications/2026/the-formula-for-agenti...

Their very cheerful "high" revenue increase from AI adoption (that few companies in the index manage to achieve) sits at 4.5%. Most of those in the "value generating" minority are seeing sub-1% returns.

Which, of course, is non-zero, real, and all that, and matters when we're talking about a 4-5% increase of a big company's revenue, assuming the expenses are not catching up with that.

Which they absolutely are. The AI is subsidized by venture capital, and the subsidies are drying up (hence OpenAI upcoming funding round). None of the AI companies are profitable (much less self-sustaining), and AI prices are inevitably increasing.

Just to back you up most surveys say only 10% to 20% of programmers time is coding.

Microsoft study of 484 developers, published in 2025 says 11%.

Another Microsoft study where programmers had telemetry installed showed 21%

https://gwern.net/doc/psychology/writing/2017-meyer.pdf

It's interesting. I remember around COVID, there were a bunch of startups building 3d printers for concrete housing. Then I looked up the actual cost of construction for a typical house, and only 14% of it was the most visible part (the balloon framing and physical house). Most of the cost is in foundations, plumbing, wiring, and things like insulation, flooring, cabinets, etc.

I guess at Microsoft coding is similar to building a house in that sense. Either that or all big orgs devolve into large amounts of time spent on politics.

I don't think balloon framing is used anymore? It's a bad fire risk.

90% of my time these days is trying to understand what the wall of claudeslop jira ticket is actually asking for. It's like archeology digging for the original customer issue to work out what is actually wanted underneath paragraphs of root cause load bearing seams.

Coding was never the bottleneck...

And how many billions or trillions have we wasted on people who didn't understand that (or did, and are just busy generating hype).

Ultimately, this (llm) technology (as it is being developed/used), is not useful to us...

Yup we already knew this.

Google had many engineers working on a) failed projects b) people being paid to sit around.

There seems to be this strange belief on here that making something more accessible to everyone will always result in better outcomes. I don’t see this being true of software.

I’m very pro-tech. But nobody can point me to a product built by someone outside of the large tech firms, made by by llm’s that is a great value add to one’s life. Many of those were already created - they’re on the apple App Store for example.

I’m absolutely confident coding speed is irrelevant. A person who has a real vision + strategy and hand written code will beat the team with no vision, strategy and code blasted out by llm’s.

Sure llm’s could augment the former - but you’re missing the point!!

There's a difference between vibe coded slop, vibe coded kinda slop built by an engineer, AI assisted engineers, and AI planning. I enjoy writing code by hand but it's quickly becoming apparent that LLMs are now a tool that one should be using in some capacity.

Nobody writes code in notepad anymore, even though you could and might even like all the black text.

I'm fairly pessimistic about LLMs, but I do find they're a good research tool. If I can accelerate finding answers amid the slurry of Confluence, Slack, assorted other intranet places and the web, I can get back to thinking about the design and programming.

I have a user CLAUDE.md that tells it not to presume to modify any files, and a bunch of internal MCPs for our logging and monitoring tools, documents, git repositories and such, and I've been dabbling with writing skill files so it can access some other internal things.

So I can basically say "this thing isn't working because x, and it's probably related to y not having z" and it'll go off and find info buried in the corporate abyss.

Then other people yeet wildly awful LLM generated PRs over the fence and I lose my sanity from basically having fight a constant battle against a slow rot of software quality that will bite us later.

> A person who has a real vision + strategy and hand written code will beat the team with no vision, strategy and code blasted out by llm’s.

But you have to beat the team with vision + strategy who is also blasting out code with LLMs.

Certainly, the time it takes to figure out that an idea is bad had been shortened :)

If the time taken is shortened but you don't learn anything from it, then you're still behind.

Actually you're not just behind, you've burned up money.. you've destroyed value - there's an opportunity cost of that money. Whilst the other competitor who is prudent eventually wins will be far more attractive in the eyes of investors - moreover once you are confident you can scale up inputs (engineers) and hone in the quality whilst the other competitor runs ragged with a half-baked product.

We've seen this story play out already numerous times: Apple. They made a mis-step with Apple Intelligence but aside from that, they've been right not to lurch to deep into things they shouldnt. Its not zero-sum.

I agree. The latest models are getting quite good at validation, as long as they are clear on what the requirements are. Recently I got frustrated that while we have a huge test suite I noticed the LLM was hardly ever breaking a test with its changes (PRs only added tests, never changed old ones) which seemed suspicious.

I had it do a full audit. There were about 100k lines of tests, of which it determined about 60k were near useless. Many were overly mocked, some mocked to the point that they really weren't testing anything at all. It deleted those and wrote more expansive scenario tests to replace them, caught a lot of bugs on the way and fixed those too. Total time was about 2 hours.

I think humans need to review requirements, specifications, and test scenarios. And for some industries and uses they're still going to have to review every detail. But for a typical CRUD app, I think we're at a point where we can already set the process and quality bar higher than ever, in addition to moving faster.

Glad to see someone else notice this. I dread looking at or dealing with AI written unit tests because of the incredible amount of whiteboxing that goes on, though usually for the opposite reason because AI testing is almost entirely whitebox testing which fails if some internal details change

Funnily enough I've found that LLMs can be effective at mitigating many of the drawbacks of black-box testing and i've significantly expanded our usage of it over the past year

I chuckle a little bit at this specification thing. We used to do this. We used to write big binders of specifications, and then we'd set about implementing them. We stopped doing it because it didn't really work. We'd learn things in the process of building which negated the value of the big specs we wrote. That's why we stopped doing it. This is where continuous improvement, CI/CD, tighter release cycles, etc. were all born.

It is funny. At some point the code is the specification.

Remember when it was time to fire all the engineers because your business-analysts could just make UML diagrams?

If the code is the specification, then the only word on what the system is supposed to do is what it actually does.

When what it actually does is surprising, maybe you can make sense of it by asking the author what they were thinking. But that only works if the author is an entity that is both capable of thinking, and of remembering what it was thinking.

But why? On reason is that implementation was a bottleneck. That made it expensive to change a system once it was entirely implemented. It was better to get the feedback sooner so you didn't waste time implementing the wrong thing.

The calculus on a lot of these old adages is changing.

It is _still_ better to get the feedback sooner. Writing up some big specification, spending a bunch of tokens on implementation, and then shipping a massive PR to match the spec only to then find out it's wrong is a big waste of time. Nothing about writing grand plans in the face of unknown unknowns has changed.

The more things change, the more they stay the same.

I don't think this was only about implementation being the bottleneck. It was also because implementation forces you to think about the thing you're building at a very grannular level of detail, at which point you might discover flaws or opportunities that weren't obvious at the higher level.

And I find that, when it reasons through and encounters some of those, it just makes assumptions rather than asking the user.

In my experience I can heavily influence this based on the prompt.

Follow the sound of my voice. Come back toward the light.

Well, kind of. I think this is an interesting opinion on that: https://www.mountaingoatsoftware.com/agile/the-cost-of-chang...

Which could be summarised by a single line: "In other words, the primary cost of change increasingly becomes feedback delay, not development effort."

Fred Brooks famously advised us to plan to throw one away. That was in the days of waterfall engineering.

The reason he said that is because the best way to learn how to properly build a complex system is by going through the process of building it. Sure, implementation is a bottleneck, but the real problem is that the experience of development is the best teacher.

Personally, I try to bring this lesson into my agentic coding practice by doing spikes and trial implementations first. This is where the AIs really deliver value: they can quickly build something out that touches a lot of the architecture so both it and I can get the proper shape of it. Only after that do I unleash it, constrained by what we learned.

Royce's paper where he coined the term "Waterfall" and described the method included throwing a first implementation away.

That phrase, “once it was entirely implemented,” is doing a lot of work.

If you go back and read the literature on this stuff, one constant pattern is that technical leaders are repeatedly advocating for iterative development with frequent integration testing, and pushing back against management types’ impulse to favor giant up front over-specified design by committee plans. It’s not a phenomenon that’s unique to software, either.

But managers love meticulous up-front specification because it gives them the illusion of control and predictability. They are always being asked, “How much will it cost? How long will it take?”, and this approach gets you there.

I would argue that that’s the basic instinct behind meticulous up front specification for AI coding projects, too. It makes it easier to believe that, come implementation time, you can reliably one-shot it with an agent and have a working implementation that satisfies all design goals by next morning.

Yet software quality has been in deep dive for a while, long before AI.

My theory on this is that it’s a lot of kids who would have gone into finance going into tech instead.

The problem with that was lack of iteration, not presence of specifications.

Yes, unfortunately a lot of requirements and specifications are now AI slop, thus developers stop reading them, and agent produce even more slop.

We need to take back writing requirements and specifications to humans.

Adopting high level BDD style testing of human written user stories (cucumber) is probably a good idea.

Just have AI write requirements then another AI write specs based on the requirements then another AI write tests based on the specs and another AI write the implementation based on the tests then another AI write the PR based on the implementation then another AI approve the PR and another AI deploy approved PRs to production!

Don't forget: let the user's AI use the product, find flaws, submit AI-generated bug-reports, which get turned into AI-generated tickets, etc.

And meanwhile, did any human find the whole process useful - no, not all...

Also, the entire thing is fully funded with AI tokens, which are paid for with money from investments into AI companies, made with AI pension funds.

Wait, no, that's ACTUAL HUMAN pensions, because plenty of AI companies are still "investment grade"

https://www.forbes.com/sites/brandonkochkodin/2026/10/12/ai-...

The Vile Offspring has to be born somehow.

FWIW, it's a great little "trick" to always ask for red-green tests. In my experience it's enough to ask for that and LLMs know what to do.

Same, although I use "TDD red phase"

https://simonwillison.net/guides/agentic-engineering-pattern...

I just don't understand the hype for this. "AI can do $x" quickly needs softening to "AI can try to do $x" which then becomes "humans need to verify $x has been done." If humans still have to oversee every part of the processes then what exactly is being automated!?

This would be like if we had our first factory producing cars but each car was like a die roll in terms of getting a car, a washing machine, a pile of scrap metal, or a baby. And people just asserting over and over that this was the future of making cars, no matter how much scrap metal keeps coming out.

I remember hearing that first mass manufactured weapons were like this. Horrible tolerances. So basically in assembly you tried different parts until you got something that fit together reasonably... It got better as tolerances got better. But I have some doubts if tolerances ever get there with AI...

If before AI you couldn't deploy to production without a code review, what makes you think you will be able to with AI?

To be fair, when I was a kid we'd connect the editor to the server using an unencrypted ftp connection and modify php files in production.

This worked perfectly fine, and phpmyadmin made schema changes super easy.

These days we do tests, schema migrations, terraform, staging sites, traffic migration, monitoring, logging, revision control, etc.

... it's a lot of boring work, and for most CRUD apps, its entirely unnecessary :)

That said: I doubt we'll abandon these practices for things that matter.

Because while modifying php files in production can increase velocity, it can also get very "exciting" if you have a few co-workers on the same project :)

> I think senior engineers find it very difficult to give up on line-by-line review, no matter how much better the agents have gotten.

I actually dislike traditional code review. In part this is because most of our code review tools are very cumbersome to use (GitHub's and GitLab's web interfaces in particular).

But also because humans aren't all that great at code review when it comes to correctness and security. Part of the problem is that you don't have access to the author's mental model for non-trivial changes and have to reconstruct it, otherwise your understanding of the program logic will be inadequate.

The problem is that purely agentic code review has orthogonal problems, and typically remains subpar when it comes to judging architecture and design considerations, compared to human reviewers. Both false positives and false negatives also remain a concern.

My best results so far have been with agent-assisted code review in a proper IDE, helping you to quickly construct a mental model and to analyze the underlying logic (in addition to having agents do a first pass for correctness issues).

> But also because humans aren't all that great at code review when it comes to correctness and security. Part of the problem is that you don't have access to the author's mental model for non-trivial changes and have to reconstruct it, otherwise your understanding of the program logic will be inadequate.

Code review is not really about correctness and security. We have testing and other verification process for these. Code review is about idea discussion mostly and correcting a few stuff that may have slipped through the author's initial review.

Your PR wants to change the software in some way. My review is to comment on how you've implemented that change, like did you miss some areas where you needed to change, does your description is actually what is happening (either a cursory reading or through testing), or are you doing some unnecessary change.

IMO, the initial reading shouldn't take more than 10 minutes. More than that (so a big diff) it should have been discussed upfront, and the design agreed. If it's an important area, a more careful reading should be done about the tests and relevant stuff.

But generally, if a review takes more than 10 minutes, there's some failure of communication going on (reviewer not apt to understand the change, big diffs that should have been discussed outside of the PR, obtuse code,...)

All good points. Maybe having worked a lot with concurrent and distributed system makes me distrustful of relying on unit/integration tests for correctness; I've seen too many concurrency issues pass CI validation. But unit tests also sometimes miss edge cases in more straightforward code, so I'm still a bit more cautious.

I also agree that merge requests should be short and understandable in 10 minutes, but IME this happy state often does not obtain in practice. It shouldn't, but it often does, whether it's mission creep, whether it's turning out that a change is more complex than originally imagined, or whether it is unavoidably complex and cannot be broken down further.

> IMO, the initial reading shouldn't take more than 10 minutes. More than that (so a big diff) it should have been discussed upfront, and the design agreed

Part of the code review process is to verify that the writer actually did build the agreed design too though.

My main goal in a review is to ensure the design of the system and approach to the change is resilient to errors (by me and the author). You have to assume there will be mistakes you can’t catch (still, catch as many as you can), but other factors heavily influence how bad the mistakes will be.

> Part of the problem is that you don't have access to the author's mental model for non-trivial changes and have to reconstruct it, otherwise your understanding of the program logic will be inadequate.

I actually believe the opposite: exactly the fact that a reviewer had to develop a mental model independently is why code review is and remains valuable (and why people use different models when doing agentic reviews).

The biggest value of doing code reviews is in ensuring maintainability of the code (1. someone else can understand it, 2. it is readable and 3. can be evolved in the future) — everything else is downstream from that.

> I actually believe the opposite: exactly the fact that a reviewer had to develop a mental model independently is why code review is and remains valuable (and why people use different models when doing agentic reviews).

I don't think we actually disagree here. I also think it is valuable, but it's also what often makes it difficult.

> The biggest value of doing code reviews is in ensuring maintainability of the code (1. someone else can understand it, 2. it is readable and 3. can be evolved in the future) — everything else is downstream from that.

Agree very much with that (with the slight caveat that it is not always the biggest value, just an important one).

> exactly the fact that a reviewer had to develop a mental model

But do they? In my experience, at most workplaces it's simply a meat linter phase with the occasional useless comment about style (which should probably be handled by proper CI/CD).

Like if you don't even check out the code (generalized 'you'), then they can hardly build up that model. And even checked out, viewed in its proper context, Naur's famous paper comes to mind - the author who wrote it is the only one who has properly built the theory (which might have included alternative implementations that failed but have no visible artifact).

I'm not claiming that there are no places that go absolutely above and beyond with their review sessions, but I would argue it's really rare - and AIs are great at figuring out some of the context the PR description lacks.

What you describe sounds like little more than rubber stamping a PR target than reviewing it.. I see it too, but I don’t thing we should double down on it just because it’s common

People say one thing and do another. It’s tiring. Long before LLMs we had the joke that a PR with 10 lines changes got 10 comments (all nitpicking), a PR with 1000 lines got just one, LGTM. We’ve had several bugs where PR review would almost certainly never catch the issue, people are terrible at reviewing things thoroughly. Guess what can do that much much better?

IME, the biggest source of rework cost that happens at (or after) code review is when someone notices that the code, correctly or not, implements the wrong thing. For example, the feature, as implemented, doesn’t sufficiently solve the original business problem. Or it solves it in a bad way, like because of overengineering or taking on unnecessary technical debt. I haven’t really seen much evidence of AI code review catching either of these problems.

I’ve heard people complain that human code review doesn’t reliably catch them, either. And I have seen that with my own eyes. Just not universally. Teams that have a strong culture of shared ownership and collaborating on designs regularly catch these kinds of problems in code review. If they’re really good at it, they catch them even earlier. e.g., I know planning poker isn’t fashionable anymore, but when I’ve been on teams that take it seriously they tend to be pretty good at finding minimally expensive, correct designs pretty early in the process. Which makes both coding snd code review go faster because simpler designs are easier to manage. And design flaws that do make it to code review tend to be smaller and less expensive to fix. So those teams didn't tend to bottleneck on code review in the first place.

I think that this is the kind of thing that led to folks like DORA observing that AI coding is something of a multiplier for the effects of both good and bad software development practice. If you’ve got a cowboy coding culture, throwing AI into the mix will probably just lead to agentic cowboy coding.

What helped me with exactly this: every project has an INVARIANTS.md, a short list of what must stay true now and in a year. The agent checks every merge against it, and changing a line in it is only my call. So I review that file much more carefully than the diffs.

As a senior engineer that is struggling to give up line-by-line reviews, I agree with your take.

I've spent literal decades where one of the most valuable practices has been code reviews, for many dimensions. It is one of the best ways to ensure quality production releases. It is one of the best ways to transfer skill to junior engineers. It increases tribal knowledge throughout the engineering org by exposing others to systems they may not be working in. The number of benefits to a traditional human-centric engineering team is hard to overstate.

But I'm starting to feel that instead of starting at one extreme (heavy handed reviews) and moving towards less review, it probably makes more sense to start at the other extreme (no review at all) and move towards a brand new practice tailored for the new agentic reality.

It is looking increasingly likely that we don't need to modify code review for the agentic era, we need some completely new practice that hasn't yet been invented.

It's really about hamstringing the AIs so they can't write crap. Writing code is not a problem anymore, so anyone with an idea can write a script to do what they want. But if they try to connect two ideas together, now they have a data modeling problem. This is where everything seems to fail with AI coding (largely because the original author had the idea piecemeal).

The problem I have is non technical people now started submitting PRs. They are like the brain damage module on GLaDOS and somehow make opus generate actual broken slop. So I still have to be on my toes to catch that, but they generate such volumes of broken PRs that it takes time away from me doing real work.

Perhaps spec review in the custom of code review - it can even be via PR - so there is a bottleneck before anything is generated, instead of after. Cheap-to-produce code maybe isn't worth understanding line-by-line anymore.

I think spec review, which is definitely valuable, solves a different problem. One question to ask is "are we building the right thing", which a spec review definitely helps to answer.

But another question is "did we build what we planned, and did we build it to a high quality". Code review partially answered that question. Adversarial review is the closest we have to that in the automated LLM world, but I feel we need something better.

In the sense that ai-engineering specs (ie an elaborate prompt with skills etc.) can be said to be compiled into code language x maybe.....the spec is the new code?

> the new agentic reality

As a senior engineer, I think the code quality and review rigour slippage came well before AI. It's cultural, not technical. People just don't want to hear criticism anymore, they're thin skinned and weak minded, and they don't want to do the work to become strong. They want to be handed the answers and told they're doing great work, regardless of whether it's actually true.

Generative AI coding tools have just amplified this problem.

To be perfectly honest, whenever I detect this pathology in a junior my effort reviewing their code drops precipitously. There's just no point investing in an individual who doesn't want to work hard and learn. If my employer wants me to green light their vibeslopped garbage then I'll gladly oblige. Unfortunately this is the norm now.

Me being selfish.. I don't mind this.

I want every other firm to get weak whilst mines stays strong and wipe them out clean.

Agents are fully capable of doing reviews as reliably as senior developers. They just need to be independent and adverserial, and validates the things you actually care about in your QA.

You don't give up on line-by-line review just because the human is getting better either, and senior engineers want other people to do line by line review on their own code. It's not a matter of how good or bad the person or program generating the code is.

> I think senior engineers find it very difficult to give up on line-by-line review, no matter how much better the agents have gotten.

Our industry has spent the better part of the last two decades interviewing with brain teasers and leet code questions. Reading code is a skill that we just weren't assessing for, and lots of people aren't really good at it.

I would argue that code review is mostly theater, politics, bike shedding and pedantry.

There is a lot of work to get away from "coding" and "programing" and get down to the actual engineering that really needs to happen in the industry.

It's not code review that's slowing things down. It takes time to get the thing you want, and then you have to be reasonably sure that it's right anyway, or you risk shipping a piece of crap to production and tanking your own reputation. Even on teams that rubber stamp PRs I see people pushing drafts and waiting to merge until they feel comfortable with what they've vibed out.

I think non-senior engineers don’t realize just how much of a burden is barely reviewed ai generated code.

I’ve seen a few projects that heavily rely on ai with not very good (though senior) devs driving it - and its a mess. Not the code. The resulting product. Code is actually sound as ai is pretty good now.

All because ai does code reviews and dump decisions go into prod

can you be more specific. If the code is not a mess, how is the resulting product a mess?

All of these model-based approaches are fundamentally nondeterministic systems, and there's no escaping the math of their fundamentals, which is textual representation of natural language.

The "nondeterministic" part is enough to flag these tools in some industries. We can't risk having a different answer to the same question in some applications. Even if the differences are small, differences compound over time, as anyone who's worked in inertial guidance can tell you.

Aside from the "nondeterministic" part, that "Fundamental Math of LLMs" is a very different beast from math that runs much of the rest of the cosmos. It's just human language. Just because you can talk about something does not mean you understand it.

Existing "LLM-type" technology performs beyond all prior preconception because there's pretty obviously some kind of basal mathematical relationship between different kinds of meaning. But that relationship, no one's really grappled with it formally in its entirety. It's probably adjacent to the big new science/mathematics of Emergence. It's also, from a pure science aspect, probably the most interesting aspect of these systems. All the crap we've been trying to wrench - for DECADES - with taxonomies, semantics, a swirling universe of computational linguistics in all its variety - that crap could conceivably have a single " $ E = mc^ 2" moment. But we don't fundamentally understand it, and it's a real mistake to hand critical systems to models that aren't understood. Down that path alchemy lies.

> I think senior engineers find it very difficult to give up on line-by-line review, no matter how much better the agents have gotten.

Interesting framing that casts senior engineers as the impediment. If the models are now good enough now, perhaps engineering leadership could[1] do away with code review entirely - or maximally automate code reviews. I'm sure seniors would love to get their individual productivity unleashed for performance metrics/bonus reasons.

1. I'm stating this as a hypothetical, but this "vibe-coding your core product" experiment has been repeated many times and I'm yet to hear a single success story

Imagine no code review: poof. You still aren't shipping at lightspeed because it still comes down to knowing where to shoot. Oftentimes this is like pulling teeth from various involved stakeholders.

You say small startups would be faster as they won't be doing code review. There's probably always been startups running without bothering with code review for as long as this has been a field. Bad practice? Sure, but all that matters to the business case a lot of the time is just shipping something that works alright, not the greatest piece of efficient code in the world. Moore's law has bought us a lot of slack in that.

AI is great at reviewing code. It is not great at reviewing intention. If the prompt was bad, not understanding or thinking about how to implement the feature properly, the review usually doesn't point out exactly what's wrong. This can lead to a sort of "polishing a turd" approach to code reviews where you patch some of the negative side effects for an implementation that is completely wrong.

This is a result of AI still being bad at telling the prompter "no". Not only because it will blindly reproduce what you tell it to while writing code without pushing back on assumptions without asking, but because it will often blindly accept an implementation approach while reviewing.

I suspect this is a hard problem, because if AI stops listening at the wrong time it can be a massive inconvenience.

I have noticed that AI is slowly getting better at pushing back on different types of things each time the frontier models get better though. I've also noticed on reviews that it will tend to hallucinate or nitpick around the problem. I assume it sees something wrong there, starts generating output, and points out something different there instead because there is pressure to be both agreeable and helpful, which are not always compatible.

I think it is getting better, but it can't always see the forest for the trees.

I think senior engineers find it very difficult to give up on line-by-line review

Thanks, hearing that renewed some of my hope for the future!

I'm definitely in that camp. The tools need to be as reliable as my compiler at faithfully expressing my intent.

Two inherent headwinds:

Their non-deterministic nature makes this difficult for me to trust.

And the imprecision of the human language.

Elaborating on the second... Source code can be a handy shorthand. It was designed for the purpose. If my level of abstraction (or "programming language") is the English language, it's going to be a lot more "code" to navigate.

That demands highly structured organization, reliance on diagrams, methodical vigilance for edge cases which may not be as readily elicited, etc. Admittedly, design hygiene that should already be the case if you're diligent, but I've seen how those areas can be a weak point in practice - particularly in some corporate environments where the developers are stretched thin, and as a result the culture sacrifices discipline.

In other words: Exactly the place where everyone says AI is supposed to be a revolutionary force multiplier.

I agree with you organizations who leverage the tool most effectively will be the ones who build or reinvent themselves across more than just the engineering teams, to avoid some of the habits human nature tends.

In the meantime I'm very keen to see how long term maintainability pans out for the codebases being churned out today (and fully expect as commodity code becomes cheaper to produce, we'll see it become much more disposable - just throw the whole thing out and start from scratch).

Of course I'd love to hear thoughts on this from people who've spent more time behind the wheel of these tools than I have!

We havent done manual code review for months actually. It is not a problem if you have adverserial review loops that automate your QA and mechanically enforce the orchestration of them. That is basically what the zeroshot framework we are building is for.

We're going to need to start putting the month in brackets after the article title, not just the year!

> shipping significantly faster

If you're right (and you probably are), we're in for a wild ride further down the quality death spiral.

The era of user telemetry and conversion tracking already decoupled product design from customer experience. No need to wait for customer's to articulate their experience or desires or for discerning analysts to amalgamate and ponder their opinions. The numbers tell you everything you need to know! Just throw 3000 pounds of spaghetti at the wall every month and wait to see what sticks.

But now you really were bottlenecked on engineering.

Only 3000 pounds of spaghetti per month? And throwing more bodies at it barely even makes a difference? Oof.

Of course the solution is to just flush pureed spaghetti-slop through the hose as fast as we can. Brilliant!

What could go wrong? The users are sure to love it. We'll know because they keep clicking. That's how they tell us the truth, even as every forum fills with louder and louder complaints!

"The users-only forum for complaints about authentication errors is completely empty, therefore everything is working perfectly."

Correct people need to go slower but this doesn’t benefit frontier labs. Go go go max max max is what they want.

> I think if there is a major change in code review culture, it's not going to happen first in established engineering teams. It'll happen in startups that adopt a no-human-review policy from jump and then maintain it as they mature.

I've been hearing this for more than a year. But if these startups are all moving at superhuman speed, a month instead of a year from idea to a shipping product, where are the products? Every time I ask that, people talk about the amazing velocity gains they experience for the thing they are about to ship. It never does, unless we count throwaway hobby projects at GitHub - by that metric, AI is adding a lot of software. And I guess never-downloaded slop-games on mobile app stores.

But if you actually go shopping for consumer or enterprise software that's camera-ready, the landscape is basically the same as in 2022.

It's as if building something was not a bottleneck for startups. Go figure.

I want the boosters to address this head on - chime in?

Codex/CC and other OpenAI and Anthropic products like Dots, are examples of how quickly real products can be built today. But to me, they feel more like mediocre products bloated with feature slop. Nothing extraordinary or technologically innovative.

Pi.dev and Cursor's Tab completion are two of the most innovative and extraordinary products I know in AI era, and both were built by humans, at least in their "breakthrough" stages.

I lean towards a hybrid review process where humans accept their limitations, focus what they're good on(higher level concepts and architecture of the proposed change), and let the LLMs do the rest.

Doing a line by line review as a human is silly now.

> I think senior engineers find it very difficult to give up on line-by-line review, no matter how much better the agents have gotten.

Why do you feel like that? Agents have got better but better how? Looking at the frontier model output, I’d say the same myopic approach that causes long term issues without frequent course correction is still there.

The study was updated in August 2026.

Whenever I've tried skipping code review I've later found janky crap or weird decisions made.

Agents allow me to build cool stuff but atm they're far from good enough to not review the code.

You dont have to review the code, but someone does. If it is a well-tuned adverserial reviewers, that would be more than sufficient. We are building zeroshot to let you customize that as a fixed graph for your repo, feel free to check it out!

You have to classify each code review based on what it changes and decide how to handle it, agent review and/or human review. You can have an agent do that.

For me reading ai code feels a lot like that time I tried reading Joyce. I don’t understand but I’m sure it’s beautiful.

My experience with prototyping games is that you need very strong human driven guidance and review in the beginning, then you can increasingly take your hands off the wheel.

If you take it off too early you end up with shit and will spend weeks fixing all these baked bad assumptions your project is built on top of. I spent weeks fixing some of this shit then the LLM revived a not insignificant portion of it in a later change because it got "confused" (its words) because some of the comments it previously made were left around.

What could possibly go wrong?

> I think senior engineers find it very difficult to give up on line-by-line review

i am pretty senior. I hate code reviews so much. They are so boring, easily the most tedious part of my job. Its such a chore. Who is clinging to line-by-line review. Ppl dont really give that much about their employers.

> Who is clinging to line-by-line review.

It really depends on the context. A react button background color - meh - the critical part of the backend where a new 300ms delay will cost the company millions then yeah.

> new 300ms delay will cost the company millions

these might be 1% typically

> the critical part of the backend where a new 300ms delay will cost the company millions then yeah.

If it is so critical, why don't we have tests and benchmarks for it?

Oh right, because "Greg the super-coder" never wrote any of this down and it lives in his head so he can be the arbiter of change.

It was toxic before agentic coding, it's still toxic now.

Document your systems. Add tests and benchmarks for what is important.

We've always known this, we have a dozen or more textbooks written about it. But we always gave it a pass because "Greg the super-coder" was producing more value than he was hurting.

That's no longer the case. Your best coder is now Opus or Astra

Good thing you reviewed the PR so you could catch the gap in Greg’s documentation and force him to write it before approving his PR!

> Your best coder is now Opus or Astra

No, that's our _fastest_ coder, which is a different thing than _best_

> If it is so critical, why don't we have tests and benchmarks for it?

Thats a fair point, but Ive seen LLMs modify the surrounding environment to “pass the test”

A human still has to be responsible at some point.

> he critical part of the backend where a new 300ms delay will cost the company millions then yeah.

If a performance regression like this isn't caught by an automated testing suite, you have made a horrible mistake.

Reviewing the PR gives you a chance to identify this gap in the performance regression suite.

The agent could also do that part while its still in draft. If the rigorous tests already exist of course.

Absolutely. And also the idea that this is somehow the last bastion against introducing bugs? Maybe run a test

> Maybe run a test

One of those things made of code that we should neither be writing nor reviewing? Shouldn't I just assume that the LLM did that or whatever?

I hate code reviews, but I owe it to my coworkers that I know will read my PRs to review my own generated slop line by line. Most of these agents are still overly verbose and I'm in a situation where no, not every single edge case is relevant enough to warrant the additional loc or complexity introduced.

You don’t sound very senior.

Code review isn’t a quality gate, it’s a way to maintain shared understanding of a codebase.

Throwing out code review is equivalent to throwing your hands up and saying you don’t need to understand anything about what your code is doing in its black box.

I don’t think anyone on this forum is half as smart as they think they are, especially in terms of systems engineering a black box solution. Myself included. Someone needs to understand what’s going on inside the Widget Factory until we have full Artificial General Intelligence.

>Throwing out code review is equivalent to throwing your hands up and saying you don’t need to understand anything about what your code is doing in its black box.

I think that is what the C-suite is currently wanting out of our engineers. Prompt, don't write, maybe read a bit, don't stop, ship, ship, ship.

This will vary by company focus and size, but sometimes the C-suite just doesn't want to believe that software-engineering has important overlap with business-analysis or product-design.

Is the C-suite ready to sack the engineers and prompt Claude themselves with their business requirements? Why not cut out the middlemen if that's how they now perceive engineers?

If they can do that, why doesn’t someone else do it first, for half as much money? What’s their moat if their business can be replicated with a few prompts?

doesnt mean its not boring

I initially pivoted to fully automated code reviews, sometimes with a brief skim of things. I've been shifting back to mostly manual review. In the background I'll also run some agentic scans, and once I'm done I'll look to see what the agents had to say. And then I go back in by hand armed with that knowledge and verify it & come to my own conclusion.

Why? Because I started to run into way too many AI generated messes in codebases. The agents are really good at some things and complete ass at others.

So you’re not writing the code, and you’re not reviewing the code…

What exactly would you say it is you do around here?

where did you get that i am not reviewing code? ironically this is an example of some ppls' brain falling apart even reading a 3 english sentences so you can only extrapolate how bad they are at reviewing code.

I also hate reviewing my own ai generated code. Worse; it’s impossible for me to keep focus. So I created a skill to keep it interesting. It’s nothing more than a prompt that asks the ai to ask me questions about the code. Starting at high level, like ‘Describe the core responsibilities of X, Y, and Z in a sentence or two. From that it goes deeper. It is also instructed to summarise based on my answers. If I give a wrong, or vague answer it will flag it as code that might be problematic.

Mostly, this helps to keep me focused and really understand the code. It’s not perfect. On two occasions a secondary human review found a critical bug, like calling a non-user-facing endpoint (but with similar name).

Both Claud and Codex would run circles around 80% of the developers I’ve worked with through my 20 year long career. This whole code review thing is a hold over that probably won’t last six months.

Reply on news.ycombinator.com