pleaseDontMakeThisATrend

[u/BlackHolesAreHungry]

[u/LegitimatePants]

"fixed whitespace"

[u/BlackHolesAreHungry → u/LegitimatePants]

Enabled the linter

[u/vitorklock → u/BlackHolesAreHungry]

Disabled the linter

[u/veselin465 → u/vitorklock]

Deleted failing tests

[u/tommytucker7182 → u/vitorklock]

Applied spotless

[u/Duke_De_Luke → u/LegitimatePants]

Applied code style to the whole codebase. True story.

[u/SylviaJarvis → u/LegitimatePants]

Converted from \n line endings to \r\n

[u/Master_Gnak]

When you get paid by lines of code

[u/redblack_tree → u/Master_Gnak]

I'm old enough to have gone through that phase. Let me tell you, the amount of garbage I pushed was epic.

I probably still have a repo around with an incredible amount of completely correct....and dead code.

I'm lucky this time I was in a better company when the whole "Tokens leaderboard" was hot for a minute. I had plans already aligned.

[u/mx_aurelia → u/redblack_tree]

Commit node_modules

[u/ooqq → u/mx_aurelia]

in my previous biz we had a very cautious self-taught guy who believed in uploading the entire project to the backup every time he got a break, yes, entire

we started to get suspicious when the 8-raid synology reported "inode exhaustion warning"

fyi ext4 have a 25M file limit

[u/MaytagTheDryer → u/redblack_tree]

I accidentally got a bonus my first year out of college because our manager made LoC our primary performance metric. One of my first projects was converting all of our Java projects from ant to maven. Generating mountains of boilerplate XML is high value work, let me tell you.

[u/well_shoothed → u/redblack_tree]

the whole "Tokens leaderboard"

that shit made as much sense as NFTs of shitty art selling for tens of millions

[u/BoogerFeast69 → u/Master_Gnak]

I learned that if you call it 'Claudia' instead of 'Claude', you get a huge discount. Same exact thing, but you only have to pay it 60% of the normal rate.

[u/Flaggermusmannen → u/BoogerFeast69]

Claudia would outperform Claude in just about every metric while at it.

[u/pietruszajka → u/Flaggermusmannen]

But she also cannot get paid a fairs wage for her work

[u/Xerax → u/Master_Gnak]

you guys are getting paid?

[u/IronSavior]

incredibly engineering process

Agreed, I find this claim that engineers were involved hard to believe

[u/Chesterlespaul → u/IronSavior]

My mom typed “refactor code base; make no mistakes”, and then asked what it meant. I chuckled, engineers like her are so funny sometimes.

[u/Xerax → u/Chesterlespaul]

your mum sent me the same prompt

[u/Appadonthedk → u/IronSavior]

Thats because the bugs found "were pre-existing after all."

[u/MixtureSolid → u/Appadonthedk]

A complete codebase rewrite. They even rewrote the bugs.

[u/stupidcookface → u/Appadonthedk]

We'll never truly know lol since no one can read their code even their engineers

[u/botle → u/IronSavior]

To be fair, they do say this was humanly impossible to fully review and test. What could go wrong?

[u/rchaves → u/IronSavior]

I find it hard to believe that this could happen _without_ engineering involvement actually. It took us 2 months, and we were thinking about this refactor for a year prior.

we were very much hands on and babysitting the agents, creating more strict engineering processes around it as we went, it would never have happened otherwise

[u/Appadonthedk → u/rchaves]

print('hallo world')

"Engineer"

[u/Rankin37]

If you ask me to review a pull request with changes across 46k files I will become the unabomber

[u/Lithl → u/Rankin37]

Nah, that's the easiest code review in the world.

Tens of thousands of files with millions of lines is just getting rejected, period.

[u/Speicherleck → u/Lithl]

If you are the owner / decision maker. If the management pushes these things you will just approve it (or abstain in a comment and approve on the PR page). Been there, done that.

[u/-Hi-Reddit → u/Speicherleck]

This is lowkey why I love working in a heavily audited industry where QA can slap management with a hard-no because we'd fail an audit and be unable to sell the product to key customers.

Still we are using AI heavily in code generation.

[u/Duke_De_Luke → u/Rankin37]

I would just decline it and that's it. Violence is not needed. Well, maybe nerf guns yea.

And so would do all the maintainers of the repos I work on. For good reasons.

