I'm saying we need to move away from "LGTM" focused PR reviews. Most companies have a PR reviews focused on getting thumbs-up emojis in the comments, then they merge and have a sprint planning. Nobody ever reviews the entire system. Nobody ever asks "assuming there is a mistake in this PR, would it matter? How can we make it so that it wouldn't matter?"
I never claimed AI makes no mistakes. People make mistakes, and reviewers make mistakes too.
I've worked at a lot of mediocre companies where the plan to keep the system working is "the developer will not make a mistake, and the code reviewer will not make a mistake, this is our plan, our plan is humans will not make mistakes, and then our system will continue working". This is like
It's better to ask "let's assume a human (or an AI) does make a mistake, how can we design the system to prevent that from mattering?"
Most companies don't have the capacity to do that though, so they never move beyond thumbs-up emojis. It's all about individual PRs with no sight beyond that.
Each function declares what it can touch (e.g. network, filesystem, clock) and the compiler and runtime work together to enforce it. However, I have yet to show it beats LLM-written Python plus tests and a sandbox. Models have gotten good enough at writing code that I haven't found much room for enforcement to help.
> I never claimed AI makes no mistakes. People make mistakes, and reviewers make mistakes too.
These are 2 separate things. The crux of the issue is the push towards utility over understanding. The volume of generated code means that it is impossible for understanding about the system to be achieved - and it is now the universal coding experience, not just mediocre firms.
Quantity is its own quality, as well so even a good culture will struggle to stay on top of review.
Do we not do this already? Sdlc is just defense in depth. Design, design review, pair programming, code review, layers of tests, QA, UAT.
you can't
there is no way around it
we need far more review than we economically are motivated to sustain
and hence issues like we've been having over the past week will continue and perhaps worsen
software will (as it already has been) get crappier and crappier overtime
You saying how mediocre companies feel though. They try really hard to not make mistakes, and then they get pwned and half the nations personal data gets leaked.
Why does AWS IAM exist? If we just don't make mistakes in all our AWS services, we don't need IAM. Let's just not make mistakes.
Truth is, there is A LOT of effort put forth by serious organizations to minimize how much a mistake in one part of the system matters to the rest of the system.
You started out mocking me, "naw bro he thinks that AI will make no mistakes", and now here you are arguing that to be successful we have to ensure that humans don't make mistakes. Do you think that's realistic?
This is a No True Scotsman argument.
The prescription you suggest is not dependent on its inspiration, so it can still be discussed.
All firms right now, even those with better than average cultures, are dealing with AI code workflows.
Previously the volume of code generated over time was lower, even mediocre code review was useful enough over all the code that people generated.
Today, the ratio of verification capacity to generation capacity has shifted drastically. Even with automated tooling, the amount of verification isn’t enough to stay on top of the generated code.
This changes only when leadership values reviewer capacity, or builds a triage/priority list for code which must be understood.
Humans can be ultra competent if people are actually paying them to be artisans or otherwise motivating them to truly be that way. That's how we have some of the architecture we have today and historically.
My current pipeline with AI-generated code (and my own code too) is that I run AI reviewers several times on a single PR (the way LLMs work, due to attention optimizations, quantization issues, token sampling issues, harness issues -- AI agents often overlook some things on the first attempt), then I assemble the final report and we quickly decide together what needs to be addressed (critical stuff) and what's okay as is. I quickly skim the change set myself too, to see what the shape of the tests is, and what code areas were touched, just to be informed, and that's about it. I don't feel exhausted personally, because it pays off when there's a working feature at the end of the day