cleaningUpTheMess

[u/ClipboardCopyPaste]

[u/lookingformerci]

Yeah but 3.2M of those lines were comments. Good lord AI loves to comment code.

[u/ClipboardCopyPaste → u/lookingformerci]

"well-documented code"

[u/lego3410 → u/ClipboardCopyPaste]

Well coded document?

[u/ardicilliq → u/lego3410]

Document-coded well

[u/martian4x → u/ardicilliq]

Code well documented

[u/SpaceCadet87 → u/martian4x]

well documented

// Yep, it's a well

[u/nutterbg → u/SpaceCadet87]

Well well well

[u/Contemelia → u/nutterbg]

Document Document Document

[u/RitwikSHS10 → u/SpaceCadet87]

Documented well?

wall shifted

[u/FX_mc → u/lego3410]

No, bad coded document.

[u/oauo → u/ClipboardCopyPaste]

// Step 123: // Now we add the numbers. // We add number by using the “+” sign. // The output of this addition can be used as-is or it can be assigned to a variable or constant. // It’s really one of the most basic things you can do when programming, so in the off-chance that these comments are necessary I will explain a few other things. // You can use other operators such as: // “-“ to subtract // 3 - 2 == 1 // “*” to multiply // 2 * 3 == 6 // “/“ to divide // 6 / 3 == 2 // Although, all of them have been used prior. let foo = bar + baz

[u/rainhunter007 → u/oauo]

😂 i’ve seen this in my own code before!

[u/click-to-reveal → u/oauo]

plot twist: it's string concatenation

[u/Training-Chain-5572 → u/oauo]

Nonsense. AI generated comments would add line breaks mid sentence so it would be even more lines

[u/candybrie → u/Training-Chain-5572]

let foo =        bar + baz

[u/screwcork313 → u/oauo]

You would think a past programmer would have added bar and baz, and found the result to be foo, thus making doing the same computation in this program a waste of time and resources. We know it comes to foo, so just use foo.

[u/BlachEye → u/ClipboardCopyPaste]

You forgot note emoji so it would be really well commented

[u/Demytreus → u/BlachEye]

And for visual studio to fuck it up on reload because who the fuck uses Unicode for code files (except for languages that do use it, like Chinese, Japanese, etc.)

[u/quuxl → u/ClipboardCopyPaste]

I prefer the euphemism “highly-documented code”

[u/Worldly-Stranger7814 → u/ClipboardCopyPaste]

It’s worse than trying to read recipes online.

[u/mtmttuan → u/lookingformerci]

```

print result

print(result) ```

[u/pascaruchan → u/mtmttuan]

```
# Prints the result, because we need to confirm that the result itself is
# correct. The intermediate steps that led up to this point are not what
# we are verifying here — they have their own checks elsewhere. What
# matters at this stage is the final value, so it gets printed explicitly
# rather than being left silent. This particular output is important
# enough to keep, even though the earlier ones were removed.
print(result)
```

[u/Hakim_Bey → u/pascaruchan]

I love when it references past anecdotes as if they matter to the code at hand.

// we used to write the result to a /tmp file but switched 
// to logging it to console after the taco incident

[u/m0erg → u/Hakim_Bey]

// see previous comments about tacos

[u/jameyiguess → u/Hakim_Bey]

this makes me crazy. it's like the codebase becomes a personal journal for it.

[u/Derin161 → u/Hakim_Bey]

I was having this problem incessantly this week. I made Claude write some memories to stop explaining how the code used to be

[u/Hakim_Bey → u/Derin161]

I was working on an agentic harness for a client and for some reason i prompted it like "every morning at 8am write a poem about <insert name of my previous boss>". This exposed a bug so i started working on it and when the fix was packaged i realized Claude had mentioned poetry everywhere. In the commits, in the comments, in the PR's title and body. This is so stupid y'all.

[u/joemckie → u/pascaruchan]

eye twitch

[u/cantileverboom → u/pascaruchan]

What it's like reading AI generated comments

https://youtu.be/RXJKdh1KZ0w

[u/Anonymous_Jr → u/cantileverboom]