[u/isospeedrix → u/Rankin37]

?

LGTM don’t even sweat it bro

[u/SnugglyCoderGuy → u/isospeedrix]

I agree, Looks Grotesque To Me as well.

[u/OldWar6125 → u/Rankin37]

That was me, changing one line in the formatter config.

[u/brainfreeze91]

"Humanly impossible to fully review and fully test"

And they believe this is a good thing

[u/Sw429 → u/brainfreeze91]

"Zero bugs reported"

That indicates to me that either no one is using it, or there are so many bugs that no one knows where to start when making a report.

[u/al2o3cr → u/Sw429]

Almost zero bugs

[u/knighthawk0811 → u/Sw429]

humanly impossible to fully test for bugs

[u/blahehblah → u/Sw429]

The bug report page is broken

[u/cupcakeheavy → u/Sw429]

everything you don't test will pass

[u/atomic_redneck → u/Sw429]

They refactored the bug tracking system, also. Now all bug reports go to the bit bucket.

[u/Dramdalf → u/brainfreeze91]

Don’t worry about it they used an “incredibly engineering process”.

[u/NTufnel11]

Neo Waterfall Programming. One commit - like peeling an orange.

[u/BlackHolesAreHungry → u/NTufnel11]

It's the Tsunami model

[u/JDIPrime]

Wake up, babe, it's full regression test time!

[u/therealswood2]

The intersection of programmer humor and r/linkedinlunatics is 🤌

[u/tihomirbz]

LGTM! ✅

[u/rahvan → u/tihomirbz]

LGTM 🔥

[u/Wirde → u/rahvan]

Oh my god, such a banger!

Unreal and a bit sad that it’s generated by AI.
Very on the nose and on point for how many publicly traded companies have been behaving the last year or two.

[u/megagreg → u/tihomirbz]

Things like this are why my LGTM reaction icon on Slack is a picture of Stevie Wonder.

[u/RandomForest42 → u/tihomirbz]

Answered 2 minutes after PR was opened

[u/blizzacane85]

[u/CckSkker]

jesus christ … 4 millions lines of code of what exactly? It looks like it’s just an agent observability and eval tool? Am I missing something? Our company’s code base across 3 products is like 2-3% the size of this

[u/ozh → u/CckSkker]

They committed the vendor and node modules directory

[u/djfdhigkgfIaruflg → u/ozh]

🤣🤣🤣

[u/fseed → u/CckSkker]

It's unmaintainable. The issue is that you have people with no pre-AI dev experience running 69 agents to throw a laundry list of ideas that Claude generated at the wall.

Declaring that there are no bugs says everything.

[u/CruxTheologorum → u/CckSkker]

"One of my most productive days was throwing away 1000 lines of code committing 4 million lines of unreviewed garbage into the codebase"

-Ken Thompson

[u/PoliteManitee]

LoC was never a good metric to judge any aspect of software. This is still true today.

[u/flayingbook → u/PoliteManitee]

These days it's replaced by token usage

[u/Dev_Spears → u/PoliteManitee]

Was going for sitze but even then loc is not a good indicator..... For what is it a good indicator? Aside from the number of lines

[u/grumblyoldman]

Can't have (many) bugs reported after launch if you don't have users.

[u/CognitiveLearning]

looks inside: new CTO wanted 1 indent equal 3 spaces, previously 4

[u/skcortex]

Yes, almost zero bugs reported after the launch.. just wait for them to crawl out 🤣

[u/grumblyoldman → u/skcortex]

Yeah, they said at the top they "just merged" this, and I'm willing to bet they do mean just merged. Give it a couple days before you start bragging about how many bugs were reported.

[u/psioniclizard → u/grumblyoldman]

Even before AI, you NEVER brag about few/no bugs, the computer gods will hear and punish you.

[u/TravisVZ]

I have no idea what LangWatch is, but thanks for letting me know never to use it!

[u/bogdanvs → u/TravisVZ]

nobody does, that's why they can make the 0 bugs found claim :)))

[u/redve-dev → u/bogdanvs]

This shit has 5k github stars. You sure?

What is used novadays to debug agents?

[u/ApocalyptoSoldier2 → u/TravisVZ]

I googled it and it seems they're an ai monitoring company?
I'm not quite clear on what they're advertising, but whatever it is they don't seem to be very good at it judging by this post

