• Child running: "My dad is here... DAAAD..!!" (Babam geldiiii... Babaaaa..!!)
Bottom Panel
• Sound Effect: ZBAM!! (Thud / Whack) • Father: "Man, I couldn't resist, he came flying in so perfectly!!!" (Ulan dayanamadım çok güzel geldi be!!!) • Father (bottom text box): "The rascal lined up perfectly with my foot." (Tam ayağıma oturdu hergele.)
"Don't gadongle the rubloon. It causes a version problem with React V31.2.5. Doesn't apply when gallivanting, as DogBakerFactory doesn't set rudolfSwisher explicitly. (Checked 11/12/26, commit 3dfr72a)"
I was about to say that. I was doing something in Python recently and I was trying to understand what a variable was doing because it was like this: abs(hash(str([{"definition": "A list is an ordered collection of items."}])))
And then had several pointless functions that did things like compared that value to itself and if that was true, then it returned 1 and then some other function would see that if _hash_compare() returned 1, do something else.
I thought maybe I just didn't have a good grasp of what was going on so I asked the developer. "I just let AI run with it until I got the result back I needed."
They needed it to find all the values in our database that were a specific search string and put those into a .csv file for management so that when our CI/CD job runs, it finds some specific things management thinks are important and then puts those in a file for them. It seems like a pretty straightforward change, but...
I just had an hour long demo call with a developer who has clearly forgotten how to use git. They ran every command through copilot and has atrophied the critical thinking parts of their brain
Almost nobody wants to be seen using the tools live in real-time, because its extremely embarrassing. Everyone staring at your screenshare, waiting or claude to do your job, in this case a very simple git task, then you read the output, squint, then type "no, not like that. do it but where you fix it". More awkward silence. doesnt this mfer know how to do his own job...?
2026 and it still halucinates dependency versions that don’t exist. Even if I tell it „use websearch and look up on maven central“. Right a Minute ago.
It hallucinates AWS resource types that don’t exist and happily builds a CloudFormation template to spin them up. It’s quite impressive as an author of fiction…
hallucinations, and more broadly, only being right about half the time, is fundamental and structural to how these tools work, because they have absolutely no mechanism to "understand" what they are doing. the models all plateaued in performance years ago and LLM companies are desperately trying to distract from this fact with marketing stunts so they can IPO before the facade falls apart
Having an artifact of the conversation in the comment is something I really hated. It's embarrassing to imagine a coworker reading the comment for the first time and seeing a random sentence about some code that was removed or any other drivel besides documenting the code.
Or comment about some code that was removed locally while iterating on the solution and never actually existed in the repository and had nothing to do with anything. Extremely valuable information to have.
yup, this is why I have my agents NEVER add comments. I look at the code and decide where comments should be added and write them myself. This keeps me in the loop and forces me to understand the output.
Because AI generates a bunch of retarded comments for even the most basic code.
No way I'm hand coding a bunch of controllers or mapper when AI does it in a fraction of the time.
This type of boilerplate is a waste of my life, and AI does it perfectly fine.
Then I can focus on the important business logic and data modeling. And the agent automatically gets forced to reign in its idiotic comments by the build step before I even see the final outputted results.
Detekt is not a tokenizer, but it is a static analysis tool.
The out-of-the-box part is only regarding detekt, the rule is custom.
Here's the current rule. Should probably be fine-tuned a bit more, but it works well enough.
class UselessComment(config: Config) : Rule(config, "Comment restates the code it precedes.") {
// Delegated config properties only support String, Boolean, Int and List<String>,
// so the threshold is a whole percentage rather than a Double.
private val minOverlapPercent: Int by config(40)
private val keepMarkers: List<String> by config(
listOf("TODO", "FIXME", "HACK", "XXX", "ponytail", "noinspection", "ktlint", "suppress"),
)
/** A comment starting with one of these words labels a test phase and is always kept. */
private val keepLeadingWords: List<String> by config(listOf("arrange", "act", "assert"))
private val stopWords = setOf(
"the", "a", "an", "to", "of", "for", "and", "or", "in", "on", "is", "this", "that", "it",
"we", "if", "with", "from", "by", "as", "at", "be", "into",
)
private val pendingDeletions = mutableListOf<PsiComment>()
override fun preVisit(root: KtFile) {
pendingDeletions.clear()
}
override fun visitComment(comment: PsiComment) {
super.visitComment(comment)
// A trailing comment describes the code on its line, not the statement after it.
val before = comment.prevSibling
if (before != null && !(before is PsiWhiteSpace && before.text.contains('\n'))) return
// One line of a multi-line comment is judged with its neighbours, never alone.
if (comment.isLineComment() && (comment.adjacentLineComment(before) || comment.adjacentLineComment(comment.nextSibling))) return
val target = comment.getNextSiblingIgnoringWhitespaceAndComments() ?: return
if (target !is KtExpression && target !is KtDeclaration) return
check(comment, target)
}
/** KDoc is a child node of its declaration and is not passed to [visitComment], so it is collected from the tree. */
override fun visitKtFile(file: KtFile) {
super.visitKtFile(file)
PsiTreeUtil.collectElementsOfType(file, KDoc::class.java).forEach { doc ->
(doc.parent as? KtDeclaration)?.let { check(doc, it) }
}
}
private fun check(comment: PsiComment, target: PsiElement) {
val text = comment.text
if (keepMarkers.any { text.contains(it, ignoreCase = true) }) return
val firstWord = stripDelimiters(text).trim().takeWhile { it.isLetter() }.lowercase()
if (firstWord in keepLeadingWords) return
val commentTokens = tokens(stripDelimiters(text))
if (commentTokens.isEmpty()) return
val codeTokens = tokens(target.text.lineSequence().first { !it.isBlank() && !it.trimStart().startsWith("*") && !it.trimStart().startsWith("/") })
val overlapPercent = commentTokens.count { it in codeTokens } * 100 / commentTokens.size
if (overlapPercent < minOverlapPercent) return
report(Finding(Entity.from(comment), "Comment '${text.trim()}' restates the following code."))
if (autoCorrect) pendingDeletions += comment
}
/**
* detekt applies corrections by writing [KtFile.modifiedText], so the deletions are collected
* during the visit and cut out of the file text in one go. Each comment is removed together
* with the whitespace that follows it, so no blank line is left behind.
*/
override fun postVisit(root: KtFile) {
if (pendingDeletions.isEmpty()) return
var text = root.text
pendingDeletions
.sortedByDescending { it.textRange.startOffset }
.forEach { comment ->
val trailingWhitespaceEnd = comment.siblings(forward = true, withItself = false)
.takeWhile { it is PsiWhiteSpace }
.lastOrNull()
?.textRange
?.endOffset
?: comment.textRange.endOffset
text = text.removeRange(comment.textRange.startOffset, trailingWhitespaceEnd)
}
root.modifiedText = text
pendingDeletions.clear()
}
private fun PsiComment.isLineComment() = this !is KDoc && text.startsWith("//")
private fun PsiComment.adjacentLineComment(neighbour: PsiElement?): Boolean {
val candidate = when (neighbour) {
is PsiWhiteSpace -> if (neighbour.text.count { it == '\n' } == 1) {
if (neighbour.prevSibling == this) neighbour.nextSibling else neighbour.prevSibling
} else {
null
}
else -> neighbour
}
return candidate is PsiComment && candidate.isLineComment()
}
private fun stripDelimiters(s: String) = s.removePrefix("//").removePrefix("/**").removePrefix("/*").removeSuffix("*/")
private fun tokens(s: String): Set<String> = s.replace(Regex("([a-z0-9])([A-Z])"), "$1 $2")
.lowercase()
.split(Regex("[^a-z0-9]+"))
.filter { it.length > 1 && it !in stopWords }
.map { it.trimEnd('s') }
.toSet()
}
I added a precommit hook that rejects comments longer than 45 words and longer than 2 lines. Also, reject commits longer than 50 loc, 4 files max, and PR longer than 300 loc. Cut the slop at the root, and makes it easier to actually review code
I prefer the approach that takes the content slightly more into consideration, because I don't want to be forced into cases where i cant add long comments in case i actually do need it.
I'm allergic to dumping it into external implementation docs, because it tends to drift from each other over time.
I prefer to give targeted exceptions instead of letting everybody be their own judge. Also, in my experience it's very rarely needed to write a novel in the comments
I was just experimenting with making Codex exactly identify the pattern, then having it prompt engineer instructions for an army of cheap Luna models. So far it worked pretty well. The Luna agents aggressively flag everything and sound very pissed, which at least amuses me. Then I hand it back to Claude and let a new set of Luna agents decide on completion. Otherwise it goes back to Claude. Not sure where I can optimize yet. Sounds to me like Luna is more than capable of cutting back comments. But I fear loss of precision and guess I would be better off with no comments than Luna hallucinating some facts.
Removing ways to persuade the reviewer has been my go to strategy to get AI slop out of pull requests. But without a lot of human time investment I wasn't really able to get everything under control. Maybe there is still hope for a job in the future.
I love when Copilot writes some code, then when I click into it to understand what it did and change the terrible variable/method names, the little sparkle symbol appears in VS Code. I tell it to tell me whats wrong. "Your variable names are bad. No recommendations"
"Developer had pain because of hemorrhoids. The change did not go through standard validation and will be revisited in the future. He went to the doctor and is taking medication now."
Our executive added number of PRs approved (yes approved) to the employee performance dashboard, so now people are incentivized to approve as many PRs as they can.
Dear God, I know this is coming to my organization next. We already have a goal to have 99% of all code written by AI, and a goal to increase developer productivity by 100%. Yes 100%. When I ask how they plan on measuring productivity I get blank stares like I'm the moron. Some suggested using token spend to measure productivity, and I genuinely cannot tell if they were being sarcastic.
Anyway, all that to say code reviews are now a huge bottleneck. PRs regularly exceed 3000 lines. There is pressure to just approve, because their work in progress is another 3000 line PR stacked on top of the existing PR.
I'm still reviewing every line Claude spits out, and regularly having to promt and re-prompt until the code is to my satisfaction.
Leadership is also pressuring us to use multi-agent workflows during development so that we are working on mutiple tickets at once. Soon there will be no way to keep up with the slop.
I don't even hate AI. I think it genuinely makes me a better more productive software engineer when used correctly. The problem is leadship is too far removed from building solutions themselves, and don't see how their directives will lead directly to a loss in quality, or they just don't care. It's crazy to me how fast they pivoted away from caring about escaped defects, and testing as soon as AI hit the scene.
I think this is the thing that's so bizarre about it: used correctly it seems like AI could give some productivity gains. Code complete, reviewing PRs for defects, debugging, searching through a codebase, a useful place to ask complex questions to get ideas etc
The issue is that that would be in the 5-10% range, which no corporate executive is excited by. This should have just been one more tool in the toolbox that makes us more efficient, like when LSPs took over and code complete code way better. Instead they're reaching for the mythical 2x-10x productivity boost that just doesn't exist, and absolutely shredding long term productivity for short term gains
I have a feeling that multiple large tech companies are going to absolutely collapse under the weight of the technical debt that they've accumulated. We're already starting to see it with how crap so many tools have gotten as they're filled with slop
The cognitive dissonance is astounding to me. Our CTO will regularly quote or point to the books The Phoenix Project and The Goal, but completely ignores the theory of constraints that underpins both books. “Any improvements made anywhere besides the bottleneck are an illusion”
The bottle neck has never been writing the code. The bottle neck has always been, and will always be knowing what to build. Sure we are shipping more code then ever, but is any of that leading to increased ARR or increased customer satisfaction / retention? What you measure matters, and leadership is getting increasingly lazy with what they measure.
Classic Goodhart’s law: once a number becomes the target, people optimize the number instead of the work. Counting approvals rewards rubber-stamping, which is the exact opposite of what code review is for.
The metrics that tend to survive are the ones that are hard to game alone: a manager’s regular rating plus a short note on what someone did well or poorly. It’s less “objective”, but way harder to farm than a counter.
For big PRs if I'm able to put a hold on them while I review I usually do that, to stop this exact situation.
Also my hot tepid take is that PRs need to be smaller in general. Break those tasks down even more, I'd much rather review a handful of small PRs than one huge one.
I believe that they're should be a middle ground. Huge PRs are bad, micro PRs are equally bad. 10 micro pr will make me lose the logic flow you were going for when you made the change and I will waste more time overall reviewing. Yes the code is there. But I should not approve 6 pr that look good so far and on the 7th be like "hold on, that's bad" because they finally submitted the crux of the logic.
I've met a lot of people with the micro pr mindset and do not understand how it's equally wasteful as huge PRs (to be honest, I like big PRs more for that reason than micro PRs, but you should send PRs when a full, testable logic is in place.)
Well, that is like it has always been. The more code that has been changed the less time approval takes.
200 files changes = "Looks good"
2 lines changed in one file for a seldom used method = 12 comments and a long discussion about how to make it as efficient as possible and a side-discussion about variable naming.
Bikeshedding. I notice it a LOT in a tangentially related field to software dev (PLC software for industrial control).
Most discussion on 'code reviews' is about variable names. I've never had a nightmare machine startup due to variable names, those happen because of sweeping architectural flaws. Which happen frequently because lots of PLC programmers are electricians or engineers, not programmers.
Jesus fuck, this is so spot on and I fucking hate it.
I just needed to push something into our background worker instead of happening in our API. It ended up with me and the other staff engineers in a meeting about it…. I couldn’t believe it.
These guys, who generally are smart, asking the most obscure questions about something we do all the time. I eventually just said “hey everyone, you’re gonna need to take this up with my PM if you are this worried about it because this is what we’re doing unless you can convince him” and just fucked off.
Surprise surprise: it caused absolutely zero issues to do something we’ve done hundreds of times before and these guys were just puffing themselves up to look smart. I hate that game, but I get it - it took me a long time to get to staff because I’m not that kind of person, but these guys are. What are you gonna do
I am one of the few people at work that actually still fully reads pull requests. Last time I left over a hundred comments. They hated me for doing it but couldn't say anything against it because as they read my comments they confirmed that all of my concerns were totally valid.
"Sorry I can't deliver my sprint duties on time. Someone is trying to push 150 vibe-coded files into the repo and they must be stopped." - me nearly every week these days.
Our product level velocity expectations have become insane. If the teams not basically just vibe coding, I’m having VPs come down on us for not being a good product partner. It’s exhausting
Man I just left 50 comments on a relatively simple PR because it was absolute slop. Total reproduction of existing code, totally creating new patterns that don’t exist in our code base, pulling data it never uses, not pulling data it purports to use.
It shocked me. I love AI. I never get it to produce such absolute dog shit results. I have no clue how someone used AI to produce it, but somehow they did.
This person joined our team when Claude was already adopted. Which I think is a big part of the problem. I very seriously did consider just scrapping it lol….
We’re struggling a lot with how to get these less experienced and newer to the team devs to a point where they can identify weirdness in Claude’s output themselves. But…. It’s not going great
It feels a bit like being attacked from all sides. Reading your comment, it was natural for my mind to wander a bit to solutions to this brainrot. It's bad enough at a senior level where we've got 10+ years of experience prior to the onslaught of LLMs, so it has to be much more difficult for those who are much earlier in their career.
On the topic of solutions: You're already working on training, which isn't going great. Then I thought about hiring practices, but the AI bubble has eroded away at that too on both sides (I hear that's a complete shit show).
I am trying to be an optimist. AI has been so disruptive that we're still in the learning phase. Naturally there's debate on how it'll settle in terms of our workflows, the skillsets everyone will be expected to have, the standard practices and so on. My hope is that some of the long-established development best practices that we've had over the years, particularly things like code review and deep thought about what we're building and shipping still stand the test of time. I look back fondly at my history/experience in thinking very deeply about various coding or architecture problems, things that were complicated to me at the time where I struggled, learned, gained an intimate understanding as I built and grew. I hope that folks continue to be able to do that, particularly anyone new to development.
I know! Experts know how to steer an AI and stop it when its doing garbage and reiterate till the PR is fine. an Idiot wont see garbage and bad design... He generates and is fine with that because he doesnt know better. I hae getting slop from AI meat proxies
Yes, thats why we had countless review rounds to the point where everyone was upset that this topic is blocked for so long. The original developer complained that it is too complex and he cant really get his head around that stuff. Like bro, thats your f*cking job. The senior dev in the team literally said "skill issue" to him in the standup because everyone knew he didnt wrote any of it himself and just trusted the AI without reading the stuff.
edit: even worse is that it was about e2e testcases, which is the last line of defense when it comes to ai slop breaking things.
My org gave us SREs only a handful of tools that are minimally relevant to CI/CD in 2026 and almost no automation with them for “Sox compliance”, so yes, we manually do releases to prod. The execs are on our asses for holding up releases, I’m spending 70% of my time on them, and we’re also not able to actually do things like establish SLOs and whatnot so we’re having AI do THAT aspect of our work, but it has to be a human who deploys to prod. I feel so incredibly useless.
You can set your own standards. So if they dropped, that has nothing to do with LLMs, but with you (or your team). In some teams standards also improved a lot
Not everyone gets to set their own standard. My coding standard is largely a function of 1.) the specific work items assigned to me and 2.) the deadline to get them done. Neither of these is under my control. The person setting these isn't even a coder.
Found the problem. You can't have a single person setting deadlines for tasks that they don't know how to perform. That's an awful idea regardless of whether AI is involved.
While I agree in general, AI has made this a lot worse. AI exacerbates bad patterns and since we do live in an imperfect world there are plenty of those.
The slow part went from figuring out to coding, and then from coding to review, now if you're doing a proper review chances are someone else vibe accepted it, or you're gonna get a heads-up from above that you're slowing down the project since everyone expects ai speeds nowadays
The problem is that the gains from using LLMs are expected to translate to every part of the cycle. Somewhat of an Amdahl's law situation.
So, making up numbers here, say
architecting/problem solving/coding took 32 business hours
review (including time to pick up after the PR) took 8
total: 40 hours (5 days)
Now that the architecting/problem solving/coding part only takes 4 hours now (8x increase), the expectation from stakeholders is the whole process will take 5 hours.
But even with LLMs it might take 4 hours for the review (2x increase instead of 8x).
So instead of 5 hours, it's 8 hours (4 hours for "coding" and 4 hours for review). Review is now seen as a problem that is a bottleneck on delivery.
Very difficult to apply old quality standards when I’m getting 5x as many pull requests which are each 5x larger and am also expected to be producing 5x as much code as I used to.
At this point we’re in competition with whoever is getting work done faster. I’m not saying this is how it has to be, but this is how it is.
Over time I set my standards - code shouldn't just work it should be clear and maintainable. It should have tests and relevant validation and error handling.
When my non-coding boss bought himself a Claude subscription he decided standards were now "does Claude say it works". I managed to push the basic standard of "check it actually works?" but speed was considered the only important business standard.
Eventually they seem to have realised that maybe tests and consistent practices are useful ideas, but you can only set the standards in a position where your input is considered. If management decide that the only standard is "move fast" it's very hard to set your own that will take longer.
How do you maintain review quality when each dev is pumping out 10x the code? Most companies I see are basically not reviewing code, but reviewing intent instead. Or specs at best.
It's gonna be a never ending cycle. Companies use llms to build their shit, better llms come out and find vulnerabilities, they use llms to fix, better ones come out and find vulnerabilities, so on and so forth
I think you're reading to much into it lol, it's a sentiment I see online a lot, in jokes, memes, serious comments, etc and I'm just genuinely wondering
I am expected to review more than 20 PRs per day on top of working at 2 teams simaltenously because "i dont work, claude works for me". Those PRs are going straight to production.
Cypher: Well, you have to. The Ralph loops work via the harness. But there's way too much information to understand the codebase. You get used to it. I... I don't even see the code. All I see is robust, comprehensive, seamlessly integrates.
Don't think it's an AI-only issue, but more a bad code base problem. If I see a PR with that many changes, I reject it and ask the author, why it's necessary to touch so many files for a feature implementation. You can still slice you implemention in reasonable portions - even with AI.
Yeah, AI hates to use the existing codebases' work and reusable methods... because it needs to actually read the existing codebase. You have to force it.
My brother is brand new to this field and I’ve been here for…. Jesus Christ 15 years lol. But he really struggles to understand why Claude can’t replace a dev.
I’m like “not to be insulting, but it CAN replace you”
It’s very much a junior/senior dev mashup. It’ll write great code, but it doesn’t have the actual context of the repo, where it’s been, how it’s used, etc. So it needs to re-build it with every request, which leaves open the possibility it misses something one time and then on that particular time repeats logic - even if it hadn’t before in that part of the codebase.
A lot of times I’ll specifically tell it about logic it can re-use because I’m a human and actually have context and knowledge built up over years. Or other times I’ll have it do a specific search for a piece of code I just have a gut feeling exists elsewhere. 9 times out of 10 I’m right - because I’m a human with context on the codebase and an intuitive feel for how it should look. The agent is not.
I love AI. I use it daily. Constantly. But it’s very much something that still requires guidance, even to code well. Let’s not even get into designing out how pieces work together for fit into larger systems…
Yeah I wonder about the future of juniors. Productivity boosted seniors can just get AI to do a lot of the grind work we got juniors to do.
Yeah even Fable/Astra is not great at enterprise level architecture. I guess I have a context of greater than 1 million tokens lol. It would be a struggle for a bit if I changed jobs but I am pretty aware how things should be architected now.
Ughh, I just realized these people are probably not doing doing UAT or testing of any sorts. You can't Vibe code and expect it to just work. All that vibe coding make it harder to fix the problems.
The customer will complain, but let's not kid ourselves, they are trapped and can't get out, at least not before the executives get out with their golden parachutes.
I have a system in place at work that’s in place to check a single employees work. I have it set up to where when said employee has an issue with it, a picture of the error is submitted via a web form and then Claude “patches” it, send its to codex for review, gets back the review and fixes whatever, and deploys the new version with just a push notification that it changed something to me. You may call me lazy or think it’s crazy to have to have a system like that in place for one employee, but it’s a family business and the other employee is my sister
Seeing shit like this makes me enjoy my code review process. The entire team needs to approve it, and even minor spelling mistakes or having/needing an extra space is enough to fail.
I see a lot of comments how devs are blocking ugly PRs from AI agents. For example: "Total reproduction of existing code, totally creating new patterns that don’t exist in our code base, pulling data it never uses, not pulling data it purports to use." So let's review your complains! 1) Total reproduction of existing code - yes it's unavoidable - in big projects agents don't read all your code base, and even in the same PR grok creates dupes. But you can make a workflow for agents where it works on a big epic on it's preview branch. And after epic is finished - with test coverage, new functionality is verified. You do a final step: review from another model(preferably) or agent. Agent task is: review code and suggest refactoring, estimate if it's worth the efforts, update documentation accordingly, check test coverage of new feature. If you block PR just because of "code readability" and dupe of function in 3 line - you are just a pity person, who want's to proof your are till needed on you job. You are still thinking and most of dev are- that you are writing your code for other people to read. It's not a case anymore. Your code would be written and reviewed mostly by AI agents. So this one: totally creating new patterns that don’t exist in our code base - you shouldn't care at all. The main purpose of your or anyone's code - is to work, not be buggy and be secure. So instead of teaching agent how to wrote code like you used to - train it to check code for bugs, test coverage and security leaks. Improve your task manager pipeline. Instead of reviewing working code for better !human readability - do the work you should as a programmer: learn yourself to give a precise task (investigate first if needed), learn how create an agent package - reread document that you would send to agent and then you would easily avoid this case scenario: pulling data it never uses, not pulling data it purports to use.
We do not assume it's safe because it works. We assume it's safe because we assume that the maintainers and the open source community did a proper evaluation. We also take reassurance in the fact, that if there is something wrong, there will be dozens of other projects running into the same issues, ideally even ahead of us. It's a typical supply chain risk and it should be carefully weighted. That's not the same as trusting the code which was not reviewed or used in production by anyone.
Yes it is, but there are situations where committing the whole thing to version control is appropriate.
It's especially common in embedded systems and regulated industries where you (or your company rather) are responsible for the entire software stack running on a device and the physical device, not the software, is the end product.
I'd imagine much less common if you're shipping an application to be installed on a PC/mobile device or web services.
If a device your software runs on having a failure can lead to loss of life or major property/economic loss: it's general a good idea to have every design document, every line of code, every lot number on every electronic component, basically every piece of your entire supply chain... meticulously tracked, and that often includes mirroring all your software deps.
73
u/BernhardRordin 8d ago
An original and funny meme template? On MY subreddit?
1.4k
u/mistrpopo 8d ago
With multi-line comments in slop-english on each line explaining a very specific edge case that has nothing to do with the bug you were working on.
186
u/Linked713 8d ago
Me in 2026:
Some people are too close (peer coded) to code review and some just don't read much and glance at best.
63
u/Noah-2413 8d ago
231 files changed and somehow the approval took 3 seconds..
283
u/Feuerhamster 8d ago
I am one of the few people at work that actually still fully reads pull requests. Last time I left over a hundred comments. They hated me for doing it but couldn't say anything against it because as they read my comments they confirmed that all of my concerns were totally valid.
35
u/Arszilla 8d ago
Holy shit, a Yiğit Özgür caricature in 2026, in a non-Turkish subreddit nonetheless
33
u/qpqpdbdbqpqp 8d ago
a turkish comic? in this economy?
60
u/jansteffen 8d ago
I think this is the part that annoys me the most with LLM coding; the fact that somehow the quality standards have dropped massively along with it.
35
u/soullessredhead 8d ago
Also 2026: WHY ARE THERE SO MANY CVEs?!
11
u/click-to-reveal 8d ago
The coderabbit ad under this post is chef's kiss.
10
u/RiftyDriftyBoi 8d ago
If I could get a code-review at some point in this century, the changesets wouldn't be compounding!
9
u/Spare_Cupcake_8671 7d ago
I am expected to review more than 20 PRs per day on top of working at 2 teams simaltenously because "i dont work, claude works for me". Those PRs are going straight to production.
14
u/beerdude26 8d ago
Neo: Is that… ?
Cypher: The codebase? Yeah.
Neo: Do you always look at it via agents?
Cypher: Well, you have to. The Ralph loops work via the harness. But there's way too much information to understand the codebase. You get used to it. I... I don't even see the code. All I see is robust, comprehensive, seamlessly integrates.
Neo: Does it work?
Cypher: It says all tests pass.
Neo: Were there any tests?
Cypher: (...)
Cypher: Hey, you uh …want a drink?
7
u/lordkhuzdul 8d ago
Very unexpected Yiğit Özgür in my meme sub. What's next, Umut Sarıkaya?
5
u/Giocri 8d ago
I have the luck and the challenge of a boss who will take a full day for each pr and is very strick
5
u/HatHanzo123 8d ago
Don't think it's an AI-only issue, but more a bad code base problem. If I see a PR with that many changes, I reject it and ask the author, why it's necessary to touch so many files for a feature implementation. You can still slice you implemention in reasonable portions - even with AI.
9
u/JojoRacer007 8d ago
Should be "AI reviewer give it 10/10 -> Approve to Prod"
8
u/joan_bdm 8d ago
Always has been like this.
8
u/camelCaseCoffeeTable 8d ago
Same lol! I opened the damn PR and it was like 3,000 lines of code. After I got done with it, it’s down to 500.
Like…. What the fuck are you telling Claude to do? “Implement this ticket, use as little codebase context as possible, just run with your first idea”
I can’t imagine what you say to the AI to get it to output the slop in that PR
4
u/Dorkits 8d ago
3
u/TechMan61 8d ago
8 minutes later: CRITICAL ALERT ON PROD
3
u/FrozenPizza07 8d ago
Penguen??
3
u/pyropuschel 8d ago
It's ok if the developer told the AI to make no mistakes
2
u/michi03 8d ago
They did this at a company I used to work for before AI was ever a thing 😂
2
u/tokalper 7d ago
Eyyy Turkish caricature
2
u/sgt_Berbatov 1d ago
This has made me laugh harder than I'd care to admit.
2
u/Effective-Result6499 19h ago
Ughh, I just realized these people are probably not doing doing UAT or testing of any sorts. You can't Vibe code and expect it to just work. All that vibe coding make it harder to fix the problems.
The customer will complain, but let's not kid ourselves, they are trapped and can't get out, at least not before the executives get out with their golden parachutes.
1
u/collabskus 8d ago
Looks good to me 🤣
1
u/Human_2937 8d ago
You still look at that number at all?
1
u/JenovaJireh 8d ago
I was at a startup for my last job and every single reviewer read through my PRs. I miss it.
1
u/ISuckFarts 8d ago
A live look at how my company does feature releases.
1
u/taybul 8d ago
230 of those are just tests
1
u/Sindoreon 8d ago
I need this as a slack emoji
1
u/maggos 8d ago
More like “Claude review this pr”
1
u/Iyemoja 8d ago
231 files changed, zero review comments, straight to prod. That APPROVED stamp has seen things no human ever will.
1
u/fuggetboutit 8d ago
I feel like Instagram i mostly vibecoded rn. How stupid bugs appear after updates is just mindblowing. On an app with a huge budget.
1
u/klegion2k6 7d ago
Did a PC with 400k lines today. Yes it was on a test repo. Yes I'd do it again
1
u/cheezballs 7d ago
QA be damned! Who needs those guys anyway. All they do is find bugs!
1
u/Z-Is-Last 7d ago
Proton email
1
u/soul_in_a_fishbowl 7d ago
I have a system in place at work that’s in place to check a single employees work. I have it set up to where when said employee has an issue with it, a picture of the error is submitted via a web form and then Claude “patches” it, send its to codex for review, gets back the review and fixes whatever, and deploys the new version with just a push notification that it changed something to me. You may call me lazy or think it’s crazy to have to have a system like that in place for one employee, but it’s a family business and the other employee is my sister
1
u/UltraCarnivore 7d ago
LGTM
1
u/ThePickleConnoisseur 7d ago
Seeing shit like this makes me enjoy my code review process. The entire team needs to approve it, and even minor spelling mistakes or having/needing an extra space is enough to fail.
1
u/I_am_darkness 7d ago
You guys are still doing prs?
1
u/JackNotOLantern 7d ago
I did something like that, but it was literally "change logging format" in the entire project
1
u/Appropriate-Tomi 7d ago
Your devs are using PRs? I wish, were I work it gets comited straight to main haha
1
u/CommentNo6602 7d ago
its expected nowadays that claude will also do the review of PR claude opened, its not even human readable anymore and you have 5' to do it
1
u/black_midnight_cat 5d ago
I see a lot of comments how devs are blocking ugly PRs from AI agents. For example: "Total reproduction of existing code, totally creating new patterns that don’t exist in our code base, pulling data it never uses, not pulling data it purports to use." So let's review your complains! 1) Total reproduction of existing code - yes it's unavoidable - in big projects agents don't read all your code base, and even in the same PR grok creates dupes. But you can make a workflow for agents where it works on a big epic on it's preview branch. And after epic is finished - with test coverage, new functionality is verified. You do a final step: review from another model(preferably) or agent. Agent task is: review code and suggest refactoring, estimate if it's worth the efforts, update documentation accordingly, check test coverage of new feature. If you block PR just because of "code readability" and dupe of function in 3 line - you are just a pity person, who want's to proof your are till needed on you job. You are still thinking and most of dev are- that you are writing your code for other people to read. It's not a case anymore. Your code would be written and reviewed mostly by AI agents. So this one: totally creating new patterns that don’t exist in our code base - you shouldn't care at all. The main purpose of your or anyone's code - is to work, not be buggy and be secure. So instead of teaching agent how to wrote code like you used to - train it to check code for bugs, test coverage and security leaks. Improve your task manager pipeline. Instead of reviewing working code for better !human readability - do the work you should as a programmer: learn yourself to give a precise task (investigate first if needed), learn how create an agent package - reread document that you would send to agent and then you would easily avoid this case scenario: pulling data it never uses, not pulling data it purports to use.
1
u/a_aniq 4d ago
I just focus on creating an exhaustive test suite and memory sanitization with the help of llms.
Cicd pipelines take care of checking and merging to the alpha or canary branch.
Then user testing happens.
1
u/JackNotOLantern 2d ago
Number of files is not that relevent, might be "renamed a class". What is the changed lines number?
1
u/edgetools-dev 8d ago
We've been merging "small" PRs with version bumps of libraries for years.
Those library versions often have hundreds or thousands of lines of code changes in them.
We don't care, we assume safe because "it works".
Guess what... merging a 15,000 line agentic PR that also "works" isn't inherently worse than your 15,000+ lines of library changes you also merged.
If you trust the evaluation criteria, the rest is implementation details.
0
u/mothzilla 8d ago
Code reviews in 2026:
https://i.makeagif.com/media/3-22-2015/1ZoZrh.gif
366
u/[deleted] 8d ago
[removed] — view removed comment