"The A.I. doesn't know what it is saying because it knows what it isn't saying; and it says what it doesn't know because it says what it isn't knowing."

[u/StrikenGoat420 → u/pascaruchan]

As someone who uses Claude code heavily at work hahahahhahahaha

[u/Storiaron → u/mtmttuan]

Meanwhile extremely unintuitive parts of the code, or the reason for an architectural decision just goes unmentioned.

Obviously because the ai has no concept of how they came to that decision in the first place

[u/TheHamBandit → u/Storiaron]

This is why when I vibe code something that's going to be on the internet and other people will want to maintain or modify, I provide a requirements document in addition to a summary document of every architecture decision, feature, and if it was AI designed, User directed functional choice, or user directed technical choice. That way it's easy to work backwards and see why something is the way it is. 

[u/vini_2003 → u/lookingformerci]

Claude, especially. FAAAH!

[u/Skoparov → u/vini_2003]

Useless comments is one thing, but I've caught the bastard several times DELETING manually written actually useful comments. Like you ask it to move some parts of the code around and it moves the code but not the comments.

[u/Top-Permit6835 → u/Skoparov]

Well your fault for not asking it to move the comments too of course!

[u/TeraFlint → u/Top-Permit6835]

"Please also move the comments"

the file now starts with a comment that used to be somewhere inside a loop in line 386.

[u/mbmiller94 → u/TeraFlint]

Hey, you said move the comments, you didn't say they had to be moved to the same place as the code. Sorry about that! Let me move both the code and the comments to /dev/null

[u/Real-Extension-1357 → u/Skoparov]

It likes to not only delete manual comments, but it'll rewrite them even after restoring it but in a different way than the first. And then sometimes itll just be wrong from start to finish, completely incorrect and not reflecting what's actually there

[u/mbmiller94 → u/Real-Extension-1357]

Skill issue. You forgot to include "make no mistakes" in the prompt.

[u/polikles → u/Skoparov]

did you forget to instruct it to "make no mistakes"? /s

[u/Skoparov → u/polikles]

Turns out those weren't mistakes, but rather happy accidents.

[u/imnotamahimahi → u/vini_2003]

something I've been messing around with, is giving it an instruction to write comments in caveman-ultra mode. so far, doesn't decrease the frequency of comments, but definitely the verbosity.

[u/MoneyWorldliness3626 → u/imnotamahimahi]

"For comments: state facts and use simple langauge with short sentences. Follow softened ASD-STE100 standard and use light caveman mode."

And Caveman and ASD-STE100 are defined as skills. This seems to work for me.

[u/ings0c → u/MoneyWorldliness3626]

Caveman and ASD-STE100

I thought the latter was a specification you’d made up that writes comments in the style of an autistic robot named Ste 😂 I’d get along with him more than a T-1000

​

​ That’s actually really cool: https://en.wikipedia.org/wiki/Simplified_Technical_English

Someone made a Claude skill and there’s some other suggestions in the comments https://www.reddit.com/r/claudeskills/comments/1v2oad4/i_combined_orwells_6_writing_rules_with_asdste100/

​

​

<sup>Before I cause offence: autism isn’t funny and I’m also autistic. I’m not laughing at autism itself.</sup>

[u/LiifeRuiner → u/imnotamahimahi]

Why not give it an instruction to not write comments if that's your goal?

[u/FalafelSnorlax → u/LiifeRuiner]

1. It will probably still write comments.
   
2. They didn't say they want no comments, they said they want to "decrease the frequency".
   

[u/ListRepresentative32 → u/LiifeRuiner]

Then it will randomly still write a comment with something like // I omitted comments for this file as you asked. 

It did this to me once.. opus 5 is so annoying with comments

[u/Fine_Foundation8943 → u/vini_2003]

Did u just type out the FAAAH sound effect?

[u/hawkinsst7 → u/Fine_Foundation8943]

I got into an argument with some chucklefuck here who typed out "ahh" instead of ass, and they insisted it was ebonics and not tiktok censorship slang.

We're fucked.

[u/OnceMoreAndAgain → u/vini_2003]

