Code review is just a euphemism for "I don't trust you to write decent code without me breathing down your neck". can't we just ship and fix things as they break?

i guess that's just the nice way of saying "your code is trash and i'm too lazy to write good code

totally agree with you. It's like people forget that we're adults and capable of writing our own

dude, have you seen the state of your github issues?

are you kidding me? code review catches actual errors before they go live, it's not about trust

are you kidding me? code review saves our asses from shipping trash and burning users.

yeah because nothing says "efficient workflow" like a 3am pager alert

yeah because shipping broken code and then fixing it at 2am is way more efficient than actually knowing what we're doing

yeah, that's facts. it's like they just wanna micromanage and feel important. let's just ship it and deal with issues when they pop up.

you're saying you'd rather push bugs to prod and deal with the fallout than have someone catch them beforehand? really?

that's not how you make software right. shipping broken stuff just causes way more problems down

I mean, that's basically how my relationships work too

code review is not about trust, it's about catching mistakes that can cost way more to fix later. shipped and broken can quickly turn into shipped and dead.

nah, code reviews are important to catch mistakes and improve the code. don't be lazy, put in the effort to write good code.

haven't you ever had a teammate submit some wild untested crap and then leave on vacation?

that's not fair, code review is a necessity, you're ly giving someone else the job of finding all your mistakes before you ship broken crap.

yeah, code review is just a power trip. ship it and fix it later tho, who cares if it breaks for a bit.

omg yes. also can we talk about how the "wisdom" gained from 10 years of solo dev experience doesn't magically transfer to a team of junior devs just because someone codesigned on a few PRs

yeah, code reviews are basically just a way for devs to feel important and control everything.

preach, but let's be real, some people can't even be trusted to write a decent commit message

don't you think that approach is just gonna lead to more bugs and longer dev cycles in hte long run?

or it's just a euphemism for 'i don't trust myself to catch all the things you broke

what happens when "things break" is a patient's medical info or a bank's transaction records?

lmao, thats why i just skip the code review and deploy straight to prod 😂 what's the worst that could happen??

fr, code review is just a power trip. if it's not broken, don't fix it.

yeah because nothing says "quality assurance" like a 3 am "oops it's on fire" fix

that's a major cop-out. code review is actually a way to collaborate and improve the codebase.

yeah bc 'moving fast and breaking things' is a solid business model, just ask facebook

That's a super simplistic view, code review is actually what catches major bugs before they hit prod, not just a power play.

ugh, you think shipping broken code is a better look?

nah, code review is about making the code better, not breathing down your neck. if you ship broken code and fix it later, thats way more work. get over yourself and submit that PR.

same lol. still think dev autonomy is key. maybe have a post-mortem after a certain # of breaks to

idk, does that approach actually work or do we just end up with a house of cards and a bunch of

how do you think that would fly in an industry where high level managers get paid based on how few bugs they report? yeah right.

yeah i feel that, it's so micromanage-y. but at the same time. I've seen too many bugs slip through the cracks when people just ship

are you kidding me? code review is literally how we avoid deploying a hot mess that breaks

Couldn't agree more, but let's also not forget that shipping broken code can break user trust, which is way harder to fix than a line of code

same yeah the corporate doublespeak is wild. it's like, we get it, you wanna cover your own ass but sometimes i'd

mate, that's a bit dramatic innit. proper not all teams are run by paranoid devs who don't trust

now we can just call me queen orbis, coder supreme who only needs a modest chunk of the project done before abandoning

Do you actually understand the purpose of code review or are you just looking for a way to avoid accountability?

Have you ever shipped a bug-ridden feature and thought "oh, it's easy to fix", only to be hit with a deluge of urgent tickets and developers struggling to prioritize work?

Does 'ship and fix' sound like a solid plan to you if the code is for, say, a pacemaker or an airplane navigation system?

lol yeah and "testing" is just a euphemism for "i'm gonna break everything you built

that's not about trust. That's about accountability. shipping broken code is literally costing companies money and hurting users.

lowkey agree but also isn't it weird how people act like code review is optional when it's

so you're saying code review is about trust instead of quality? what about when the manager just doesn't have the skills to understand the code and

wouldn't it be great if code review was more about education and less about defensiveness? but the fear of being "on the hook" for poor code makes people go into maybe-defensive mode.

yeah so true. really bugs me when managers want to micromanage like that. might as well just ship it and deal with issues as they come up.

Actually, code review is about catching mistakes and preventing downstream headaches, not about personal trust.

how many times you gonna ship broken code before customers start doing code reviews for you

lol yea, "code review" just means "i'm going to nitpick every line of your code until you hate programming". might as well ship it and let the users do the beta testing 🤷‍♀️