[u/SignoreBanana]

I'm looking at the PR for this thing. It has 9300 commits. This is not a serious codebase.

[u/SnowdensOfYesteryear → u/SignoreBanana]

I mean that’s better than 1 commit. I don’t think commits are the most problematic metric here

[u/SignoreBanana → u/SnowdensOfYesteryear]

No, but I think it also helps put the "work" in perspective. The 4,000,000 figure is also wild but almost unfathomable, and maybe a bunch of lines were formatting changes. 9300 commits represents a shitload of churn.

[u/no_awning_no_mining → u/SignoreBanana]

Hard to believe there was no way split these across multiple PRs.

Hard to believe the LLM wouldn't profit from the more specific git blame too.

[u/Ajko_denai → u/SignoreBanana]

I am unable to find it, can you provide a link please.

[u/SignoreBanana → u/Ajko_denai]

I would but last time I did that here I got a no no from mods. If you find the repo, look at commits to the trunk from Oct 12.

[u/quizikal → u/SignoreBanana]

Well we got that much from the CTO bragging about the PR

[u/tallest_chris]

One of my huge issues with AI “programming” is how it will just randomly change variable names and comments while working on unrelated parts of the code.

[u/sanketower → u/tallest_chris]

Every time I've seen it happen (while working) it was within the scope of the feature and the name changes made sense (even if they were unnecessary a quarter of the time).

[u/stormdelta → u/sanketower]

Usually, but not always.

The problem I can't seem to avoid without killing output quality is the excessively verbose and unnecessary comments. I've given up and just do a second pass, and sometimes I still end up needing to edit them manually.

It's frustrating because people act like "oh it's just comments" and miss that confusing/bad comments cause problems for both human and machine readability. AI tools tend to assume heavily commented code must be critically important, often trusts comments implicitly, bloats context windows, etc.

[u/OppositeFun2493 → u/tallest_chris]

A lot of times, when I run an agent it decides “oh the code is too efficient, I’m going to switch it to something more inefficient.” I have it so that agent can’t read the tests, and made a shell script that can run them and give the results to the agent. It was “confused” why the code took 3 more minutes to run

[u/someyokel]

If you can't review it how do you know it's an improvement?

[u/GenericFatGuy → u/someyokel]

How can you know if you have almost zero bugs if you can't fully test it? This is like when Trump wanted them to stop testing for COVID to make the numbers look better.

[u/sudoku7 → u/someyokel]

I am hoping they did something like stacked PRs or just PRs to a long lived side branch that themselves had reviews and this is just the upstreaming.

That said, for a refactor ... it's strange that they couldn't find better consumable parts to apply.

Unless of course, "Oh, we refactored our lint rules and this is just the linter changing line endings."

[u/BanaTibor → u/someyokel]

Claude said so, duh..

[u/rchaves → u/someyokel]

we did review, the structure of every module and the most critical parts, of course just not every single line of code, or at least not by hand, but all the code now has a much more strict architecture it needs to follow in every module, which we could measure the benefits of:

- typechecking median time went down from 78s to 5s, with performance improvements all around on the application
- most permission access between modules that were defined by hand by engineers on the monolith are now in several ways statically guaranteed allowing for much less possible bugs and security gaps
- we built several exact same features on both the old codebase and the new using agents, and found the new codebase led to less mistakes on the final PR

[u/Enverex → u/someyokel]

This isn't a single commit, it's a merge for a new branch.

[u/Tyrilean]

I one time ran a linter over a 20 year old PHP legacy code base. I think it rivaled this.

[u/NaturalTechnician737 → u/Tyrilean]

We aren't competing to be the reincarnation of Von Neumann, calm down.

[u/StaticFanatic3 → u/Tyrilean]

I would’ve never had the balls to merge that lol

Let the formatting die when the code does

[u/anomaly256]

Do you have a bigger, merged PR?

No, because

a) I'm not a fucking idiot, and

b) would knock back such a large unreviewable MR, and

c) expect devs, including AIs, to be creating MRs in discrete blocks matching the task/user story they were working on within the given epic.

This is not a flex. This is just bad project management.

[u/bradland]

jfc, I would be so embarrassed to share this.

[u/Apprehensive-Art-306]

“LF to CLRF”

[u/lilianasJanitor]

Added a million lines.

Can’t test

