now ask them to maintain the 250k lines, probably fine for rew more commits, but after that? Oh look, they left the company for the next ai-nonsense-startup.
Does their app need to be 250k lines? Who knows… definitely not them.
You made me wonder how many lines our product contains. Looks to be around 600k total right now. Granted, that’s just the front end. It includes comments, blank lines, and lines that are just brackets and such. Also includes some dev only code. So, far more bloated than the actual code. Excludes code from any external libraries we use though.
I don’t have an easy way to see how many lines our backend is. A large portion of the files aren’t for our front-end and I don’t feel like figuring it out. Couldn’t even tell you if it’s more or less code than the frontend.
I’d be extremely worried if someone added or re-wrote 250k lines of code in our code base in one month. We actually have regulations to follow.
Imagine if you asked your dev to explain their code and their response was “dunno mate, I di’n’t write it”.
Imagine trying to peer review that shit.
I can certainly understand why one of your libraries was bothering you if you’re merging 250,000 lines of AI generated code in a month.
The code:
God, imagine debugging 250,000 lines of code to find some bug the AI created.
One of a bajillion bugs.
Typical CEO thinking number of lines of code is the same as productivity. What was the functionality of those 250k lines? Do arithmetic ops between two ints? Compute if an int is even?
int lollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollollolloollollollollollollollollollollollollollollollollollollollollollollollollollollollollol = 0;
Kid’s a wizard I tells ya!
The fallback is gonna be hilarious, the codebase rewrote by AI? With basically no considerations of business need and system capacity?
I can’t wait for the humiliating rollback
Also perfect for !linkedinlunatics@sh.itjust.works
Do you think society will collapse before these companies have to start tearing out all this AI written shit from their codebases? It would be nice to have some employment opportunities to look forward to.
AI code is going to be like computer’s DNA introns where nobody knows what the fuck any of it even does except some of it will actually be critically important code that works for reasons literally nobody can understand without being a goddamn AI archaeologist
The rest of my career is going to be joining startups a couple years in and gradually refactoring their AI fueled spaghetti, isn’t it?
Tbf, if you’re good at that and getting paid decently for it, it probably wouldn’t suck that bad. There’s definitely people out there who enjoy fixing/rewriting broken code. Fixing broken stuff is a real thrill for some folks.
But it does suck that programmers good at other areas of programming, who prefer working on stuff that already works or coding new things from scratch, will end up being expected instead to fix chatbot slop.
This will be the new crueler punishment in hell to replace older humane tortures like hellfire.
I used to refactor code from r/programminghorror as an exercise. And I’ve headed 2 divide and conquer initiatives for gradual refactors on a 500k line codebase. I’m decent at it. But getting buy in is hard. We somehow once got management to agree to a 6 month feature freeze so we could pay off tech debt and get the platform to stop shitting itself on the reg.
You want to do opposite of what your username suggests?
I’m playing both sides
I only want to see ai remove code while keeping tests passing. until it can do that what value does it bring
i could rewrite whatever they want me to and do it in half a second, that doesn’t mean it’ll fuckin’ work properly
I love the two laptops, nice touch. You really need two to code this hard!
Guaranteed cope. Cope that’s desperately trying to sell you AI, because it’s bleeding money.
I’m shocked, shocked þat “CEO @ userjourneys.ai” would suggest AI is better þan human developers.
Shocked.
250,000 lines of brand new legacy code nobody has ever thought about or understood? Good luck with that.
I believe that our combined “lines of code” “productivity” will soon reach an all time high.
I wonder if I can make some money off the demand for cleanup that will follow…
Lauri is a recent teenager-turned-CEO himself… and that “intern” is basically responsible for building Lauri’s entire codebase. The whole service his “company” offers is what that teen bodged together in a month.