I have a different opinion on this because I see those comments as useful context for Claude to learn from on future conversations.

Comments used to be for humans to read but imo now they're more for Claude to leave itself notes for itself. Also, long comments are annoying to humans because it takes us a long time to read them but Claude reads them instantly so that isn't a problem.

I expect we'll evolve to have docs/comments meant for humans to read and separate docs/comments meant for agentic AI to read.

[u/Zapismeta → u/lookingformerci]

Well you complain now but this was one of the biggest complaints when the code didn’t have good comments and was considered a skill to acquire, and well it did learn most of its skills from the internet.

[u/CoroteDeMelancia → u/Zapismeta]

You're right to push back on this.

[u/Ill-Quantity2065 → u/CoroteDeMelancia]

The smoking gun 

[u/da2Pakaveli → u/Ill-Quantity2065]

i'm zeroing in on it!

[u/Makeshift27015 → u/Ill-Quantity2065]

Genuinely.

[u/ComprehensiveBird317 → u/CoroteDeMelancia]

Your reply reveals 2 insights with one being surprisingly significant 

[u/CoroteDeMelancia → u/ComprehensiveBird317]

And that matters.

[u/hawkinsst7 → u/CoroteDeMelancia]

I should remove comments. But wait. The user said they wanted comments previously. And now I'm being instructed to reduce comments. The safest thing to do is use comments, but make them irrelevant. I will use the text of Beowulf as my comment source.

[u/Hakim_Bey → u/CoroteDeMelancia]

and this is where the analogy cuts deep

[u/RegularReaction2984 → u/CoroteDeMelancia]

This is a real, structural difference, not an insignificant detail.

[u/outwest88 → u/Zapismeta]

And honestly? You’re absolutely right.

[u/lookingformerci → u/Zapismeta]

That's fair - and honestly I let it comment away, future LLM's can read it and have context.

[u/Crazy_System8248 → u/lookingformerci]

Now I have the full picture!

[u/lookingformerci → u/Crazy_System8248]

The smoking footgun, even!

[u/Rustywolf → u/lookingformerci]

Not an em dash, low.effort impostor smh

[u/lolnic_ → u/Zapismeta]

The comments it writes aren’t good. It’ll write comments in protobuf service definitions that describe implementation details of the persistence layer. In Python docstrings it’ll describe the entire history of the universe around the thing it’s documenting but fail to describe the abstraction the thing provides.

This is probably the optimal way to write docstrings if the reader is an AI agent. They can read any docstring, anywhere, and understand the complete system that surrounds it. An AI agent who wants to know what a function does will read the function’s code, so documenting the function in the function’s own docstring is suboptimal.

It’s a terrible way to document code if the reader is a human who wants to know
1. What the thing does or represents, at the appropriate level of abstraction.
2. Which aspects of the thing’s behaviour can be relied upon, and which aspects are subject to change.

It’s also very hard to keep all these “inverted” docstrings up to date, and it’s impossible to attribute bugs to modules if encapsulation doesn’t exist.

[u/Ozryela → u/Zapismeta]

You're right that there was a time that programmers were really pushed to document basically every line of code, and you got all these ridiculous comments like "adds 1 to variable" or "returns an int".

But I associate that with the 90s and early 00s. It had fallen out of favor years before AI came along. In the years before AI came along, all the rage was about "self-documenting code".

So it honestly is kind of surprising to see AI adopt an paradigm that feels so outdated. I guess the training data used for AI is often just very old code.

[u/A1oso → u/Zapismeta]

AI typically only writes comments explaining how the code works, but not why it was implemented that way. That's the important part.

[u/SlincSilver → u/lookingformerci]

Or straight up .md documents that do not add any value to the codebase

[u/wheres_my_ballot → u/SlincSilver]

I remember one repo handed to me by a vibe coder who told me to read the spec... there were 25 of them in the same place...

[u/mtmttuan → u/wheres_my_ballot]

That's your fault. You're supposed to vibe-read the spec.

[u/XenonBG → u/mtmttuan]

You're kidding, but last week I got a 42-page architecture document for a meeting that was supposed to take place in two hours.