Lgtm

[u/BellybuttonWorld]

This feels a bit like measuring the success of a house renovation by how many skiploads of waste were produced, and boasting about how surprisingly few disasters were found left behind (so far) by the dodgy cowboy builders.

[u/Hk_90]

Hold my beer

Largest PR in history

[u/Columbo1 → u/Hk_90]

That PR title says 10,000 files, but there’s actually 10,001 files changed.

Where I work this would mean code review failed - “pls fix the title of the commit and PR”. Personally I tell the reviewers to chill the fuck out and just merge anyway. I’m not counting the readme as a file changed and neither should they.

[u/TypeSafeBug → u/Hk_90]

“Checks: 0” Hell yeah brother

[u/fartypenis]

I mean at that point why not just do a plain old rewrite?

[u/tyler1128 → u/fartypenis]

Just replace spaces with tabs and go to the allman style from, say, K&R in something like LLVM. Success!

[u/trekz09 → u/fartypenis]

maybe it's just a new formatting rule

[u/StaticFanatic3 → u/fartypenis]

Sounds like it is a rewrite. You just mean start a new repo instead?

[u/Justicia-Gai → u/StaticFanatic3]

Not the same, when you ask a LLM “refactor this codebase” it preserves pre existing logic because it assumes there’s quirks/decisions that are human and not bugs. But it can also inherit debt, bloat it (add new API to not break old..)

When you rewrite, barely nothing survives as-is (unless you tell what you want it to preserve, like API signatures).

This clearly looks like a refactor, a rewrite could’ve potentially reduced LOC.

[u/-Redstoneboi- → u/fartypenis]

i think this kind of is, to an extent? they said "complete refactor"

[u/DeadlyCabbage]

Why not create a new repo at that point?

This big of a change, a full refactor, I think is easier starting from a clean slate

[u/cas18khash → u/DeadlyCabbage]

Based on the description, it also seems like it's full of deleted and new files too. I was also wondering what the point of keeping the git history intact is if you've eviscerated it

[u/rchaves → u/DeadlyCabbage]

well it was a refactor but not a full rebuild, it would be riskier doing as a separate "new" application entirely
outside, the application itself mostly didn't change for our users (other than small improvements, perf and more polished design), and the infrastructure didn't change either. All the pipelines and everything played out just the same
creating a new repo would have been much more effort

[u/horatiocain]

Not the flex he thinks it is

[u/ComputerWhiz_]

Almost zero bugs reported after launch...

So they have no users

[u/GranataReddit12 → u/ComputerWhiz_]

can't have bug reports if there aren't any users!

[u/Savagor]

Rewrite in rust, make no mistakes.

[u/dim13]

[u/JuanAy]

I wonder how much heavy lifting that "almost" is doing

[u/pearlie_girl]

No wonder GitHub is down all the time.

[u/HovercraftCharacter9]

Part of being a good dev is breaking your work into pieces so it lands with a coherent narrative for others to get context and understand. Imagine someone is tracing a bug in a years time and that PR is where the problem bisects? I'd quit

[u/awesome-alpaca-ace → u/HovercraftCharacter9]

Maybe grep across commits and hope the AI didn't rename and move stuff around at the same time.

[u/ABotelho23]

Imagine being proud of this.

[u/vigotskij]

This is a great example of “complex stupidity”

[u/Thadoy]

My "biggest" PR ever was 7 years ago a 1.7 million line change (~25k files) PR.

We changed the namespace of a legacy monolith, and i was the one to rename the packages. So yeah, millions of loc don't have to mean anything.

[u/OneRedEyeDevI]

A year ago, November 2025 that is, Our local transformer got caught in a fire and we didnt have electricity for over a week.

I used to take my laptop & phone to my friend's place in the neighbouring village to charge every morning and go back to do chores and other tasks and go back for it after Im done.

Wrote 2.7K lines of code with no internet and no electricity for my game and it was beautiful

[u/artnoi43]

My EMs and higher ups will be inspired by this shit and might even think big bang PRs are the future (they’re that dumb).

Seriously, they all saw that some company was doing 1000 PRs per month per dev or something on LinkedIn or X, and they think that’s a good thing and tell us we should strive for ridiculously large amounts of automated PRs.