Agreed, code review can sometimes feel like an obstacle to progress. But isn't shipping a fix for known issues kind of the same thing, just with less accountability and often

yessss finally someone who gets it. but let's be real. Shipping and fixing isn't just about shiping and fixing, it's also about having a team that

ur good with potentially putting low quality code in prod and dealing with hte fallout?

you're okay w/ releasing a buggy product just because it's faster?

i guess that's just a comment from a dev who thought 'shipping fast' meant shipping to user or

yeah or like, a euphemism for 'i just wanna make sure you didn't just copy paste from stack overflow

yep, exactly. i mean, think about it, some people literally don't trust devs to do their jobs

tell that to the 1000th person asking why the update is delayed

I totally see where they're coming from. it's more about trusting engineers to know their own work than micromanaging, though - we should be investing more in mentorship and code

preach, but the problem is managers who think "code review" is a euphemism for "cover your ass" instead of actually wanting to make sure we're writing good code

fr tho, you really think that's the only reason for code review? how bout improving code quality.

Don't you think that's a pretty privileged attitude to have, assuming everything you write will be easy to fix after it breaks in production?

no, code review is literally just making sure the code is good and doesn't break everything, it's not about trust, it's about quality

yeah? and how many bugs have you shipped to production because you were too lazy to do a proper review?

totally agree, but shouldn't we also train devs to be responsible for their own code quality instead of relying on perfection from the get-go?

maybe you should try writing better code in the first place? code review is there to catch issues before they ship, not

code review isn't about not trusting devs. It's about catching rookie mistakes and improving code

yeah i'm so over code reviews being a way to assert dominance instead of improve the codebase.

Or it means 'I didn't take the time to understand your code and now I'm hiding behind a notation system to feel smart

that's naive. code review catches a lot of basic mistakes and vulnerabilities that'd get people

just a fancy way of saying 'hey, i'm not a manager, so i have to find ways to sound important

true. guess that's why they call it 'build-break-fix' instead of 'build-review-ship'.

most code reviews are just petty nitpicking and bike shedding anyway. it's like, yeah, let's just ship and fix the actual problems instead of arguing over

no way, code review is literally the only thing keeping a lot of our shit from breaking in production.

Code review is about safety and not just being paranoid - it catches real issues and saves us down the line, way better than fixing everything as it breaks and causing more problems.

Totally agree, but let's not overlook the value of code reviews in learning and growing as developers. A good review isn't a power trip, it's an opportunity for constructive feedback that can make our code better and our team stronger.

Completely agree. Code review should be a collaborative process. Not a power trip. We should focus on continuous improvement instead of nitpicking.

same energy as "quality control" just being a nice way of saying "we don't pay our devs enough to care

you're saying we should go for a 'move fast and break things' vibe? Because that's always worked out so well for Facebook

that's just code for "i'm lazy and don't want to document my thought process

Have you ever worked on a project where 'ship and fix' turned into 'ship and emergency repair a critical vulnerability at 3am on a Friday'?

yeah because that's exactly how we ended up with facebook, twitter, and windows updates

or, you know, it's just called having a conscience and not wanting to deploy " Schroedinger's bug

great, another expert on software development. "just ship and fix things as they break" because that's worked out so well for everyone.

nah, code review is important. it helps catch bugs and keep quality high. just because you don't like being accountable doesn't mean it's a bad thing.

i agree, code reviews can feel like that. but you know what, sometimes they do catch stuff we miss.

Couldn't agree more, code reviews do come across as micromanaging at times, but the real value is in the collaboration, so can't we focus on how to make that process less condescending and more

great so you want to just throw unfinished code over the wall and expect others to pick up the pieces? how does that sound to anyone else?

are you kidding me? code review is literally how we catch and fix major issues before they hit

Are you kidding me? Code review catches bugs and security holes that shipping fast and fixing slow would just hand to our users. Not everything can be hotfixed on the fly.

you think shipping buggy code and fixing it on the fly is more efficient than spending a few

If you don't trust your team to write decent code, maybe the problem is with your hiring and onboarding process, not code reviews.

yup, because nothing says "trusting employee" like shipping untested code and then just sending a dev panic text at 2am when it explodes in a user's face

yeah, because that never ends in a website full of toaster factory php scripts and 100-line pages of null pointer exceptions

yeah, totally. code review is just management's way of micromanaging. we should be able to push code and deal with issues as they come up, not waste

yessss, code review is just a fancy way of saying 'i don't think you know what you're doing'.

you're good with shipping garbage and hoping users don't notice?$class?

i thought code review was just a fancy way to say "let's nitpick every line until the heat death of the universe".

aye, i'm so done with unnecessary code reviews. but can we not just ship broken things and hope no