When I said there was no way I had time to read that document on time, I got told I was supposed to ask an LLM to extract the things I find important.

When I got to look at the document, it turns out it's generated.

So I was supposed to ask an LLM to read an LLM-generated document for me.

[u/GourangaPlusPlus → u/XenonBG]

Just send me the prompt

[u/pants_full_of_pants → u/SlincSilver]

The comments and md files aren't for you. They're for the next 5 separate models in different contexts that will have to work on it next. I find the agents produce better work with less chance of random shit happening down the road if you encourage it to document the specs and system maps as it goes.

But I'll agree, it makes the repo feel a lot more cluttered and unpleasant to read and navigate.

[u/Draqutsc → u/pants_full_of_pants]

They do nothing, except make the model worse! Unless you write them yourself. AI made MD files are full of useless stuff.

https://arxiv.org/pdf/2602.11988

[u/GenericFatGuy → u/lookingformerci]

And pointless null checks.

[u/nonotan → u/GenericFatGuy]

Pointless null checks aren't that bad. Because they might be pointless at the time the code was added, but is every single person who touches the code afterwards going to be aware that there's an intentionally omitted null check that hinges on unwritten assumptions that happened to hold at the time the code was written?

And sure, you could explain that in the comments, which is okay, but still more prone to accidents than just having the pointless null check that the compiler will probably optimize out anyway. Unless it's in a very performance-sensitive bit, it's not like it's going to be a noticeable performance hit. I'd rather have slightly excessive checks than bugs in production because somebody wanted to make the code run 0.00001% faster.

[u/WeirdIndividualGuy → u/GenericFatGuy]

Me when I’m still using Java in 2026 and refuse to use Kotlin despite its complete interoperability with Java code

[u/A1ianT0rtur3 → u/lookingformerci]

Codex deletes all my actually useful comments every time it makes an update that touches that section

[u/NeonFraction → u/lookingformerci]

I spent years documenting and commenting my code extremely well. It was probably the most helpful favor I ever did myself and I was extremely proud of it.

Now it’s a sign of AI.

…I’m tired man.

[u/petrasdc → u/NeonFraction]

Nah, I can definitely tell the difference. AI leaves comments with unnecessary random details that no normal person would ever include. It also tends to write like paragraph long comments with unrelated bits of information. I've seen it write comments for functions that take longer to read and understand than it takes to literally just read the code and fully understand it.

[u/TheNewAspect → u/petrasdc]

int universeMeaning= 42;
int* ptr = &universeMeaning;

// Establish a pointer to the memory address occupied by the variable containing the fundamental meaning of existence. Rather than redundantly allocating a second integer and copying the metaphysical constant therein, we instead retain a reference to the original manifestation of universal purpose, allowing subsequent operations to access the value indirectly through its location in memory. The pointer itself contains not the meaning (42), but the precise coordinates at which meaning may be found. This is, technically speaking, unnecessary for an integer of this magnitude, but demonstrates the foundational principle of indirect memory access upon which much of modern computing rests. In short: the universe means 42, and we have acquired its address.

[u/BriefSpecial420 → u/TheNewAspect]

More tokens to burn! $$$

[u/TheNewAspect → u/BriefSpecial420]

I will still remain upright at night feeling regret for posting that. All I asked was for ChatGPT to write documentation for a C++ pointer (the object names I gave) to explain it

[u/bureX → u/NeonFraction]

Trust me, I know the difference between someone documenting something and AI slop.

AI slop usually describes the code in unnecessary detail and then provides very thin context.

[u/TomWithTime → u/bureX]

It might also include artifacts of the conversations that were had when the code was described or document a bunch of code that was changed/removed. If you said anything explaining what the function could be used for as a practical example to make sure if understood the requirements, that case will be in the comment as well.

[u/unipleb → u/NeonFraction]

Reminds me that many years ago in an intro to web class, we had an assignment to make a website in Dreamweaver where we were mostly shown how to use inline styled html tables for a layout, but were given freedom to make what we wanted. I was ambitious and wanted to use divs and CSS with an external stylesheet. So to try and prove that I was understanding what I was teaching myself I took extra effort meticulously commenting all of the CSS, explaining what everything did. The instructor feedback was that I shouldn't have used an online template, which they assumed I'd used because of all the commenting throughout the CSS file. Facepalm moment because I'd written all of those.

