Hacker News new | past | comments | ask | show | jobs | submit
The problem is that when nobody writes code or feels ownership over it anymore, nobody will be qualified to or really interested in doing the code reviews. The way forward could involve dropping code reviews altogether. You could argue that the useful pingpong between coder and reviewers has been replaced by the similar pingpong between the prompter and the agent.
In my company, people found out that if they use an agent that commits and do the pull/merge request, they can approve it themselves and bypass a second set of eyes.

Since they are the one doing the prompting, they quickly got lazy of actually reviewing the output from the LLM which means that nobody is reviewing anything.

It hasn't happened yet but I guess that is how you end up with major outages.

This is everywhere to my knowledge, and engineers are burning out left and right with stress because of how little anyone understands the code, and how much of a mountain of nobody knowing anything they have to handle. We are turning our critical infrastructure mechanisms into stochastic grey goo.

I find the engineers currently thriving are the ones who never gave a fuck about anything but their own advancement and are happy to drop weeks of work on others and take the credit.

loading story #50543071
loading story #50541860
loading story #50541508
loading story #50540603
loading story #50541261
The compressed timelines which result when leadership sees how quickly code can be produced becomes pressure on the reviewer to not be a blocker.
loading story #50540786
loading story #50540685
> The way forward could involve dropping code reviews altogether.

I unironically agree. At least, the current form of code reviews needs to go.

Currently we spend all effort reviewing individual changes and no effort reviewing the entire system, or the underlying dependencies.

If you sat down to learn a legacy codebase, you would not review it in the order of commits. Reviewing individual commits is inefficient.

It would be better to have an entire team of reviewers systematically reviewing ALL the code, over and over, including the code of dependencies.

We need better tooling and heuristics to help focus review efforts on the code that is most risky.

loading story #50544531
I stopped reviewing for things like cognitive load and future extensibility a while back. When refactoring is almost effortless, writing future-proof code is unnecessary.

I review on a high level, but on a line-by-line level, it’s pointless to try to trace everything. It either works or it doesn’t. Have good tests.

loading story #50544178
> "nobody will be qualified to or really interested in doing the code reviews"

It is a job you know... doing what is necessary to keep yourself qualified is an implicit requirement, and "being interested" is irrelevant. It's work.

loading story #50541295
> The way forward could involve dropping code reviews altogether.

Yes, if we stop doing quality controls, we don't have the problem of being hung up on quality controls. You do of course have SOC-2 compliance which is a legally auditable attestation, so if you claim you do code review but don't you're committing fraud unless you drop that.

That would be great, IF there were valuable ping-pong between the prompter and the agent. For skilled engineers the game between themselves and the agent is enough. But most people are submitting senseless slop grenades for review.

Claude always comes up with more things to add to the code that are pure bloat and become inbred bombs over several iterations, and some people can't distinguish what suggestions to reject and go along with everything Claude suggests to the detriment of the program #garrytangate

It’s hilarious already. People ask for code reviews and two or three people drop in with a bunch of AI code reviews comments from their respective agents. To which, of course, the author has their agent fix those comments. Repeat and repeat. The entire thing is a performance for some authors these days.
loading story #50557341
> The way forward could involve dropping code reviews altogether. Y

It seems that the human involvement is the new "unit testing". There was a period of time when management that it was superfluous.

I can't wait for the pendulum to swing back in full force.

I'm having good luck with the approach of building a thorough requirements specs that are a few pages long, are quite reviewable, and are human written/AI reviewed to prevent it from becoming slop. I call it layered spec driven development, where the one layer is AI read only, and the other layer is the slop layer that AI can play in. The problem is that it requires slowing down just a smidge, which to management these days is more unacceptable than no one having any clue how anything works.