Today I announced that I won't be reviewing AI generated PRs at company meeting
Posted by Evgenii42@reddit | ExperiencedDevs | View on Reddit | 318 comments
I was reviewing PRs from data scientists (data scientists) for the web service. The data scientists were using Claude Code to generate changes to the web site (rails/vue) and send PRs to the web developers. I made a decision that I no longer want to review this code, since it's AI generated and people who generate it do not understand it. The reason is that I find it very easy for me to miss issues during such PR reviews, because the AI generated code look good and plausible, so it will lead to bugs and security issues.
Today we had a company-wide meeting, and during my turn I explained the issue and announced that I no longer be reviewing these PRs. It went surprisingly well. I got massive support from people and the leadership also acknowledged the issues. I can now go back to what I love the most -> writing code :D.
pr0cess1ng@reddit
This is not the economy to be doing that brother...
gcampos@reddit
Quite the inverse.
When anyone can just produce slop, you can justify your paycheck by being the one keeping the quality bar high. If OP company doesnt care about quality, their time was already counted anyways.
kowdermesiter@reddit
What you call slop, others call it a problem they want to solve. If you don't like those PR-s, talk to them.
gcampos@reddit
I'm assuming OP already tried this road before going to the nuclear option
kowdermesiter@reddit
Not sure, but simply refusing to review AI PR-s is a fireable offense. Engineers need to adopt to changed environments and now AI is one.
I'd setup more guardrails, more tests, processes for any team that wants to contribute to my repo.
"Don't send AI slop" is just ignoring the problem that can be solved.
notjim@reddit
He’s not setting the bar high, he’s just being a roadblock. People are trying to use the available tools to move forward and op just announced he’s not willing to help them. Bad look imo.
gcampos@reddit
If the road is unsafe, you want someone to block to road
Few_Raisin_8981@reddit
Lol you think the CEO of senior exec care about the code quality in the codebase?
gcampos@reddit
No, but they will care about why every week there is a major incident and everyone needs to stop what they are doing for half day to fix it
YK5Djvx2Mh@reddit
I feel the major incidents come from when someone is under pressure to get a feature out, and they dont understand the full context (so obviously they cant inform AI correctly). Then things blow up, and they dont know how to fix it. That has always been the case, and honestly I think a resolution is often found quicker.
What I am seeing is frequent PRs that are 1000s of lines of code, that dont plug into the code base, they just create new, they're horribly inefficient and unreadable. Management doesnt care because they can ship features faster, and hopefully you find the major bugs during testing or a pilot. What they dont realize is that its costing them an insane amount of money in time wasted with inefficient code, resource allocation for stupid large binaries, and token spending by encouraging use of AI even when find and replace works for free. But again, the first two points have always been a problem.
zzzthelastuser@reddit
That's the problem. Nobody cares until you are long gone and the effects start to surge. Then they will hire someone else to fix it. Rinse and repeat.
zzzthelastuser@reddit
That's the problem. Nobody cares about your work in the company until you are long gone and the effects start to surge. Then they will just hire someone else to fix it. Rinse and repeat.
You as a individual developer don't matter to the company. You are just a resource with a name.
SignoreBanana@reddit
I wouldn't do it myself because I have three people relying on me, but I give nothing but kudos to folks like OP willing to put their jobs on the line for principle. We should all exemplify humanity so well.
kdawg94@reddit
Can't we still unionize?
zozoped@reddit
It’s the experienced developer’s job to set good practices in the company. He is 100% right in this.
cbusmatty@reddit
Never in the history of time, has the guy who stood up in a team meeting and announced something, was the guy who is right. This is performative and ridiculous and counterproductive and egotistical
WalidfromMorocco@reddit
Please explain to the rest of the class how this is performative and counterproductive ?
cbusmatty@reddit
Making announcements at company meetings, without informing any other peer are people who have no paths to quality, they are purely workers. They are not on any staff path. They are code monkeys.
This is what you do when you want people to go “and then everyone clapped”. Not institutional change
zozoped@reddit
Agents. Agents will review. As they should.
YK5Djvx2Mh@reddit
I will never understand this. Why have AI review AI written code after the PR is created. Have the agents review before submitting, then have humans review the PRs.
Having agents review the PRs just tells me you dont trust your team mates to follow procedure, or you dont have good procedures.
zozoped@reddit
Actually it's the other way round. It's our job as humans to give work to AI, it's not up to them to tell us what to do. An agent writing code and filing a PR and asking a human to review it is basically us having to review automatically generated code - that's stupid.
Us owning the code and having AI reviewing it to help us figure out what could be done better is the way to go. It's also what I've found is the most effective if you want to avoid having to correct slop.
YK5Djvx2Mh@reddit
You must work at one of those unicorns that care about code quality over speed. Are you hiring?
Evinceo@reddit
I expected the edit to be "Edit: I was let go today"
East-Programmer3788@reddit
This just tells me that you previously just approved PRs because they looked good and plausible.
MaleficentCow8513@reddit
It’s not even that AI generated code is clean and passes the smell tests. The problem is that it’s so voluminous. If I’m a maintainer, I’m simply not comfortable rubber stamping 1000+ line merges
paradoxbound@reddit
This is a sensible choice. I have a heavily agentic workflow but I review all the changes and if I don’t understand it then the AI has to justify it. Only then does it go out for PR review from other humans.
nfw04@reddit
This is just like copying and pasting from StackOverflow in 2010
Oscar_the_Hobbit@reddit
I also sorta did that. But didn't go so well. I was leading a greenfield project. Hard project too. We got a total of 1 month runway to deliver it to production... We were using AI, responsibly. But leadership got eager and pressured for faster delivery. Manager started vibecoding and opening huge PRs that were just impossible to review. They openly said "I believe by the end of the year no one will be writing code anymore". So when it got chaotic I decided to step away. I said there's now no meaningful way I can contribute properly and used the corporate speak version of this "I'm not empowered to do my best work".
Funny thing is that they've now hit and went through the the ETA I initially estimated as reasonable for a proper release. That is, they are now taking longer to deliver a production ready project that it would have taken of we'd done things propertly and I'm loving they slowly realizing it. MVP was FAST but after that, just stumbling around in the dark, and instead of fixing the foundations they keep adding features (or should I say, promises of features) which serve only to entice the stakeholders eyes and years.
Basic-Lobster3603@reddit
this is exactly what I'm seeing at work too. except timelines are now measured in weeks not months.
we moved so fast to prototype a POC. the team can do all this just as fast for production.
Evgenii42@reddit (OP)
That's just sad. Thanks for sharing.
vooglie@reddit
No one should be raising PRs they don’t understand - whether it was written by AI or not,
Hot-Profession4091@reddit
Hard disagree. I’ll raise a PR I don’t understand.
> Hey, there’s this bug. Here’s the repro. I’m unfamiliar with this particular code so [agent] recommended this. I’m not sure if this is the “right” fix.
Most of the time it is not the right fix, but it starts the conversation and we get the right fix done.
vooglie@reddit
This is such a waste of time. Why not just create a branch and collaborate?
Hot-Profession4091@reddit
How is that not _exactly_ what this is?
vooglie@reddit
A PR is a request to merge your changes to a destination branch with the expectation that it is production ready. What you’re wanting is either a draft PR or just working in another branch. The expectations around both are quite different and generally people will be annoyed to get draft PRs as full PRs. Also in places with CICD a PR triggers a number of actions which would be wasteful here. IMO you’re abusing the PR process and that might be fine where you’re working but that’s not the industry standard.
Inf3rn0_munkee@reddit
How do the reviewers feel about this?
Something that seems to get forgotten often is that reviewing a PR takes time (remember time is money too)
If a senior dev reviews 10 PRs that result in only 2-3 being right, then 7-8 of those PRs were time wasted and therefore money the company wasted.
Hot-Profession4091@reddit
I’ve never had anything but appreciation, collaboration, and good will. Because I’m being up front about my lack of knowledge in a place where they’re the expert and I’m bringing a test and at least some possible solution.
Inf3rn0_munkee@reddit
If the reviewers of your PRs are happy with it and the time spent on it, then that's great for your team.
YakaryBovine@reddit
Right, but that’s not functionally a PR. It’s just a commit you’re sharing with somebody. There’s no expectation it’s mergable.
wise0wl@reddit
Shouldn’t, but that’s where things are heading everywhere. Companies only care if less money is spent and opportunity is not lost. What’s the difference between a piece of closed source code you license for cheap, or vibe coded slop you make for cheap? The vibe coded slop has a better chance of having bugs fixed quickly. I’m not arguing for slop, but I understand the business owners reasoning.
I’m slop coding too. I review everything though. I have to. I have to support it afterwards and at 2am when shit breaks I want to know instinctively where it may break. So maybe not total slip, lol.
chickadee-guy@reddit
What? Its the complete opposite
vacant_gonzo@reddit
I find it staggering that even very senior people don’t seem to understand. It doesn’t matter whether the code was from AI in 2 minutes, or from reading official docs for 2 hours - if you submit it you need to understand it.
ether_reddit@reddit
"but I didn't submit it -- the bot did" -- which is why I block on github every AI bot I come across. If you can't be bothered to take the changes the AI produced and review them yourself, and submit them under your own name, then I don't want to see it.
nmur@reddit
A few years ago, if someone pulled a block of code directly from a Stack Overflow answer and just slapped it directly into a PR, it would be considered totally unacceptable.
I don't know why people feel like AI generated code gives them a pass. Code is code.
edgmnt_net@reddit
The main appeal of AI seems to be generating boilerplate you won't read and glue code based on documentation you didn't bother to consult.
coderstephen@reddit
AI hype train means we now measure productivity by "how much AI Kool-Aid you are drinking" instead of anything reasonable. Some companies are going totally off the deep end right now.
BrasilianEngineer@reddit
I pulled some code from stack overflow for calculating Easter for any given year (See Gauss Easter algorithm). To this day, around 8 years later, I still don't understand that code.
warr-den@reddit
I think most people would agree that a math formula can be a black box for the devs, but if you don't understand the implementation then that's a problem. I don't have to understand why the math formula for the zenith angle of the sun is the way that it is, but I definitely need to understand how to put it into code or connect it to the larger project
user_of_the_week@reddit
Slop Overflow
SubstantialSeesaw374@reddit
Good new coined term for when a project gets too large for an LLM to understand it well enough to contribute to it coherently.
atxgossiphound@reddit
I’ve started to use the term slop creep to describe how architecture can slowly move from good to a jumbled mess without anyone knowing. At some point, it overflows.
This, “Slop creep leads to slop overflow.” I’m running with that phrase.
user_of_the_week@reddit
Funny, I just thought what would a real life Slop Overflow look like, but someone else already had the same idea and even implemented it: https://slop-overflow.com
CreativeGPX@reddit
It's about ownership. If you understand it you can own the problems associated with it. If you don't, you can't. You can't fire software that malfunctions, but you can fire a person who makes harmful choices.
Managers should understand that. It's not uncommon for certain roles/positions to exist solely for the purpose of having somebody to be accountable and take blame. I'd say it's an open secret, but it's not even a secret. I've heard management say it flat out, for example, when it comes to hiring a third party to do something compared to their team doing something in-house.
Even if AI dramatically changes or reduces the workforce, this idea that roles correspond to blame (and therefore the presumption of being proactive about issues in some area) will need to continue.
Isofruit@reddit
What keeps coming to my mind on tales of folks just vibe-slopping some PRs with no care or consideration: What value do they provide over just the LLM they prompted? None. The value of their contribution is worthless because the LLM did all the work, so one could just use the LLM without them. The value they're supposed to provide is evaluating the work the LLM did and correcting it. Without that, you should just be fired.
SansSariph@reddit
I'd go a step further and say they've contributed negative value. If someone is asking me to review garbage they didn't bother reviewing themselves, they've taxed my attention (and not just mine) for zero value, and that attention could've been useful elsewhere.
ESpy__007@reddit
I have similar feelings about review comments that are just noise.
SansSariph@reddit
Agreed on AI comments that don't spot an actual issue
If it's a comment from a human it's an opportunity at least to understand where they're coming from - which is sort of the meta point, to me: is the communication I'm responding to backed by human judgment and someone who is accountable for product in the same way I am? Or is it generated?
ESpy__007@reddit
Sometimes I have difficulty telling the difference between review bot comments and humans (who may or may not be using AI to generate their comments).
We seem to have a few engineers who like to make comments for the sake of making comments with no grounding in reality, which is slightly frustrating.
I have been rewriting the review bot's instructions to try and rein it in slightly; we shall see if that improves its behaviour.
thekwoka@reddit
I'm more okay with AI review things just as a quick sanity check.
Mainly with the kind of presumption that everything it says isn't helpful, so the "cost" of checking its comments is quite low, and can sometimes catch some easy things that would have wasted human time reviewing.
thekwoka@reddit
yeah, they make the system work worse, produce a worse product, take a salary, AND eat up token budgets.
SecretaryAntique8603@reddit
100% agree. The same goes when a question is asked and someone helpfully chimes in with “I have no clue but ChatGPT says…”
Thanks, now I’m wasting my time fact checking a robot hallucination for you, how exactly is this helpful to me?
johnpeters42@reddit
"So what would you say that you do here?"
-manabreak@reddit
I'm a people person!
Evgenii42@reddit (OP)
my favorite movie
thekwoka@reddit
or at least understand the important parts.
There is kind of a reality where you can end up with code that is a bit "idk why this works...but it does and is necessary"
Turbulent_Idea7328@reddit
Me too. I don't consider myself an exceptionally strong developer but reading these things makes my head spin.
If you don't understand something about your code, then idk... ask AI to explain it to you?
AI is really a great tool for learning when one puts a modest amount of effort.
AnAcceptableUserName@reddit
I don't get it either.
Honestly I've learned a ton since I started reviewing gen AI PRs, because I won't put my name on anything (like a review approval) that I don't understand myself. Agents tends to use a lot of patterns and functions myself and my human coworkers wouldn't typically reach for, so there's been lots of exposure to new (to me) things
Velocity of those "there's no way that works...holy shit" learning moments has basically quadrupled over the past year for me. And I'm not new to this. 10+ yoe. Hearing the people submitting this stuff aren't taking the time to understand it themselves blows me away.
Basic-Lobster3603@reddit
wish that was the case. we are being first to vibe at an insane rate. No dev understands what is going on. it's just AI implementation, AI writes code, AI review Code, someone says they are reviewing but they are just pushing AI review agent to do it. I don't think anyone could actually explain any line of what was written in the past month.
it's an awful environment
estebanredditor@reddit
>we are being told to vibe at an insane rate
I'd like to understand how these expectations are being laid out. Has this come through a direct manager? Is it something upper-management mentions more broadly? Or maybe it's implicit in the way performance is measured, as in "if I don't do it, others seem to do more work than me".
Basic-Lobster3603@reddit
top down push 100%. not really a other people do more work so I must follow type of thing
vooglie@reddit
But you put your name to every PR you create. If the company culture is so blasé then I guess it doesn’t even matter however for the sake of reducing support incidents I hope you at least have good end to end testing as quality gates.
Basic-Lobster3603@reddit
like the name matters. no one cares any more at all and it's the direction they want to take the company it's a non technical company. we have AI quality checks and 0 end to end tests. but we have potentially hundreds of unit tests that may or may not actually be worth something. lul
Dry_Author8849@reddit
Non technical people never cared. It's not their job.
If you hire a construction company, you don't care about the proportion of concrete mix, the thickness of steel bars and other details. You don't expect the building to collapse, you trust company engineers take care of that.
I guess no one in your company is raising the hand and explaining that they are trying to accomplish engineering work without the knowledge and the thing may collapse.
Anyways, responsibility can't be delegated. When something breaks hard, someone will just look the commit history (or some external engineer will be hired for auditing) a culprit will be found and forced to take responsibility. Heads will roll.
That's what will happen. The only chance for that to end well is that what AI is building is solid, which is likely not the case.
Be careful with your commits.
Cheers!
subma-fuckin-rine@reddit
Problem is that concrete or buildings are very hard and expensive to replace once built. Software not as much. Everyone is drinking the AI kool aid and thinks even if it makes mistakes and breaks things, it can go back and fix them easily.
Personally I think that's a dumb take because at that point it's not even faster than doing it the right way from the start
vooglie@reddit
I guess it sounds low stakes enough that it doesn’t matter then lol
Basic-Lobster3603@reddit
I wouldn't call it low stakes but its. pretty critical that the code actually works for the calculations and queries needed to serve the busines
vooglie@reddit
Yeesh
Well I hope you’re not on call
Basic-Lobster3603@reddit
I will definitely be on some support rotation whatever that looks like in the future
Aggravating_Branch63@reddit
What can go wrong? ;) and who will get the blame? I think I know….
itsgreater9000@reddit
I've commented here about being that "one reliable dev" that people go to for help. Was told by management to stop blocking PRs and that I need to close tickets more quickly. Just commenting once with concerns (so at least there's a paper trail) and approving PRs. It's what my coworkers are doing, so I just push whatever the AI generated with some spot checking and call it a day. I can't keep up and value my health and sanity over good work at this point.
Already had a bunch of issues but whatever, management seems happy
SubstantialSeesaw374@reddit
And you can see the effects in pretty much every site. More downtime, more stupid bugs, more deranged design choices. It’s like watching crack wipe out a vibrant community.
schmerg-uk@reddit
I'm very much with OP on this...
What gets me is they ask the AI to do something, it makes 100 changes that they think they understand, they glance at the first few, then submit an MR for me to review.
For the cost of hundreds of CPU hours but only 2 or 3 minutes of their time, I'm now expected to review this (and a codeowner of certain key items I'm obliged to do so), examining each change for: is this correct; does it do what it says; does this also require a further change that the AI hasn't done; has the change been explained / justified; are the existing comments and other documentation still accurate; is this consistent; does this strengthen or weaken checks and guards that in the previous form would catch common mistakes with this item (static assertions etc)
Sure the code compiles, but it was compiling before... if you've ruined the fact that the previous code would by design NOT compile if certain errors were made then that's quite hard to test in a CI type of environment.
And when I come up with a list of 20 or so spots that it's missed, not documented, contradicted itself, removed checks etc etc then somehow this makes me a nitpicking luddite for doing the work they should have done in the first place...
Not to mention what does this actually achieve, is it worthwhile, does it make the code better or worse..
estebanredditor@reddit
This ties back to the responsibilities of the reviewer, and why code review exists in the first place.
You should not be responsible for making sure that the code is correct, follows conventions, or contains blatant mistakes. You're a peer reviewer, a collaborator checking a colleague's work. Are the decisions sound and justified? Is it in line with our team's goals and engineering practices (not code- but higher-level)? If it touches code the author doesn't have authority over or experience with then sure, review more carefully and be nitpicky. But not because they're not accountable, simply because they're more likely to make a mistake or be unaware of certain consequence.
Not saying your comment disagrees, just pointing it out as a fault of software engineering culture as of recent.
schmerg-uk@reddit
Agreed, but then I'm more used to properly structured Software Inspections (Fagan, Gilb etc) not the dog and pony shows that modern reviews have become, and if I don't do this then it's just more shit in the codebase that will end up being my job to clean up.
estebanredditor@reddit
I think most of the time *they don't know* that they don't understand their own PRs, because they don't review them. They probably have some sort of heuristic for verification, like running tests (including newly generated ones) or doing a manual smoke test. At a certain pace, it's not possible to read as much code as one's pressured to output.
AI coding tools are increasing the expectation of throughput for devs at an unsustainable rate. Existing processes are not ready for the volume, and most companies aren't working on fixing them.
crustyeng@reddit
Imagine not even being able to ask the guy ‘why did you do this?’… because he didn’t and doesn’t even know what you’re talking about.
It’s bad.
unconceivables@reddit
We had a senior recently should have known better than to submit PRs with code he didn't understand, and when he kept doing it despite being warned over and over he was fired. The worst part is he did have good technical skills, but some people don't seem to be able to use AI without shutting off their brain.
liquidpele@reddit
Companies have never had to really gatekeep PRs though, because until recently it was just learning opportunity... but now it's gish gallop.
ButchDeanCA@reddit
True, but I think it’s also undeniable that AI is heavily contributing to PRs where the issuer has little to no clue what they claim to have done.
oupablo@reddit
Meh. It really depends on the blast radius. A vibe generated helper tool, go for it. A PR from someone else to fix a bug in an internal tool, maybe if it's a small fix. A full on vibe coded product is where I had to draw the line at work.
We we literally had a PM generate a giant block of code that they wanted to "Demo" to a customer then release within two weeks if the customer was happy. They said, "we'll have engineering review it if the demo goes well." It's not even remotely reasonable to ask an engineer to review a couple thousand lines and resolve any issues in two weeks while a customer is breathing down our necks for something you've already shown them. People don't seem to understand the nuance that goes into the way things are developed to run at scale vs "it works on my machine".
mvpmvh@reddit
Business is not spending tokens to not ship code faster. The org has all these different teams, each with their own okrs, kpis, and roadmaps. The old way of doing business was to have team a start a feature and then get stuck when they needed team b to take over for the domain that team b owns. Tech leads/agile scrum masters had to cross-coordinate to figure out when team b could commit to delivering the features for team a, thus plunging team a's velocity.
But now every team can run full steam ahead! No more wasting time trying to "collaborate" with domain experts from other service owners. Everyone is the service owner! Everyone is the domain expert! Or, at least Claude is. However, in the spirit of maintaining communication and collaboration and coordination, teams will send PRs to each other for review instead of tickets to be implemented. You're welcome, we already implemented it for you, just sign off on it. Be a team player, not a blocker.
Tl;dr: no, a data scientist is not going to use Claude to learn rails/vue (and vice versa). Claude is not being shoved down our throats to learn (that kills velocity).
xSaviorself@reddit
The first thing that needs to happen when an AI PR is pushed for review is that developer should self-review. Ideally after disconnecting for a day and returning with fresh eyes.
If you cannot explain the changes the AI suggested, then the result is not something we want to maintain. If it requires understanding outside our capabilities or relies on systems we do not have insight into, we will move in a different direction to stay more informed.
Development pacing with AI is so fast that failing to stay informed about what's being added to a code base is common. We need to put more onus in making sure that if we are shoving code into a codebase, we have more insight into it than "claude wrote it, ask it again".
No. You as the developer have the responsibility to understand your own contributions. If they can do the job without understanding it themselves, they are by definition replaceable cogs. That's not what we hire developers for.
talldean@reddit
I generally go with you have to own your code in production. If it causes an issue, it’s your job to fix. If it’s ring an on call pager, that’s you. If it’s part of a repeatable pattern of preventable errors, you need another job.
Putting clear and escalating consequences behind bad actions massively reduces bad actions.
Eric848448@reddit
Yeah, back in my day we just copy-pasted from Stackoverflow until it kind of did what we wanted!
Inf3rn0_munkee@reddit
Where I work I'm trying to change the mindset from "AI wrote this code" to "I wrote this code using AI".
It's a tool just like intellisense, snippets, SDK generators, etc. The person submitting the PR is responsible for the code they are submitting, if they don't understand the code and can't answer my questions on the PR then they've wasted both my time and their own.
Curious_Owl197@reddit
What if I understand it now, but not in 1 week lol. We're producing so much code with ai it's impossible to keep up
TonyGTO@reddit
Why not?
vooglie@reddit
Is that a serious question?
yknx4@reddit
That’s quite literally the only extra rule we have for ai code in my company. You must understand and be able to explain whatever the ai outputs
Every other detail gets treated the same, it needs proper test coverage and be gated with feature flags.
ConspicuousPineapple@reddit
Right. At the end of the day a review is only best effort. It's going to miss some things inevitably, as it's harder to review code than to write it. The only person responsible for the code quality is the one who wrote it, so of course if they don't understand what was written it's gonna cause issues.
SubstantialSeesaw374@reddit
Exactly, the problem isn’t the lack of writing but the lack of reading.
SignoreBanana@reddit
Simple as. I wouldn't expect it from a proper developer, why would I accept it from someone who wasn't even a developer.
Evgenii42@reddit (OP)
Yes! I have no issues with people using AI to generate code. I do it myself it's massively useful. But the person who uses the AI needs to understand the code it is generating.
Chunkz_IsAlreadyTakn@reddit
I started asking the devs behind these kind if PRs to do pair reviews with me and it was obvious they no ide how the PR worked. Most devs got their act together and its a real non issue anymore.
ktmd-life@reddit
THIS. It doesn’t matter if it’s not AI generated, if it is copy pasted code from stackoverflow that they can’t even explain, it should not get approved.
This is a basic requirement for PRs.
pro-taco@reddit
Remind me in one week: do they still have a job?
StableStack@reddit
We have a framework where most PR aren't reviewed by humans, BUT the most sensitive ones are.
We built a bot (agentic) that reviewed each PR and categorized it into a risk category (low, medium, high), to illustrate my point:
* Low might be a PR behind a feature flag, with no migration, no shared contract changes, shipping to internal users first.
* High could be a migration of a database index on a 50 million row table
Based on that, the PR gets routed and gets the appropriate human oversight. This allows us to avoid bombarding engineers with tsunamis of code reviews but also keep our reliability metrics up.
SawToothKernel@reddit
The reality is that this is only going to get worse. So the response is not to disengage, but to aid in building the guardrails. You company needs your help and it seems like you're just abandoning them in their time of need.
apnorton@reddit
I think the better line to draw is that to not review PRs that were made by people who are unable to self-evaluate the changes they've made.
Evgenii42@reddit (OP)
Yes sorry, I realised my title was misleading. The problem is not with AI but with the fact that the people who use it do not understand the code it generates.
sneeje00@reddit
So the solution is for no review? Am I misunderstanding?
alinroc@reddit
The solution is to decline a PR that the developer didn't author themselves and therefore doesn't understand.
sneeje00@reddit
I'm with you, yes. The biggest thing I'm afraid of (as an AI researcher) is this idea that we just give up accountability. Due to capitalism, there will be enormous pressure to just accept whatever the outcomes of these algorithms are because it will be too costly to double check them.
Essentially the arguments going to be, the whole point of innovation and AI is to reduce human effort and having a human in the loop doesn't do that. That argument terrifies me.
Samakuutra@reddit
I got your point.
Management wants speed, lower cost, and higher profit. They don't care about moral accountability — they want someone to blame when things break. If AI makes as few or fewer mistakes than humans, they'll happily trade "someone to blame" for "less blaming needed." As long as it's profitable, management will adapt to whatever delivers that profit.
Today, management still relies on (and prefers) humans for accountability. But when the process shifts to code with no accountable author — and I agree that's a nightmare scenario — they will replace the human reviewers with AI reviewers too.
sneeje00@reddit
We've seen a glimpse in healthcare. Right now, yes, it is a hellscape and denials are difficult to address but effectively you can get to "give me the doctor and licence # that said this wasn't medically necessary and have them explain why they have the expertise to make this judgement."
Imagine when AI starts wholesale denying claims and the healthcare provider basically shrugs and says, because the algorithm said so. The HC company that Luigi is involved with tried using it and like 90%+ of claims denied were improperly denied. The whole system breaks down if we don't have accountable humans in the loop.
Zetus@reddit
these health insurance companies literally shouldn't be able to exist, we need single payer healthcare asap
Glad-Researcher2738@reddit
Simple just request changes pointing out the issues. If a person takes too many rounds of review and still unable to finish a PR it's a competency issue regardless of whichever tool they use to write code.
apnorton@reddit
No; that's not a game the reviewer can win. It costs the person who creates a crap PR with AI nearly no time, while the time required for a reviewer point out issues is not insignificant.
I have no qualms about flat rejecting a PR with no comment from someone who cannot evaluate their own work.
mirageofstars@reddit
Yep and then the next thing is the PR reviewer gets in trouble for blocking progress and not getting enough points done.
chickadee-guy@reddit
Our management not so subtly told me to stop blocking the project and approve the slop no matter what
Thelmholtz@reddit
Yeah but a conscious review takes time, and if you are getting DDoSed by people who haven't even read their code you can't do valuable work and are stuck reviewing poor PRs that won't get merged.
At my company we have a pre-AI rule I have come to appreciate now: you can merge a PR on any repo, but if you do it on one you don't own, you should add your team as code owner if that part, and become co-responsible for that feature in prod as well, meaning you have to be responsible for alerts, monitors and if it applies, on call.
It has stopped me from merging minor QoL PRs, so it's not all rainbows, but hasn't stopped me from merging things we really need and other teams didnt have capacity to address. It does an amazing job at stopping vibe coded PRs without understanding though: Claude might be able to write your code, but it still won't be there to cover for you when you are troubleshooting a SEV-2 incident on a Friday afternoon.
SansSariph@reddit
Your last paragraph describes taking accountability for not only your own work but making it a team commitment, and it's a beautiful thing to hear. Brings a tear to my eye
Thelmholtz@reddit
Yeah it's a great place to work. Pay is meh but I prefer this to great pay, shitty conditions.
ketralnis@reddit
No. A PR implicitly comes with reasoning supplied to generate it. If you can’t assume that, you’re not going to get to a successful review via a series of nits.
SansSariph@reddit
What a fantastic metaphor
Glad-Researcher2738@reddit
If the PR is a dump truck of rubble just push back on that particular PR.
If it takes too many rounds and the code is no where near being the right shape, escalate to the author's manager about the PR's author inability to do their job.
There are playbooks already in place for people who create bad PRs, regardless of how they create it.
SansSariph@reddit
Why should it be the reviewer's responsibility to take on the cognitive labor of sorting through someone else's disaster when that person put maybe 10 seconds of effort into something that will take their team at least 15 minutes to even orient themselves to, much less review?
It is utterly disrespectful and should be politely called out as such and not tolerated on a team.
BorderKeeper@reddit
Playbooks come with the assumption of amount of prs opened being manageable. I cannot babysit 4 PRs which are clearly a mess. Playbook I have is if it looks like the author didn’t understand it and I see signs of hallucination it’s instant back to the drawing board to the author from me.
SubstantialSeesaw374@reddit
Offloading the initial read through and verification onto the reviewer is giving them your work. It’s a good way to get fired, or at least really piss off whoever’s reviewing it.
DangerousPurpose5661@reddit
Thats fair…. But how can op make this conclusion?
havok_@reddit
This is exactly it. AI PRs are fine if the person driving the AI fully understands what they are submitting. The line is people who don’t understand their changes - that’s an absolute no from me too.
mr_brobot__@reddit
Meanwhile my non technical PM is shipping vibe coded slop straight into A/B tests without eng oversight 😂😭
mxldevs@reddit
The A/B test will show whether the slop is any good
Future_Manager3217@reddit
The cleaner line is not “I won’t review AI-generated PRs”. It’s “I won’t review PRs whose author can’t own the diff”.
For AI-assisted PRs, I’d make the submitter bring a small review packet before it enters the queue: intent, risk areas, tests run, what they personally verified, and what they still don’t understand.
If they can’t answer basic questions about the change, it shouldn’t consume senior review time. That keeps the rule about ownership and review bandwidth, not about which tool drafted the first version.
ghdana@reddit
You tell me do to that and I'm adding that to the GH Actions instructions lmao. Automating any gates.
But yeah I'm not opening slop PRs and no one on my team is either. We use AI to generate a lot of the code(and throw a lot of it out) but the idea that someone would open a PR that they don't understand is crazy to me, goes against our expectations as SWEs.
YK5Djvx2Mh@reddit
See but the definition of a SWE is getting blurred. We have project managers shipping code now...
mxldevs@reddit
By shipping, you mean they submit code for the engineers to fix
Affectionate_Day8483@reddit
It's getting to the point at my job where every dev is using AI for everything. I have to review multiple prs daily that have hundreds of changed files. There are no requirements or acceptance criteria for any of the work. I gave up and just started hitting approve since management won't learn without a 5 week hyper care or multiple outages.
Oo__II__oO@reddit
Make management happy: Have AI do your PR reviews.
Affectionate_Day8483@reddit
Yes, I have been doing that. I'm just limited to our AI budget. Cost controls are in place since the company is sort of going down the toilet.
Evgenii42@reddit (OP)
That's sad, are you in the position to discuss this with management or no?
Affectionate_Day8483@reddit
Probably not, I'm still new here and part of the problem is the management.
Evgenii42@reddit (OP)
I would try discussing this with more senior devs, get their supports so they can back you up in front of the management.
Affectionate_Day8483@reddit
A bit of a rant below and I appreciate the suggestions:
I think the AI coding with little testing or requirements is because of the manger's and upper managements culture of just ship it and how small the team is. The team is 2.5 software engineers, one qa, and one data engineer. Every resource is assigned their own project. It's one dev per project that's it, so if a pr comes across to me I have zero context on the change. Note this will never change.
For the pr changes, we have brought it up multiple times but have been told you have 2 hrs per day allotted outside of board work to whatever is necessary for your job. The problem is that 2 hours includes meetings, on call work, and other random stuff that happens, so the team ends up with overtime all the time.
I'm already taking steps to move on, so I really stopped caring about this job. Honestly, I wouldn't mind getting laid off at this point. This company is a bad matchup culture wise for me.
subma-fuckin-rine@reddit
Yea same, management is only caring about merging more code regardless of quality. People have spoken up but it's on deaf ears. The only thing that will spark a change is an outage of some kind
gorliggs@reddit
Yeah, no.
globalaf@reddit
Have fun being unemployed. We are way past the tipping point of AI being useful, the genie isn’t going back in the bottle, your line should be not reviewing from people who aren’t qualified to understand the code, not Not reviewing anything AI at all. But you do you.
Cyrrus1234@reddit
Don't forget, not everyone works for zuck, at some workplaces, even in this economy, you don't have to get your nose brown to stay employed.
dimebag_lives@reddit
Don't forget that a company that goes at a fraction of speed as other companies in the same space that are competing, won't have a long life especially any software as a service places where their software is now drastically devalued
globalaf@reddit
I've been saying this to people too. The big software vendors that have existed largely on their scale are going to get eviscerated, not the workers. Intuit laid off 17% of their workforce to cut costs, however those laid off engineers can use these tools just as easily as Intuit can, and I would not be surprised if they saw a serious competitor seemingly spring up out of nowhere and start eating their lunch in less than a year. Yeah they cut costs, but now their revenue is falling because they clearly took the wrong message away from the AI revolution.
dimebag_lives@reddit
Bingo. Exact same words I've heard from a technical vp at a major faang adjacent corporation. There is no going back, AI is here to stay and will be adopted way more. It's inevitable, so OP is set for failure.
This is from a 20yoe dev (me) who focused on code and has been writing code every day for the past two decades. It's totally heartbreaking but the earlier you accept it the earlier you can master agentic ai development. The days of writing code all day, bashing your head on a problem and manually testing all options, are gone.
globalaf@reddit
I also say it as someone who for a long time was firmly against anything AI getting into the codebases. Opus really has changed everything though, even the biggest holdouts are finally onboard, it is becoming very clear that if you aren’t using it, it is going to be obvious in every productivity metric you can think of.
dimebag_lives@reddit
Glad we're on track, and reason why as soon as I added agentic development on linkedin I got back many offers like the old days during the startup surge
Would I wish this didn't happened and we can code like the old days? aaaaabsolutely and I already miss it a lot. But you cannot stop the trend, it's not like blockchain where the buzzword was shoved everywhere with no real advantages in many fields, here you can already see a massive difference in impact and proficiency (if you use it right) - I still value humans in the loop and not blindly trusting it but there are still many in denial
This is good tho, it means the market won't be flooded with many seniors refusing to use AI, so there is more room for me and I feel somewhat safer for the future.
globalaf@reddit
Yeah it’s just a different job now, the old days of code monkeying are never going to come back, every senior engineer should see the writing on the wall by now else they are rapidly relegating themselves out of the job market. Actually our internal data shows the biggest uptake of AI at the beginning of the year were the juniors and the seniors, with the correlation bring stronger the more senior they are, with little adoption from intermediate engineers. This has corrected itself since then (everyone across the board is using heavily it now), but what it should tell people is that everyone who is confident in their abilities is more likely to use AI. It’s like a reverse Dunning-Kruger curve.
dimebag_lives@reddit
yep I can totally see the same too, the problem I sense is that the quality and consistency depends on the granuarity of the tasks that you offload to AI, the bigger the task the more risks you get - using proper harnesses should solve most of these problems anyway, but I'm still on the side of having code reviews in place (with first passes done by AIs), this might change too tho
what you're saying is a bit like the IQ curve memes we've seen with low IQs saying "I dont' care what to use, a computer is a computer", then mid IQs "nooo you should use gentoo and compile everything by hand" then high IQs "a computer is a computer"
(I'm not saying that whoever resists AI is stupid ofc, just that they might not really know what we're talking about as they always refused to use it OR they really think they can beat 10 parallel agents solving 10 different bugs on a properly structured repo)
globalaf@reddit
If I had to place a bet, it would be the better and faster you read and understand code, the easier it is for you to use AI, since that is basically your job now. If you are experienced enough to not be over-confident, but still aren't good enough to quickly parse and understand code, you will struggle and perhaps naturally resist the urge to use it at all. Some of these types will probably also assume it's the same for everyone and become angry boys about AI on reddit.
The reality is nobody in senior positions cares about what people have to say to compensate for their own lack of experience. "AI is too expensive", "people don't understand it", "it's all vibe coded slop", sure whatever floats their boat. All this bluster about how AI is a hoax will only serve to flush out the bad engineers who treat engineering like a dogma and cement our value (as in, yours and mine) for another few years at least by continually to out-compete these people in simple productivity metrics alone.
Saith1234@reddit
I mean I'm aware that we don't have accurate data available, since big tech is hellbent on not providing them (which is a signal in itself), but the costs are staggering: https://isaiprofitable.com/
The token prices are still way below what they should be, and we already have reports from NVIDIA, Uber and Microsoft that it is more expensive than employees.
So we have an undperpriced technology, which I won't deny, has good use cases, that will most likely in the future cost much more.
We also can observe skill atrophy, comprehension debt, bloated code bases and more security issues/outages.
And you are basically defend the position, that we should all blindly adopt it, with no skepticism, or otherwise it's ok to get fired? There are so many unknowns, it's a total valid position to adopt it slowly.
Especially, because even the most favorable studies measured at best a 50% productivity increase just for coding. It is totally fine to take it slowly and it should even be your job as profressional to give a balanced position.
If you can't do that at your workplace, it might not worth to give up all morals just for a bigger paycheck.
globalaf@reddit
Anyone who is using it earnestly knows it is way above 50%. 10x is not a joke.
Saith1234@reddit
We can throw around opinions all around, but this leads nowhere, studies are the best tools we have, even when flawed.
I'm using claude "earnestly" and my anecdotal experience of people overestimating their impact is, that they weren't very good software engineers before AI.
This funnily also aligns with earlier studies, that showed a bigger productivity gain for less skilled workers. Still this is just my opinion, and I still should stay open to it's potential, but also not seeing just the massive risk this poses, especially for all none AI-Vendors, is just as delusional as not giving the technology any credit.
globalaf@reddit
The strongest ICs in our org as recognized before any of this AI stuff are now reliably landing 300-500k of significant lines of code in a single half. I didn't make that up, I literally just looked up our top ICs (IC8/IC9) in our internal systems right now. Whatever you think of the quality of that code or the quality of that metric as a whole, if you are still at 15k SLOC for the entire year, even I as an engineer am going to ask questions about what we are even paying you for.
dimebag_lives@reddit
I'm also afraid token prices will skyrocket and working on multi model flows that allow you to use vendor LLMs for important tasks and local llms to execute them - you're not taking into account the efficiency. LLM vendors have all the incentives to make it as efficient as possible, so I don't think costs will be prohibitive
Talking to VPs here it's already clear the cost is way less than a team's cost, we have many examples of new fully fledged tools that costed 10-20-50k on tokens and they are still way less expensive than manual work considered the complexity
That website has no meaning in day-to-day work, fine to be skeptical but big companies and literally any SaaS based company should run to get as much AI impact as possible as they can literally be replaced by a clone product built with AI (=which FYI it doesnt mean vibe coded with 1 prompt lol, but handled by proficent devs that can solve N bugs in parallel at the same time, build tools and harnesses to auto verify or auto produce videos of the results, quickly validate and run other iterations of reviews to align to codebase standards etc.)
The problem with AI is that you can use it at any level, e.g. 1 big prompt to build an entire app vs many sub tasks handled one-by-one and the quality of the results can wildly vary based on the competence of the team and care about the product
Lyraele@reddit
No it isn't. That's just the sycophants wishcasting again.
dimebag_lives@reddit
Yes it is. It's fine to be still in the denial phase tho so enjoy it
chickadee-guy@reddit
Spoken like a true slop artist. Theres 0 evidence demonstrating that AI use is anything but a net negative in enterprise
globalaf@reddit
Let me just say I am perfectly okay with you spreading this fiction to every corner of engineering. Think about why that might be.
chickadee-guy@reddit
Yeah, a big time skill issue on your end. Pumping out slop and token maxxing isnt impressive
chickadee-guy@reddit
Skill issue on your end
Lyraele@reddit
Did you survive the last round of layoffs? Having a good time training the models until Zuck cuts you? It's not a genie, it's a parrot. Enjoy licking boots until the ride's over.
phillythompson@reddit
Circle jerk
Almadan@reddit
Imagine opening a PR you can't explain in detail...
People nowadays have no pride at all
winebiddle@reddit
Seriously try scrubby.ai It really makes a difference in clearing out all the bullshit from PRs.
There’s a special place in hell for any dev that sends a PR for review without testing it at all.
IrwinElGrande@reddit
Tell them to use another AI model to do the code review :lol
Tricky-Pie-7582@reddit
No, you didn’t
Wattsit@reddit
The amount of AI evangelists in this sub at this point make me really doubt the "experience" around here.
ryan_the_leach@reddit
AI's mileage varies drastically between domain problems, architectural designs, and programming language, and DOCUMENTATION PRACTICES.
I also, have doubts, but some of the "AI Evangelists" ARE experienced dev's, who are succeeding with AI, in their specific domain, with their specific architecture, with their specific documentation practices.
psyyduck@reddit
This is so true. I've been working on something very similar to a compiler, and AI has been amazing because it's easy to think of and test edge cases. I've done massive refactors (eg making the compiler stateless) without much fear because the test set is so good. If it was just "making a web page" I can't think what I would do if a junior wrote a 5000 line PR.
fucklockjaw@reddit
I guess it goes to show "experienced" != "good". It's just a sub for those that don't want to deal with the "babies first python app" kind of posts.
SeasonsGone@reddit
I’d lose my job. My company is all in on the high speed slop train
raymondQADev@reddit
The solution as with most things is that people raising PRs should always be required to review their own PRs
pro-taco@reddit
Is this one of those stories where everyone clapped at the end?
ThirdWaveCat@reddit
Being this direct can be successful in the right environment.
Sir_Edmund_Bumblebee@reddit
Is this being direct? Wouldn't being direct be talking to the people actually making the problematic PRs? This feels weirdly passive aggressive, making a show of refusing to do it in front of everyone.
_hephaestus@reddit
Yeah but I don’t think a company wide meeting is the right environment for this usually.
moduspol@reddit
I think the time to be this direct is after some demonstrable business value is achieved. For example, some security issues that got through, or worse, some that were actually exploited.
Though if that’s happened, there’s no need to “announce to the company I’m not gonna do this anymore.” Because you’ll presumably have management buy-in.
Empanatacion@reddit
And that developer? Albert Einstein.
ComputerOwl@reddit
From what I heard Einstein had pretty weak Python skills
zzzthelastuser@reddit
Einstein divided by zero and made it work!
IndependenceGold2407@reddit
Found the guy who can’t read code
lost12487@reddit
Sure is. Exposed by the fact a supposed experienced dev is taking issue with AI and not with the lack of understanding of the person submitting the PR. Not to mention they supposedly just announced they weren’t going to do part of their job at a company wide meeting without giving anyone a heads up.
Longjumping_Feed3270@reddit
... with tears in their eyes
rutoca@reddit
In the line for unemployment benefits
waloz1212@reddit
It was true, and he is Albert Einstein
qawsedrftg9@reddit
It’s true, I was the PR
crossy1686@reddit
It's one of those stories where devs start getting laid off because management have realised where the bottleneck is.
Commercial-Ask971@reddit
The bus driver
Glad-Researcher2738@reddit
Assuming this is not a fake story, this being posted in "experienced devs" sounds very inexperienced: - If a PR has issues, point that out and request changes - If a PR is too big to review, point that out, ask the author to break it down into smaller PRs, and request changes - If a PR has no problem, approve it - If a PR is buggy but the reviewer misses it, it's on the author to fix / revert it - If a PR is smalle enough to be reviewed and you as the reviewer misses the issue just because AI makes it look good, then it means you would have approved it anyway had the PR was written by another human.
You were just saying you refuse to perform your duty.
SubstantialSeesaw374@reddit
Nah it isn’t. If you send me a PR of code you haven’t read I’m sending it back to you to read it first. My time is more valuable than that.
Inevitable_Zebra_0@reddit
What makes you assume they didn't read it? Do they leave comments like "PS didn't read"?
SubstantialSeesaw374@reddit
Pure animal instinct
CaregiverMundane9712@reddit
OP is no different from the author of the PR he claims doesn’t understand the code. OP admitted to failing to catch issues shen reviewing said PR, so my take is that he’s just as oblivious as the author. In his place, I would accept this rather than point fingers at the author (who does this?) and destabilize the development team by refusing to perform day-to-day duties like reviewing a PR.
Generally speaking, If you don’t understand what any piece of code does or how it behaves, you’ll certainly fail to catch issues that stem from it. This is a skill problem, not a people problem, and certainly not an AI problem.
SansSariph@reddit
If I vibe out 5 low quality PRs in an afternoon, how much time do you give each one, and at what point do you start to feel your attention is being strained and there's an imbalance of accountability?
Is it fair or reasonable of me or the team to expect you to assess the quality of my work each time, or is the onus on me to respect your time and attention as a resource?
gajop@reddit
I early return problematic PRs in 1min but vibeslop is not such a pronounced issues. My bigger issue in inadequate testing, background, etc.
moduspol@reddit
And also:
If you disagree with all that and still don’t want to review the code, the person to talk to is your manager, not to make your own announcement to others.
Conscious_Support176@reddit
This is nonsense. AI doesn’t write code the way a human does. Yes, you could demand smaller PRs, but if the AI is being used by people who don’t understand what they are doing in the first place, do you think that’s going to solve the problem?
either-15-or-40@reddit
I think the problem is that previously you could kind of adjust your review intensity by your understanding of the person raising the PR. If there’s another dev who has done multiple big PRs but all of them have gone well without any issues, then I know I can be easy on the next PR.
f I know a dev who is likely to have certain category of issues in their PR, I would be more attentive to that category in the future PRs.
With AI code, you don’t get any consistency between PRs. So you always have to check for everything which is exhausting.
xcVosx@reddit
I think the person you're replying to is saying that's still an option and isn't impacted by the "AI slop" that posts like OP are railing against.
I know which devs on my team actually read their own prs and can explain them and the ones who just put up a pr that an agent wrote everything for without ever checking it.
The day it gets hard to tell, then we're just back to where we were before.
Reviews and senior bandwidth is and has always been the bottleneck at least in the teams I've worked on over my career.
havok_@reddit
On your last point I mostly disagree.
At least if it was written by a human you know that someone took the time to understand each line as they added it and should understand the implications of their work. And if there is an issue, they will have a deep enough understanding to be able to reason about the fix and take responsibility.
If it’s AI slop being slung over the fence and the driver didn’t understand enough to review it then op is right in not wanting to take the time to review it. It’s a waste of their time. Better to put requirements in plain text into ops backlog and op drives the ai to make the pr.
spiralenator@reddit
Python also lends itself to this problem because you can only truly validate code paths at runtime. The code may look fine but have bugs only surfaced in production. This is bad enough when you have humans writing it that understand what they are writing. Add in PRs with hundreds of lines of AI slop and, ya. Makes me want to reject them all.
arihoenig@reddit
The reason you don't want to review the code is because it looks good and plausible? I have to admit that's the first time I've heard that reason for refusing to review.
AlternativeSwimmer89@reddit
I was impressed by this post up until the edit. What I also run into is sheer volume of PRs produced with AI even if the authors claim to understand it. So much respect for standing up and I don't think you should draw a line in understanding or not...I believe if you don't write it from scratch youre pretending to understand it. Hell even if you do write it from scratch there are times you don't understand why it worked, but at least you're aware about that you don't understand it.
maverickzero_@reddit
When you're reviewing PRs that the creator doesn't understand, you're closer to a second-pass developer than an actual reviewer. It's not like they could even take feedback if they wanted to because they'd have no idea what you're talking about.
SuccotashBig5350@reddit
I don't either, I just say I do.
Specialist_Golf8133@reddit
the syntactically correct but structurally wrong failure mode is exactly the dangerous one. it passes CI and a casual read, and the happy path wont catch it either. the breakage only shows up when someone calls the function with input the generator didnt imagine. ive seen the same pattern in ML pipeline code: model inference works on the eval set, ships to prod, then fails on a document type that wasnt acually in the test distribution. the generator has no mental model of the system's contracts, so it can't know what it's violating. the review burden for that class of bug is higher than reviewing code written by someone who understands the codebase, not lower.
subma-fuckin-rine@reddit
Yep I've seen ton of them where it builds and all tests pass but soon as it's started in the real environment it fails. Sometimes even fails to start lol meaning no one actually tested it before merging
hobbycollector@reddit
I've had this problem with one of the senior developers. He is good at certain things, but he doesn't understand the large code base I mostly wrote, and yet continues to push PRs to it that violate basic external requirements. He doesn't understand those PRs, and will accept failed tests by altering the tests. "Hey, at least it's fast".
LaloSalamancaXD@reddit
AI please write code like human -> enter
ImPapaNoff@reddit
I'm embarrassed to be a part of this community these days. The amount of supposedly intelligent people shutting off their brains and raging against a tool as if that tool has no positives is actually insane.
lenswipe@reddit
How do people get these jobs where they can lay the law down and go "I'm not doing that" and management just accept it? 😆
endless_shrimp@reddit
the problem isn't AI pr's, the problem is that you have another team trying to do your team's work. tell them to stick to their own stuff.
Perfect-Campaign9551@reddit
I think you are dumb. If those people submitted PRs without AI you'd have just as hard a time understanding it.
The problem is your ability to read code and they it takes longer, not that inexperience people are submitting PRs
ub3rh4x0rz@reddit
The primary reviewer of AI generated code has to be the person signing the commits. Anyone in the habit of throwing shit over the fence to the reviewer should be fired. PR review should focus on architecture and following correct change management practices, not tedious line by line review of the entire change set.
r240825@reddit
You did well. At my company, I constantly see PRs with bloated, irrelevant comments. It’s a huge no for me. I don’t care if code is human or AI written, but bloated, unnecessary fluff is where I draw the line
ButchDeanCA@reddit
So refreshing to see someone take a stance. Great job, OP!
ryan_the_leach@reddit
No one should be accepting PR's that aren't thoroughgoingly reviewed / tested from anyone.
I've seen workplaces collapse, because of LGTM reviewing, and metrics where management were only caring about the amount of tickets closed.
If you haven't
run the code.
played around with it in an editor exploring.
reviewed (or written) tests against it.
Then you haven't reviewed it, you've 'glanced' at it.
AI code is no exception to this, and external contributors (even within the same company) should also be looked at under the same lens, or coached to become internal contributors to the project.
If the amount of PR's is too high, that you can't reliably review them (reviewing is often harder then writing small fixes yourself) then low-priority merges should be de-prioritised on those grounds, and explicitly stated.
Goes for open source just as much as closed source, if not more so, as without a relationship with the contributor, you have little idea of their skillset.
AI just muddies this more.
SimplyJow@reddit
If submitters don't give a damn about their PR's why would the reviewer? The solutions is exactly what you proposed and/or review it with AI too.
ThePsychopaths@reddit
The problem isn't with pr being AI generated. The issue should be I am not reviewing your code if you don't understand it. First understand it and then raise it. AI generated PR should be fine as long as the developer knows what he is doing and keeping the agent in check. It should be just for minimizing the efforts.
ThomasRedstone@reddit
Yeah, it's the big danger of AI code, most of our shortcuts to identify bad code are missing, it looks right, a bad coder wouldn't write it, but it needs careful review by the person who created it and another person, PR review is not for this!
People from similar areas who do understand the problems they're working on can still get great results, like a C# backend engineer, they're likely to be able to produce decent solutions in Node or Ruby, but if it's something totally different, like a DBA or a Data Scientist then that's likely too big of a difference in specialisation.
xaervagon@reddit
I could never submit a PR where I didn't know what I was writing. I've had hardass bosses challenge me on some obnoxious code I had to write because they wouldn't change other parts of the system and either had to approve or make the other changes. When I worked long term on a codebase, the biggest obstacle became myself because I would come back to it and find my own name on it. I realized that if I don't understand my code, nobody else will and people and things will just try to work under, around, and over it.
fake-software-eng@reddit
Just get AI to review them on your behalf. Fight fire with wife.
greenhouse421@reddit
I phrase this slightly differently. I don't care how you generate the pr but you are the one signing off on it being reviw ready. Not the tool you used.. If it isn't / you can't / you haven't that is on you to fix not on me to compensate for/take on responsibility for. And I will call you on it. And you will have to compensate for the flag against you/your PRs that means I won't be reviewing your low quality/effort PRs until you justify removal of said flag.
Zulban@reddit
I recommend a bit more nuance. I wrote this which you may find useful: Why I'm declining your AI generated MR
Plenty_Line2696@reddit
We've adopted a system where for anything but the smallest PR's the submitter has to have a short call with the reviewer to walk them through the code and explain why they did what they did.
This was done precisely because of AI spaghettislop making it to production, and I actually like the process aside from that because it's nice to get a high level overview ahead of time.
kruvii@reddit
The prophecy has been fulfilled!
Normal_Run_6601@reddit
I have raised a few PR with AI assisted code myself. Lots of time AI reasoning were buried and hard to trace. Would a more transparent reasoning tracking or explicit policy or guideline for AI help? Curious to hear your thought
siegevjorn@reddit
All AI slop PR should be sent back without further explanation than:
"low (human) effort"
Which have been applied to the SWE field from the beginning.
forbiddenknowledg3@reddit
Review your own code before sharing with the team. Now with AI, review it 5x before sharing with the team.
djnattyp@reddit
What's the point of all the "LOL AI is inevitable. Boss will delete ur job LOL" posts? Just slopaganda bots and shills?
luckypanda95@reddit
yea, i feel you. my company trying to be cheap and hired a bunch of interns who use AI to work on the tasks. it was a nightmare, they don't even bother running the app to see if its working
kincaidDev@reddit
Were you trying to get on the layoff list?
precariousopsec@reddit
Management getting your severance package ready.
ericatclozyx@reddit
Jokes on you, those PR's are going to get merged without review now.
bart007345@reddit
You should take some time to document the issues and feed it back into AI code reviews.
Kazumz@reddit
Bad approach, too emotive and opinionated.
You should require anyone that wants a review to provide you with a walkthrough of the code and functionality instead - we all used to do this pre-2020 anyway.
That way you push organic understanding even if it was written by AI, and satisfies your requirement too.
Affectionate-Mail612@reddit
which will be AI generated too
Kazumz@reddit
I’d be impressed if someone AI generated themselves on a Zoom call and had me convinced 👏
RedditIsBadButActive@reddit
Heroic, I bet you had a lot of sex afterwards.
veber1988@reddit
Hmmmm. My companies colleagues even don't create prs!
mylanoo@reddit
Making PR should take more energy than reviewing it generally.
TheKaleKing@reddit
I work in a big company and we're moving towards AI and pretty much everyone uses AI to write code. Not meaning that they don't understand it but yeah if I'd say: "I don't want to review AI code" then I'd lose my job most likely.
Code is code at the end of the day AI written or not. People are still responsible for a PR that they send out but being totally against reviewing AI code might not be the move.
dead-first@reddit
Let's be honest here for a second... Next year we aren't going to be writing code and AI will be reviewing AI code changes. You will be laid off with the I wanna code attitude. Nobody write code anymore get used to it or get laid off
kamilc86@reddit
Data scientist here. What you're describing is data scientists shipping frontend PRs to a stack they don't own and can't maintain. That predates AI by years, Claude just scaled the volume. The right fix is making the team that ships the code own the code, however it was written.
ikk_ah@reddit
Are you sure it went well?
'Leaders' don't like people opposing their mandates and ideas. They might say: "oh cool, yeah, you're right" in public, but they can easily start a private conversation to retaliate or started process of finding a dirt against you
anish714@reddit
A better solution would be requiring every request to include a summary of changes.
colcatsup@reddit
Require tests. If you can understand the tests, and they work, and don’t cause regressions, maybe that’s a middle ground? Generally I support your stance. In other orgs where there might be pushback, the test route might be the compromise. Sr reviewer needs to validate tests at minimum. B
martabakTelor6250@reddit
in my opinion, AI generated code that we don't understand is a normal thing. Our knowledge is limited. If it is working and useful (for personal use), we most probably don't need to dig deep everything it has generated. But once it got into PR, then the developer who submitted the PR must own it (implying also to understand it)
Double_Try1322@reddit
The real issue isn’t AI-generated code, it’s AI-generated code nobody truly owns or understands. Review breaks down when the reviewer becomes the only person reasoning about the system.
Evgenii42@reddit (OP)
This is so well put.
pwab@reddit
I’m curious OP; what is the purpose of “review” in your org? I come from a tradition where review is mostly about knowledge sharing and collaboration.
Evgenii42@reddit (OP)
Yes, same purpose, plus of course having a second pair of eyes to improve code quality.
coldfeetbot@reddit
I now use AI to review PRs as well, not entirely but as an assistant, to level the playing field. And managers should acknowledge that using generative AI means higher speed, but at the expense of having less knowledge of what's happening under the hood in the code
BoundInvariance@reddit
Falling behind the times I see
muralikbk@reddit
I put limits on the PRs themselves rather than the source- say max 1500 lines, no redundancy, and single purpose. If the PR goes bigger- break them up into smaller pieces that are easier to review.
I have an extreme adversarial review skill as a backup for repeat offenders.
ivancea@reddit
Good. Reviewing a PR generated from an untrained entity (whether a person or an improperly guided AI) is basically doing it from scratch.
That said, I wouldn't mind having autogenerated code on a codebase with a high level of testing, and with agents trained on it (as in, trained in previous commented, potential and typical flaws, and so on)
tango650@reddit
Lol, how did that you end up having randos pushing code to you in the first place.
Shazvox@reddit
I get your point, but you absolutely went at it the wrong way. People can use whatever tool they like, but they have to be able to defend and explain their own PR:s.
PurplePlenty4980@reddit
Set a simple rule: whoever submits the PR has to walk through the changes line by line during review. If they can't explain what each piece does and why, then gets rejected.
EnderMB@reddit
As of right now, PR's are raised by a person, not AI.
As such, whether it was written by Claude, xAI, or their dog is largely irrelevant. It is their name against it, and they are ultimately responsible for it. They should be able to answer questions about it, they should fix it, and they should be judged if on average it takes 4-5 revisions to get something passable. That's how you'd learn as a junior, and it's how they'll learn to not trust AI.
It's fine to say that you don't want to review it, but it's not going to detract people from using it. The only way you can do this is essentially through them acknowledging that it takes forever to make a change of sufficient quality via AI, but less time from someone that knows what they're doing.
2cars1rik@reddit
See you in the unemployment line brother
ShazaBongo@reddit
They send PRs they don't understand. Oh boy, do they know what a test is? This sounds like criminal behaviour. In some engineering fields this kinda work would result in revoking your licence, huge financial penalties and in some cases put you to jail.
It's sickening what's going on in the software "engineering" industry.
Evgenii42@reddit (OP)
Yes and we have power to push back. It's all in our hands.
gondalez@reddit
That took guts. Nice one! Glad to hear leadership took it on board. I think the more awareness around the issue, the better.
People pushing code they don't understand has always been a thing right? Only, AI makes it a lot easier.
Evgenii42@reddit (OP)
Thanks yes we have good people in the company luckily. Yes I won't claim that all code I've written myself I understood completely.
Saki-Sun@reddit
Here I am looking at the vibe code I've worked on for two weeks without touching a keyboard. It's better than 95% of the PRs that come across my desk.
I mean I get it, but damn the world is changing.
ProgrammerNo3423@reddit
I'm senior enough in the company to be one of the people deciding policy on this and my stance is smaller PRs, stricter AI instructions, more stringent policy of local testing, and obviously devs owning the code. The how you got the code is irrelevant. We should be having those policy whether it was generated by AI or not (except the "AI instructions" part obviously lol).
But yea, weird hill to die on bro.
whimsical_alligator@reddit
The real issue is people shipping code they can't explain, not the tool they used to write it, that's a code review problem that existed way before AI.
fmgiii@reddit
I wouldn't feel too comfortable in your position. I don't think it's going to last. I maintain a better strategy is to use ai to help scan the changes and push back on the ones who are submitting the changes, whether they are using using ai to make them, or not. It doesn't matter if the changes are made with ai or not anymore. It's the new reality, like it or not.
You will achieve the objective you are going for and, more importantly, you will be able to sustain it, if you use ai to assist in your code reviews. If you find yourself with a big pile of crap slung code to wade through. So be it. A well guided (meaning by you) agent can point out the pitfalls of crap slung code, quickly, easily, and thoroughly.
In a word: fight fire with fire.
The notion that you will be able to slink back down into a position of quasi 'nostalgia', an environment where people 'understanding what they write' etc, this is forever gone now and really it never existed in the first place. In the past, if devs didn't know how to do something, they simply couldn't submit as much code.
AI has changed that. They can now submit a ton of code. Fundamentally however, this has only changed the playing field slightly. Some of that code 'may' work whereas before, it just wouldn't be submitted. AI may be able to glue some things together for them now as well. Okay so be it. It's the new reality.
If you to survive now by attempting to be a 'you don't understand what you have written ' purist, you are just not going to make it. The win you described in your OP will be short lived at best. Trust me, I wish it were different, but Pandora is out of the box and here we are now.
Arm yourself with a copy of Claude and start your reviews out now by having it point out the pitfalls and ramifications of all the changes submitted in your PR branch. This is your new weapon. Your attitude should be, well I see you didn't put any time or consideration into this code. So I will use the same tools you did to push back. Honestly you may find yourself really starting to enjoy being able to push back in this way. You can do it intelligently, beneficially, and achieve the goal of communicating to the author that they did not understand what they submitted, and have enough energy left over so you don't feel like you're the victim of this new reality we now find ourselves in.
Indeed you will find that some ai generated code will get through your reviews. That's okay. But remarkably you will find, quite easily and effortlessly, that a sizable amount will not. So I use this phrase often now:
Everything has changed, but nothing has changed.
Get back on your horse. Mount up with your own set of ai approaches, and most importantly, your hard earned ability to guide them to and push back intelligently. And then, push back hard. By doing this, you will set yourself up to be able to navigate and thrive in this new reality.
Ozymandias0023@reddit
Glad to hear it went well. The "even our PMs are submitting PRs now!" management crowd would have their feelings hurt but it sounds like you work with people who haven't entirely lost their minds
jasie3k@reddit
My solution is that code reviews nowadays have to be done during the call, you as a person raising the pr need to explain it in full and you are on the hook for every line/function changed, you need to be able to explain it like it was written by you.
Sure, it can become a bottleneck, but it promotes accountability for the changes AI made. I myself review the code like the raiser made the changes personally - if you can't explain why something is being done without saying "lol Claude did it this way" then it is a rejection.
Lothy_@reddit
It has been challenging dealing with some of the MicroSlop. Glad you’ve received broad support for your stance, and hopefully it’s earnest support.
Traqzer@reddit
This has nothing to do with AI and more to do with people unfamiliar with the code base raising PRs that they don’t understand
AI just makes it easier for this to happen
ficuswhisperer@reddit
Just use AI to review it. They can use AI tools to address the AI reviewer comments. Repeat this loop until everybody has consensus.
This is the new AI circle jerk that I’ve been experiencing first hand.
PartyParrotGames@reddit
> because the AI generated code looks good and plausible, so it will lead to bugs and security issues.
Ok, but human written code with bugs also generally looks good and plausible. I get not wanting to do your job, but your argument here isn't very strong. Its the core requirement of code review to find hard to identify issues in plausible looking code. A better argument is the amount of code you have to review is drastically increased making it harder to get through, not just that it looks plausible but *could* have bugs, you can say that about most code with bugs submitted by competent humans as well.
Conscious_Support176@reddit
There’s maybe a better way of putting it, but is it not pretty obvious that AI used by someone who has no idea what they are doing will mimic standard forms, whereas a person who has no idea what they are doing will reveal their misunderstandings in what they write by hand?
Manual review of ai generated code in that context seems pretty idiotic, surely you need to ramp up test coverage instead?
CraZy_TiGreX@reddit
Just for a basic sanity check build an agent that can do decent reviews.
That will give you kudos in the company for sure, and it's a cool thing to do
RecaptchaNotWorking@reddit
raising pr that they dont understand is dummbp as frok. they should get fired.
UnderstandingDry1256@reddit
This is not sustainable - you just positioned yourself like "I don't not know how to deal with AI" in leaderships' eyes.
Write manually, enjoy, be replaced by someone who know how to deal with it.
I dont understand why developers like the "old way" to do things instead of adopting the new technology.
PRs can be reviewed with high confidence by AI tooling actually. What should be solved is quality and safety criteria.
Also, defining the framework for python data folks would help them genereate more structured and safer code. Skills, rules, all the stuff you're trying to avoid.
Realichu@reddit
All the Claude agents in the comments coming to big AIs defense lmao.
Good job OP. Nice that some folks in this industry have integrity still!
Ok_Tax4407@reddit
Just use ai to review /s
kzr_pzr@reddit
When you write code with AI you should also review code with AI and review just the outcome. Just like we don't review the assembly GCC outputs when it complies our code.
Ok_Slide4905@reddit
And then everyone stood up and clapped.
9sha@reddit
Did you help the data science guy get his changes in?
Evgenii42@reddit (OP)
My manager suggested to close the PR. We agreed that if data scientist want to make changes to the web service they we need to ask me to write the code.
BarberMajor6778@reddit
Didn't you see a PR coming from other dev which looked plausible but sneaked multiple bugs and security issues? It's quite common
bystanderInnen@reddit
Time is ticking tho
Bicykwow@reddit
I said that at my company. They just stop asking engineers to review code, and started merging it directly to main. The CEO then said it "was the right way to build software" at an all hands.
Odd_Perspective3019@reddit
the best is when PMs write code change in tickets and say it’s simple when they have no clue all the interfaces it touches
Artistic_Respect_450@reddit
I feel like you only shifted the problem elsewhere. Now those data scientists will either submit the same AI code through someone else or leadership will assign another reviewer.
sarhoshamiral@reddit
I find this hard to believe but it is also a short sighted view to take anyway.
Coding agents are here to stay, so we may as well see how they could best be utilized. If the concern is regression, make sure your CI pipeline has enough tests, if concern is style use linters etc to enforce it.
If there is specific patterns etc use a code review agent for the first level review and so on.
FxAnd@reddit
let AI review AI problem "solved" /s
CrouchingJaguar@reddit
I mean, I hate reviewing AI generated code too, but usually it is still authored by someone with speciality experience related to their code changes, so I have confidence they at least understand the changes.
What you are describing does sound a lot more frustrating, honestly valid.
ktmd-life@reddit
As a reviewer, you always have a right to get them to explain their PR to you in a call. If they can’t do that, the PR will not get approved.
It’s been that way before vibe coding was a thing. Maybe people rubber stamping PRs is the real issue here.
CrouchingJaguar@reddit
What? That’s not at all what I said, lol.
watscracking@reddit
Just use AI to do the code review, now you don't have to do the reviews
Unfair_Long_54@reddit
A ginius did this around 1 month ago, Claude praised code quality and said its according to the implementation plan and very well implemented. Long story short, its around 1 month we are fixing production problems.
vitek6@reddit
So ai code looks good and that’s why you are not reviewing it…
arjjov@reddit
Review as usual but say you can only accept if they will be maintaining it in prod. Now when shit's on fire causing impact on prod they'll learn.
pseudo_babbler@reddit
That's what I did, our support roster was optional and I said oh yeah awesome super interested in the experiment to build a new web app with a team of non devs and AI. It's going to be really interesting also btw I'm taking myself off the support roster. Oh why is that? My boss asked. Oh just a change of personal circumstances, I said.
Still didn't avoid the "hey it would be great if you could help the team to overcome some blockers in our environment that are preventing them from deploying." Aka they have NFI how to put an app on to any type of server system we have.
CadeOCarimbo@reddit
This didn't happen at all
Spare_Dependent6893@reddit
good move but probably it will not completely prevent the review code made by AI and it will not prevent ai generated code as it is the direction we collectively have taken. But at least it may force everyone to understand the produced code and by able to maintain it. So the question is how to keep improving productivity with ai and having developers completely autonomous on this code for evolution, maintenance, test as they were before ai ?
ToughStreet8351@reddit
This is how you end first in the list of people to fire when time comes
OuiOuiKiwi@reddit
We look forward to your job search threads in the future.
TheAllKnowing1@reddit
Please drop your company name so people here can apply for their upcoming software engineer opening 🙏
vinny_twoshoes@reddit
hell yeah
Tight-Requirement-15@reddit
Weird hill to die on. Hope youve signed an offer elsewhere
410_clientGone@reddit
Speed running unemployment. Play stupid games, win homelessness
vibes000111@reddit
So you just asked people to hide the fact that that they use AI from you.
A better solution is to put code constraints on what a PR should look like. Or in your specific case, you can put an organisational constraint and tell the data scientists that it’s not their job to touch the web code.
throwaway_0x90@reddit
lol RIP
sfscsdsf@reddit
surprised you can push back, management must know tokens have been getting expensive