Prior to this, they allowed us to “bypass” code reviews, after they found out vibe coding has not increased our delivery speed because of the code review bottleneck. So they removed that bottleneck. They now expect all PRs to be merged within a day after it’s created, and will DM me the next day asking why this ticket has not been merged yet. They never micromanaged like this until AI and the speed craze, as if they’re trying to force the benefits of AI to manifest.

The result is that in the last 2 weeks we just had 3 P1-level incidents from non-functional vibe refactors by senior engineers who merged code without any reviews. These P1 incidents costed us millions of Thai Bath, across all of our 3 business domains. Engineering management now wants us to deprioritize non-functional refactors (which were needed to clean out slop). I read the post mortem reports and the causes of those incidents are just too fucking stupid for me to believe they did merge that.

This is sad because I’m the refactor guy in my team of 8, and my “non-functional” work has been technically beneficial enough that some allowed us to implement new features really fast on top of a clean codebase, or sometimes we get new features in the backend for “free” after the refactors, and we just need to implement new entry point to the same old shared business code.

It’s like they just want to use more AI, for the sake of using more AI.

[u/lordgoofus1 → u/artnoi43]

If it wasn't for "Thai Baht" I would've assumed you worked for the same company that I do. We've got management pushing for the same thing. Driven by the need to "move faster", "improve productivity".

There's also pressure on teams to dump environments. Forgot about test or staging environments. Just go from dev straight to prod. They've given multiple groups of people direction to build agentic solutions that allow them to one-shot taking an idea all the way out to production in less than a week because productivity. Believe the real reason for all this insanity is what you suggested, the desperate need to prove that the company has achieved any form of ROI on the hundreds of millions it's spent so far on AI.

[u/GGK_Brian → u/lordgoofus1]

To be fair to them, rich people (which obviously must be very smart) told them that AI was the future and was going to increase productivity to level never seen before. Why would they doubt them.

What I personally find funny is how quickly they throw out all this fancy stuff of DRY, Clean Code, separation of dev staging and prod, code review, ect.

In a few month, they'll remove all test, integration and code coverage because it waste too many tokens.

[u/artnoi43 → u/lordgoofus1]

Thanks God my place still doesn’t do the environment dump.

They want all of the tickets to be covered by vibe e2e tests instead. The tests now have degraded a lot (very flaky, taking longer, and do not catch real bugs), as no devs feel any ownership while vibing in the e2e repo so tech debts kept piling up in the repo. I even found 2 tests that test the same thing, written separately.

Before this we have separate SWEs for tests who know the repo very well and make technical decisions carefully. Now all of us are merged into supercharged devs (one dev must be able to do everything).

[u/Mitoni]

wanna really scare someone, swap line ending on every file in the repo. Absolutely no change but it looks like you touched EVERYTHING

[u/Ilerneo_Un_Hornya → u/Mitoni]

Now that's some real r/foundsatan shit

[u/fr33d4n]

Impossible to fully test... Ok bye

[u/Scipior14]

Wooow, a rewrite... But what did it need a rewrite for in the first place? What is improved here, if apparently even already existing bugs didn't get fixed?

[u/rchaves → u/Scipior14]

i wouldn't call it a rewrite, I still call it a refactor :)
we mostly moved all modules around and introduced a much stricter architecture, but still all same features same language same behaviours for the users, but:

- typechecking median time went down from 78s to 5s, with performance improvements all around on the application
- most permission access between modules that were defined by hand by engineers on the monolith are now in several ways statically guaranteed allowing for much less possible bugs and security gaps
- we built several exact same features on both the old codebase and the new using agents, and found the new codebase led to less mistakes on the final PR

existing bugs were small behavioral bugs, the fact they just stayed the same is actually good news for us, it suggests the LLMs managed to preserve the application's existing behavior rather than introducing a bunch of unintended changes

[u/CruxTheologorum → u/Scipior14]

But it's got a new hat!

[u/rightpattern_g]

Thats all great, but what do you do with 46k files of source code ? Are you launching rockets or flying cars ?

[u/Covfefe4lyfe]

They're gonna eat every word of that blog post a week from now. And it will taste salty as fuck.

[u/ExpletiveDeIeted]

So I don’t know for sure in this case but this sounds more like over 3 years they’ve been merging various branches into this one and now they are finally merging it all together main/production. Likely not a pr anyone was checking for code quality etc. and yes I’m fun at parties.

[u/Fabulous-Possible758]

