Ask HN: How to speed up code-reviews?

First articulate the purpose of code reviews (typically, there are about 3 or 4).

Then think about whether there are other, better ways, to accomplish those goals, assuming you still want to reach those goals. That can inform how you modify your SDLC.

Go all in on AI, stop worrying about quality. When shit breaks, spin a replica and have an agent look at the logs and figure it out while hoping the replica restores service. It might sound counter-intuitive, but you know who's doing it? Your competition.

It's cheaper to create than it is to understand, so if you have no understanding in your SDLC, you can't expect to have it on incidents.

What @pluc said basically. You could use stuff like https://bte.mills.io and https://git.mills.io/prologic/squint to help test/validate the "behaviour" of what is being developed/built. Try to think of yourself as the "Product Designer" and "Product Owner". Worry less about the _actual_ code itself, and more about how the software/product behaves. Write specifications that can be validated and ask yoru favourite coding assistant to ensure that those are validated.

Writing tests should be "practically free" too

Depends what do you look for in code review? I only check the code architecture.

Does it use dependency injection as we set it up? Are domain/data/presentation classes in correct modules? Is the data flow hierarchy correct according to clean arch? Are unit tests written, is the code coverage better or at least the same? Are classes doing specific things named according to patterns how we name them? Is everything generally following the same pattern as the rest of the project?

Code is mostly about patterns, and if you know the pattern, making sure the AI agent follows it gives you the peace of mind that you can also manually check and understand it later. Everything else is a fine detail, and at the moment, this is something that I don't think is that important unless you have specific bottlenecks or issues, which again... you fix with a new prompt...

Trigger automated review at the end of CI, but do stay very in the loop, both during development and review. This idea that you can let the machines write and decide things, and you just need to check, is the wrong approach. Tell the bots what the architecture should look like and how the core loops should work. These are places our machine gods make poor decisions and many mistakes.

be willing to change paradigm to what works well for you specifically. Gather buy-in towards a specific shape, if there are other devs involved.

my teams and I use small sub-branch/stacked PRs in a specific order (contract, spec, mechanics, logic, wiring, cleanup) -> feature branch -> staging. PRs need to stay small enough that we can (1) review intent, (2) review code, and (3) hold the PR stack in mind. It adds overhead to introduce sanity to the current speed of developing with AI.

every contract has specs, every spec touches logic. If any one of those is orphaned, identify why.

it boils down to "identify the fundamentals that matter to your way of operating and your company's needs"

if someone is just letting a third-party LLM at the code without any structure... blessed be their sleepless nights.

[flagged]

You can’t make humans read faster, in order to speed up review time, you need to write less.

AI is very good at writing a ton of overly complex code so the you gotta babysit it sometimes to get a lean code.

On the other hand, reviewing the code needs a better surface. It’s still the hard part, but what kills me is that GitHub is still expecting us to review PRs the same way, and it’s increasingly stressful due to GitHub’s poor support for a good PR review experience, I ended up building my own solution (https://pyor.review) to make reviewing the code a lot less tedious and closer to how I want to look at code.

One of the features that actually makes me read less code confidently is that it highlights the moved code, so in a large refactor PR, i can skip reviewing the parts of the code that just moved without change, it also takes AI-assisted review differently as it groups files depending on importance and flags noise, so it’s not adding more walls of text for me to read.

I found this to be the only way to move faster.

The purpose of code review is to check if the PR implements what was meant to be implemented. The code should be verified against task specification and ADRs, plus some technical checks like comments, test coverage, semantics. Not everything may be found in code review and tests. I recommend also mutation tests. In one of my projects mutation tests discovered a real problem in the code.

We are building zeroshot.sh to automate the entire implementation, review, and acceptance testing workflow as a customizable graph with adverserial cycles that you can define to match your QA requirements. Should be relevant to check out for people in this thread. MIT open-source.

We built it for ourselves and havent reviewed code since starting to use it.