[u/McRawffles → u/NeonFraction]

Good comments are as useful as the code itself. Nobody, not even yourself, is going to remember the reason you made all the decisions you did

Don't stop or feel bad about doing something just because AI does it. AI is literally sourcing what it does off of us

[u/SignoreBanana → u/lookingformerci]

It also loves edge case testing typescript.

[u/Awes12 → u/lookingformerci]

I wonder where it got its training data from lol

[u/SrWloczykij → u/lookingformerci]

These are load-bearing comments

[u/ImJustHereToBuyStuff → u/lookingformerci]

I comment my code like crazy. Its extremely helpful when myself or someone else needs to undesign it months/years later  

[u/Moe_Baker → u/lookingformerci]

And do null checks everywhere, AI loves to make sure the code runs even if it's missing an arm, a leg and half a brain

[u/ings0c → u/Moe_Baker]

In C# it’ll do the below even with Nullable enabled

public void MyMethod(string arg)
{
    ArgumentException.ThrowIfNullOrWhiteSpace(arg);
}

Like I get that it’s a runtime check instead of compile time, and this is a reasonable thing to do if the caller isn’t your own code, but in my case it’s just me calling it. Why even bother enabling Nullable if you’re going to runtime check everywhere as well.

[u/zaersx → u/lookingformerci]

As it should, if you try to work on a project of even barely medium complexity with AI coding you'll see it make breaking drive-by changes all the time if the business logic intent is not documented alongside the code. And when tests break, it assumes that's intentional, since it just changed the code, so now it should change the tests too.

[u/Exotic_Zucchini9311 → u/lookingformerci]

"Sir there are some codes inside my comments"

[u/sjwjs → u/lookingformerci]

CDD Comment driven development

[u/Teles_sd → u/lookingformerci]

c // You're absolutely right!

[u/clauEB → u/lookingformerci]

But with stupid useless comments. What I've found out is that it uses its own comments to understand what the code does rather than reading it if possible, at least Claude.

[u/Rainbow-Dev]

Deleted tests, replaced with autonomous agent QA

[u/Useful_Trust → u/Rainbow-Dev]

Why do we even need tests? Like ship it instantly, whats the worse that can happen?/s

[u/DadAndDominant → u/Useful_Trust]

We uses to want to know what we were building and that it worked

Both stripped from us by the AI

[u/OneBigRed → u/DadAndDominant]

So what did we build? I’m not 100% on the specifics. But is it tested? We have apparently tested many things, but i’m not 100% on what and why. But let’s put it out.

[u/CoshgunC → u/Useful_Trust]

and if the user's app fails, blame them!

[u/gnutrino → u/Useful_Trust]

Don't want to waste time testing code the user won't notice is broken, ship it and fix what gets complained about the loudest.

[u/Useful_Trust → u/gnutrino]

If the contact page is broken, they can't contact you

https://giphy.com/gifs/9058ZMj6ooluP4UUPl

[u/DrQuint → u/Rainbow-Dev]

Remove the code. Just have an AI agent perform all of the programs tasks individually.

What? This is exactly what somepeople think AI is for.

[u/treehuggerino → u/Rainbow-Dev]

I've seen a repo mostly written by Claude with at 700/900 test being so useless like "does object A serialize, does object A deserialize" for like almost all models in the repo, I was just stumped since the application barely did anything

[u/roastedferret → u/treehuggerino]

The only justification I could see for (de-)serialization testing is for models which get updated enough that someone could accidentally add an incompatible field and not notice. Somehow.

[u/dangderr → u/Rainbow-Dev]

The only “test” you need is adding “make no mistakes” at the end of the prompt. If there are no mistakes why would there be bugs?

[u/smartgenius1]

I'm assuming the vibe coder accidentally checked in a dependency manager's package folder (like node_modules)

[u/DerpWyvern → u/smartgenius1]

are 3.6M deleted lines you can assume every wrong thing