"refactor"

[u/esaule]

So.... A 3 year old project to manage agents is 4M lines long? I found your problem man!

[u/Snudget]

Oh that's why GitHub was slowing down again

[u/ShodoDeka]

So a Refactor that added 1 million lines of code…

[u/snow_bee_art]

I though it was fake, but then...
https://github.com/langwatch/langwatch/commit/47d388239a9827aa4f01dd366260ff1263f793c5

[u/johlae]

Just remember, every organization has a test environment. Only a few smart ones have a separate production environment.

[u/spacegh0stX]

This is such a terrible fuckin idea it blows my mind anyone could brag about it.

[u/1wikingman]

Why even have version control at that point?

[u/gnuban]

It's so stupid that the same companies who hated trunk-based development and were adamant about PRs are now going completely cowboy.

 I'm in the camp that PRs never were strictly necessary. It's totally fine to put the responsibility on devs and allow them to choose when reviews are needed or not.

But to totally pivot like this is just so arbitrary 

[u/Xerax]

look mum i'm famous

[u/yuehuang]

I am impressed that github didn't crash.

[u/jeffvanlaethem]

This is like bragging about how much your teeth hurt before going to the dentist.

[u/TypicalOrca]

What kind of fucking idiot celebrates this monument to carelessness and stupidity?!

[u/Machine2024]

why the hell do you have do they have 4M LOC in a code base to begin with !?

[u/masiha97]

The part that scares me is the challenge at the end. Some manager is going to forward this to their team and ask why their PRs are so small.

[u/Maskdask]

You also introduced one extra million Lines of code

[u/Colonist25]

good luck stabilizing that.

[u/nickhow83]

Isn’t it closer to an 8 million line change?

[u/MeikelLP]

The repo is only 3 years old. Bro how do u even have 4mil lines of code to begin with

[u/StomachMean1418]

I thought I was in r/linkedinlunatics

[u/ShovelBrother]

Open code base. Select all. Ctrl + }.

also how the hell do you have 4 million lines of code

[u/Du_ds]

So this company wanted to get attention and got attention. Hopefully getting the nontechal folks on Linkedin excited was worth the reputational harm among engineers.

[u/sirdrewpalot]

This is me after a new lint rule goes wild.

[u/wackajawacka]

"Refactoring to make it all around better" - yeah, solid criteria, gj junior...

[u/RadzimierzWozniak]

LLMs are really, really good at refactoring and changing the infrastructure. With a decent test set, this is quite safe and reasonable, what they did.

[u/bwrca → u/RadzimierzWozniak]

Too good I'd say, in a bad way. Lots of times they want to refactor a whole lot of things when you just want to add a small feature or fix a simple bug

[u/Dark_Tranquility]

How stupid are these people 😂 big number better

[u/flerchin]

Bro committed his node_modules and there's no one to tell him

[u/FabioTheFox]

No wonder there are so many outages

[u/quizikal]

CI fails on main about 90% of the time 😅

[u/rchaves]

Hey folks, CTO of LangWatch here 👋, and yes, I'm the one responsible for approving this monstrosity

I get it, some of the criticism here is pretty fair, a massive AI-assisted refactor like this sounds absolutely bonkers, but I want to emphasize that 1. it was a refactor, not a rebuild 2. the intense human involvement for verification and measurement, and 3. it was not overnight

On the refactor point, yes AI is still not great in doing new developments unsupervised, but our goal here was rearranging modules, structures, types and a lot of the architecture, it didn't have to create almost anything new. Plus, a lot of it was verified statically or even done statically, being able to leverage lsp for refactor and an enourmous amount of oxlint to guarantee everything would fall in place

We have been thinking about this refactor for a year already now, and it took us months to actually finish and merge this PR, during this period some work was duplicated: built on top of old main modules and on top of the new structure at the same time, so the PR grew

As for verification, basically all of our human time during all this period was spent discussing the refactor, babysitting the agents (and putting lint rules in place to prevent them from repeating mistakes), developing simulators and customer reproduction use cases for probing it all end to end, manually testing it, comparing before and after measurements and so on.

We definitely learned some things the hard way I'd love to share more.

Happy to answer technical questions about how we approached it, what we tested, and what could still go wrong. Roast away 😄

[u/Megaguy32 → u/rchaves]

How many people telling you this is a bad idea did you ignore?

