Ah, that's only true if whoever is in charge is willing to _have_ a bottleneck in reviewing. In some software development groups, there is a strong pressure for reviews to pass, i.e. expectation that reviewers approve; and the notion of veto is not common, so that if some reviewer objects, the implementing developer can find others who would be willing to accept, bypassing the objections. Also, few people are willing to conduct long reviews of a lot of code, and even less people are willing to read multiple comments in a long review of a lot of code.
Now, in some projects, there are only one or two "owners" or "marshals" for some areas of the code, so they can apply a strict standard if they want to, but - their time is limited, meaning that long LLM vibe-pull-requests are likely to either be ignored for a long time or rejected off-hand.
I have many years of the experience of of raising concerns, criticism and objections in reviews
I’ve mentored juniors and the common trait is that they rush to code without understanding, then they spend days trying to fix things. Coding will seem like a real bottleneck for them.
As a senior (of sorts), even though I don't quite rush to code, I often find myself starting to code something 'naively', while my understanding is lacking (typically in a tangled, inconsistent and poorly documented codebase). But what probably sets me apart from juniors is how I handle getting stuck, or rather what it means for me to try to "fix things". I spend time thinking about what I've discovered that has gotten me stuck, what I must take into account, and how I should alter my approach (or refactor the existing code to be more accommodating).
Sometimes I manage to formulate ideas apriori that reduce the frequency of my getting stuck, and/or the extent to which I need to backtrack. But - not always.
Have you ever heard of the V model (https://en.wikipedia.org/wiki/V-model) ?
Long story short: it does not work, because the act of coding adds new valuable inputs that alters the (original) design.
One might say "you just have to know", which is an equivalent to "you just have to figure out the future", "you just have to be perfect" and other non-sense (which does explain why V cycle does not work, high inefficient, low quality outcome, bad method)
People that do trial and errors lacks direction and their code is often fragile, especially with evolving situation. Because their have failed to grasp the deeper truth of the domain. The usual signs are tightly coupled code and code churn.
Honestly, where did the bottleneck end up now ? It sure isn't simply reviewing, or designing, so where is it ?
Assuming you're comparing to experienced human developers that are good at what they do, then I think you have to define what "better" means here. It's clear that you can get correctly functioning software faster in many cases, but it's not clear that the design will be better in terms of conciseness and readability or that it's as useful as a foundation for building upon later if nobody understands what's going on inside.
But to me, having graduated last year, it doesn't seem far-fetched to think that AIs will also get better in terms of design.
And will conciseness and readability even matter in the long term ?
It's all things I think about more and more often and I'm not sure where I will end up
Fair question. Right now the way for humans to understand code is to read it and that'll be easier if the code is concise and readable. But it's possible that we'll end up in a situation where the code is separate from the explanatory materials that humans need. This is similar to math where we might have impenetrable Lean proofs of theorems and then natural language expositions to explain the proof.
If I can shit out some vibe-coded thing over a weekend that does <useful thing> it means anybody else with the same tool can do the same thing. There is no value in the actual code itself -- the faster these models run, the more true that statement will become. In the not too distant future these things will run directly on silicone and operate at thousands of tokens a second. That means they'll iterate and explore something far faster than they do now -- mistakes they make will be fixed in seconds or perhaps milliseconds.
That being said my <useful thing> is likely only "60%" of what makes an actual product somebody would buy. It's finding the other 40% that is something I don't think that LLM's can solve. That requires human judgement and then knowledge of how to communicate that vision to your agents.
In short, I believe the challenge is knowing what to build that others would find useful. It's easy to crank out <useful thing> for yourself. Making something others can use is not. And that is, possibly, the bottleneck. But once these are fast and dirt cheap, (and that is a when not an if) the cost to iterate to something workable goes way down. Of course mumble mumble "no silver bullet" / "mythical man" month mumble mumble and all that soo......
I dunno... doesn't directly answer your question but it is what came to my mind anyway.