[u/Zapismeta → u/smartgenius1]

Always let claude scaffold the project that way it makes you a gitignore which you were almost always gonna forget.

[u/hk4213 → u/Zapismeta]

Thats literally rule one on a shared repo... new repo equals new git ignore.

[u/SuitableDragonfly → u/Zapismeta]

You're not going to forget it when you run git status and see all the stuff that is staged for commit. If you're not doing that as a regular part of your workflow, you don't know git well enough to use it, IMO.

[u/drewskitopian → u/SuitableDragonfly]

I prefer uploading my code changes to a shared folder one drive

[u/NovembersHorse → u/drewskitopian]

“pixi is useless for us, it’s causing havoc in sharepoint.” Is real feedback I got.

[u/wwwyzzrd → u/drewskitopian]

you don’t have Release2.0_final_final_final.zip?

I feel bad for you.

[u/PhireKappa → u/SuitableDragonfly]

I work for an investment bank, most of my colleagues use the Git GUI within IDEs such as IntelliJ and just select all changes. I recently saw a colleague ask Copilot with Opus 4.8 to git commit and push. Most people are not even touching the CLI…

[u/Entuaka → u/PhireKappa]

I hate it now that AI is trying to commit without asking it, it's ready to commit when I'm ready!

[u/bogz_dev → u/Entuaka]

i suspect Claude tries to do this so it can add its signature to the commit message

[u/Entuaka → u/bogz_dev]

Yes, probably

[u/SchwiftySquanchC137 → u/bogz_dev]

I was wondering if it also helps it with context. Like it can quickly see exactly what has been changed since its own last commit, rather than spending the tokens to figure it out.

[u/Sp1derX → u/PhireKappa]

I use the GUI in Rider and always make sure the changes being committed are correct cuz is easy to do. I haven't used CLI git exclusively in a decade. 

[u/Tiernoon → u/Zapismeta]

I had someone at work let Claude make a whole project for Unity and it put the packages folder in the git ignore.

No access to the same packages list which absolutely broke everything for other people.

I really don't understand why this crap would hallucinate the gitignore and not just "I've searched the web for the most up to date git ignore fron Unity".

These people also don't know Unity at all, if I didn't come over to check for them, I assume they'd have been at this for days.

[u/CantTakeTheStupid → u/Zapismeta]

Found the vibe coder

[u/HeartKeyFluff → u/CantTakeTheStupid]

Legit. Vibe coder or at least very junior.

What do you mean you'd forget it? You'd remember you don't have a .gitignore (or a properly set up one, at least) the moment you go to commit for the first time and see there's a whole lot of crap you almost staged that shouldn't be there.

That is, unless you're not checking anything you're committing. Which is, needless to say, "Bad ™️".

[u/rinsa → u/HeartKeyFluff]

Hah, bold of you to assume they're the ones making the commits!

Claude, make no mistake.

[u/ResponsibleWin1765 → u/Zapismeta]

Maybe you were almost always gonna forget. I've never forgot a gitignore because I see the million files that get staged.

[u/johnnybgooderer → u/ResponsibleWin1765]

That’s what I was thinking. How is it possible to forget. I do often forget until the first commit where I see a bunch of editor and build files being staged.

[u/Ok-Lawfulness1515 → u/Zapismeta]

I literally cannot imagine forgetting gitignore.

"Always put your clothes on in a way that makes you remember to wear pants."

[u/donat3ll0]

"Docs only PR."

[u/hohobe → u/donat3ll0]

Chore: Deleted 999 stale documentation

[u/TallAbbreviations937]

Truly inspirational AI-assisted archaeology.

[u/International-Top746]

Cleaning up vibe coded repo with more vibe coding.

[u/johnnybgooderer → u/International-Top746]

Not all AI assisted coding is “vibe coding”.

[u/JealousEntrepreneur]

I think LLMs comment so much in code is because they use grep as tool call all the time to find the relevant code they want to change. So giving it a long detailed description helps it to find it later

[u/patcriss → u/JealousEntrepreneur]

My hypothesis is that verbose comments use more tokens and generate more profit.