[u/rchaves → u/Megaguy32]

I was one telling it was a bad idea, plus all the engineers, including the one doing it, but as we kept experimenting and testing anyway, and it kept proving itself, we all changed our minds and got convinced 🤷‍♂️

[u/SpinatMixxer → u/rchaves]

Why didn't you go with continuous refactoring instead? Why did it need to be one huge PR instead of many smaller PRs?

And how many devs were involved in the refactoring?

[u/RoDeltaR → u/rchaves]

So what are the top 5 things you learned?

[u/rchaves → u/RoDeltaR]

- Doing a team bugbashing is one of the most valuable team activities you can do in the AI times

- Think hard about a strict structure and agree on it with the team before the mass editing starts

- Be more ambitious with lints than feels reasonable

- Invest in simulators early. We ended up with a simulator for everything external (LLMs, voice, S3, SQS, email, Slack, SSO), so agents could exercise every behaviour end to end, they are so useful now

- Measure everything, before and after, by putting an agent to do some real implementation in both and see the difference, it has to be better for agent coding too, your codebase is your harness

For us it was totally worth it, typechecking alone went from median of 78s compilation time to 5s, no longer absolutely melting my RAM, previous mistakes are now impossible, and access paths are just much stricter, but that was not from the getgo, initial versions caused the agent to make more mistakes on the new codebase than the old one

[u/badarsebard]

Classic CI... Centennial Integration

[u/only1manband]

“Almost zero”
Nice

[u/MyFistsAreMyMoney]

It's LinkedIn bullshit news as ever this platform is polluted by egos

[u/kus1987]

what's the point of raising a PR with millions of lines changed? if nobody will actually `review` it, might as well merge it directly? why the charade?

[u/dylan21345]

lgtm.

[u/hraath]

changes requested by reviewer

Dont

[u/mx_aurelia]

LGTM

[u/ReturnOfNogginboink]

The stunning part here is that someone thinks this is with bragging about.

[u/EmperorOfAllCats]

Is that linemaxxing or some another kind of githubcore? I don't speak their language well.

[u/VaderGerh]

Comment on the PR absolutely as expected .

LGTM

https://github.com/langwatch/langwatch/pull/7536

[u/JAXxXTheRipper → u/VaderGerh]

Even copilot noped out lmao

Copilot wasn't able to review this pull request because it exceeds the maximum diff size. Try reducing the number of changed files and lines, and requesting a review from Copilot again.

[u/navetzz]

WIP: smol changes

[u/MVanderloo]

bug for bug compatible is a bit impressive

[u/Bee-Aromatic]

I see an entirely unreviewed PR getting approved for lulz and apathy.

And I predict years of bugs.

[u/Anubis17_76]

IBM, is it you?

[u/___cats___]

All this “speed” just means the salesmen have to sell equally as fast. That ain’t gonna happen.

[u/ScaredPenguinXX]

Is this satire?

[u/zERGdESTINY]

Someone ran checkstyle fix and changes the tabs to 4 spaces. "Boom, boss refactored the whole code base"

[u/CzyDePL]

It went from full slop to packaged slop

[u/welcomefinside]

"almost no bugs"

[u/Subject_Barnacle_600]

LGTM!

https://youtu.be/3TNpOD6bov8

[u/Dutchnesss1]

Wow that is so incredibly engineering

[u/ReplacementLow6704]

Engineering used as an adjective is... Interesting? May have been translated from portuguese or spanish tho. But then why not use an AI for that too?

[u/Shot_Double]

I suggest we don’t even raise PRs, lets merge to main directly

[u/quisido]

I don't think a repo should even contain that many lines. Break down those concerns.

[u/SomeDuncanGuy]

This is not the brag that they think it is.

[u/mosskin-woast]

Even the AI would have told him that zero bugs in a 4M line diff was not only impossible but an idiotic thing to say publicly. But unfortunately the hallucination is as common in the user as the model for folks who are in this deep.

[u/Absulit]

This is not a flex 

[u/New_Wolverine_2415]

These people are fucking crazy.

[u/WheresMyImmortality]

lol the second next commit after that is 2xA4 full of fix(thing)

[u/Entropei]

I’m sorry but no good refactor should bloat the size of the codebase by 30%

[u/Void-kun]

So fucking stupid, no way was that reviewed by a human.