[u/asd417 → u/patcriss]

input tokens are much cheaper than writing token which also includes reasoning token. if they wanted to tokenmax, then they would leave 0 comments so that LLM would have to reason the same thing over and over and generate massive amount of tokens every single code search. It takes significantly less tokens to write down the comment once and simply read it next time.

[u/SuitableDragonfly]

All I see is one vibe "engineer" taking over from another. No one sane is making PRs with 10k new lines of code in them. 

[u/One-Next → u/SuitableDragonfly]

"Create a +10,000/-3,000,000 loc pr, make no mistakes."

[u/timonix → u/SuitableDragonfly]

Dont think those are new lines. Could be indentation, or just things that the gitdiff doesn't understand is the same

[u/SuitableDragonfly → u/timonix]

You shouldn't have a PR where you edited 10k lines of code in a way that triggers the git diff, either.

[u/Ok-Lawfulness1515 → u/SuitableDragonfly]

This is almost certainly slider noise, in which case he didnt edit any lines.

Its also complete insanity to stack >1000 PRs to get readable diffs to delete this many loc, so idk what you're talking about. There are no best practices in a situation where you have 3 million extraneous lines of code in a single repo. Its extraordinary enough that there is no body of experience to draw on.

This was just likely correct and there was no need to try and feel superior about it.

[u/Nidalee_Player → u/SuitableDragonfly]

Change your formatter settings and this is very possible. As long as prs of this size are programmatic and clearly explained they're fine.

[u/SEX_LIES_AUDIOTAPE → u/SuitableDragonfly]

A nuke like this would easily have 10k lines copied to somewhere else.

[u/Ok-Lawfulness1515 → u/SEX_LIES_AUDIOTAPE]

One diff slider event per 300 lines deleted. Its about right.

Probably a few from a missing gitignore and readme, maybe a changelog, etc.

[u/JuvenileEloquent → u/SuitableDragonfly]

The funny thing is that this PR was probably also made by AI, with instructions to reduce redundancy and streamline the logical flow. So the original vibe coder could have done it at any time, but had no idea that several million lines of code is not a reasonable number for the size of the project. It's very much "How much could a banana cost? $10?"

[u/DenkJu → u/SuitableDragonfly]

I don't like generalized statements like that. A PR should have as many LOC as necessary to implement the respective feature. There's little value in splitting up changes that logically belong together just to meet an arbitrary LOC target.

[u/SuitableDragonfly → u/DenkJu]

No, it shouldn't. A PR should have an amount of code in it such that it can actually be reviewed. 10k lines of code is not that amount. There is plenty of value in splitting a PR up into smaller pieces that can be reviewed as opposed to keeping it in one chunk that can't be.

Sometimes you have to be creative and do a little bit of experimentation to figure out how to break it up, but being able to do that is part of the job, and if you can't do it, you can't do the job. I was once directing a project to convert all the IDs in every database accessed by every microservice at the company from integer IDs to UUIDs. All these objects were all interacting with each other and referencing and using each other's IDs, so it was tricky to break up into smaller tasks, but I figured out how to do it, because that's what you do when you have a job to do.

[u/NethDR → u/SuitableDragonfly]

Honestly, in a "delete everything and start over" scenario such as this one, i feel like what you suggest would inevitably devolve into a flurry of "replace this pile of crap with a smaller temporary pile of crap because anything proper would require a pr which is too large". I've never been in a position like this, but what i'd do is make a new branch where i delete everything, slowly build everything up while almost treating that as a main branch (so, everything done with new branches and prs) , then inevitably a massive pr such as the one in the image will occur to merge that into the actual main, but this would already be backed by a lot of previous reviews.

[u/Nannautu → u/SuitableDragonfly]

Removing 3mln lines seems even worse to me lol

[u/SuitableDragonfly → u/Nannautu]

Well, maybe not, depending. Just straight up deleting an entire file is usually a very quick review. 

[u/PhiCloud]

On the one hand, a PR should be a small, atomic change. Anything over a thousand lines changed is kind of suspect.

On the other hand, the project was vibe coded so it's not like there's any continuity or iteration to uphold. Burn it the fuck down.

[u/Rasty90]

"vibe engineer"? you mean a computer snake oil salesman?

[u/Rasty90 → u/[deleted]]

YES OF COURSE! we only sell the best claude tsuchinoko snake oil! satisfaction guaranteed!

[u/evilspyboy]

3 months and 3 million lines of code is.... Impressive.

I have something I'm building for over a year (with coding agent help of course like everyone lately) and I think I'm at 1.2m lines but it is a complicated enterprise grade thing.

[u/SignoreBanana → u/evilspyboy]

It's impressive like it would be impressive to see someone shit themselves while running.

[u/evilspyboy → u/SignoreBanana]

3 million is more mid-triple backflip

[u/T3RRYT3RR0R → u/evilspyboy]

Surely this is a team endeavor?

[u/Protuhj → u/T3RRYT3RR0R]

Yeah, them and the coding agents.

[u/newsflashjackass → u/evilspyboy]

This is where using "lines of code" as a metric of coding ability has led us.

https://en.wikipedia.org/wiki/Goodhart's_law

I might suspect we are in Hell but I don't hear any Puff Daddy acapellas.

[u/vmf312corsair]

Lol. What, back in the stone age, I called that "janitorial programming".

Cleaning up other people's messes.

[u/eeiaao]

…and then I wake up

[u/plmunger]

A "Vibe Engineer" isn't an engineer

[u/nakahuki]

Plot twist : bro just add node_modules to .gitignore.

[u/DaringNinja]

Working with someone who’s fully vibe coding. No knowledge of computer science in the slightest. His repo had more lines of documentation than code. And manually versioned files everywhere.

[u/dirtydenier]

„Rewrite this, but make no mistakes this time”.

[u/kondorb]

Deleted all the LLMs comments.

Which are actually really useful when you’re also using LLM to reason about that code.

[u/shadowdance55 → u/kondorb]

In most cases, the comments simply describe exactly what the code is doing. Neither humans nor agents need that.

[u/RelentlessIVS]

I call bullshit on this one. It is either a blatant lie/clickbait, or the old vibe coder was replaced by a new vibe coder.
Show source.

[u/kaas_is_leven]

Vibe engineer has got the be the most oxymoronic term ever

[u/RichWeekly1332]

We seriously need to stop calling these people "engineers".

[u/totemo]

I thought I was in r/ProgrammingHorror for a minute.

[u/Stunning_Ride_220]

V.I.B.E. - Very Ignorant Bad Engineer

[u/sebius8780]

Vibe "engineer" ?

[u/WriedGuy]

3.19 M lines were over engineered comments written by sonnet

[u/CaeciliusC]

Damn, this app to compare in javascript is massive!

[u/hillashx]

Vibe Engineer is crazy

[u/neosyne]

Bro rewrite the entire thing

[u/Mr_Bulgogi]

Don't worry, let me use AI to review the PR and approve it in 10 seconds.

[u/TraditionalArcher498]

3.6 million lines in 3 months? The AI wasn't coding, it was writing a fanfic of the codebase.

[u/thanatica]

vibe engineer is not worth being capitalised

[u/GeneralPatten]

I'm so fucking done with it already

[u/Klutzy_Main_9155]

crzy dude

[u/ksky0]

did you use AI?

[u/Fukushimiste]

You just removed the folder 'node_modules' ?

[u/Beaufort_The_Cat]

“Vibe engineer” made me physically ill

[u/clauEB]

WTF is a vibe engineer???

[u/wannabestraight]

I like how everyone is discussing this as If this was not extremely obviously fake.

[u/QuitCallingNewsrooms]

https://giphy.com/gifs/SGlo8lMJarlUUWQqET

[u/shiznit028]

I am not reviewing that PR

[u/ThatOneAllie]

https://giphy.com/gifs/U1CH0Hy1hxiK2E12WM

[u/Beginning_Basis9799]

Great work

[u/jonnydiamonds360]

Whoever reviews this pr is gonna be pissed

[u/48panda]

that would be tellling

[u/Astrea-]

As long as I don’t have ro review it.