Saving challenging projects was my niche, but AI codebases are making me miserable
Posted by HedgehogFlimsy6419@reddit | ExperiencedDevs | View on Reddit | 241 comments
I've noticed that most people focus on rapidly developing new features with AI, but barely anyone talks about maintaining this hot piece of garbage.
I am sharing these thoughts to see if anyone else has had a similar experience.
Over the years, I've built a reputation at the companies I've worked for as the guy who gets thrown into "we don't know what to do anymore" projects, the person who dives deep into production issues, plans gradual refactors, and in general improves projects with a lot of tech debt. Dealing with codebase clusterfucks and hot potatoes has been my niche for years (and it paid really well).
It was demanding, but AI has taken it to another level of awful. It is at the point where I'm actually considering switching careers, because most of the new projects are literally required to be vibe coded and everywhere I interview it seems to be the new standard - you either use AI, or bye bye.
Human-written clusterfucks and spaghetti codebases still have SOME signs of a human thought process. No matter how wrong it is, there IS a path. Until recently, I was always positive that the rabbit hole had an end. There was an immense amount of satisfaction that came from progressively discovering someone's thought process as they went down the wrong path.
AI-written codebases, though, are just completely incomprehensible to me and make no sense most of the time. They are completely unpredictable and act like a triple pendulum. It’s really hard to describe the experience of diving deep into one of these.
The best way I can put it is: AI-generated code is like a thousand people were assigned to a task, and for every single line, the current writer just passed the task to the next person. There is no plan, architecture or underlying logic at all. The code doesn't feel built with purpose; it feels like just a big collection of fragments that happen to be in the same place. It’s... just there, sometimes completely unused.
Maybe that is the endgame of these agents. AI companies want us to rely on their products to debug this mess and learn what the code actually does. I’ve found that using AI to fix these codebases is basically a requirement at this point.
And that’s what bothers me most. The job was already difficult, already full of imperfect human decisions, already mentally demanding and already full of messy realities. AI just made things 10x worse from my POV.
Maybe I'm overreacting and I just "have to adjust". I'm not completely against AI, I use it as well for quick prototyping and generating boilerplate, but I review every single line and make a lot of adjustments. Most of the people I've worked with in the last year though seem to just not care anymore. They commit whatever AI generates, no matter how convoluted it is, and when asked about their solution they don't know how it even works, because they didn't even bother to review the code. It's just lazy.
Roidot@reddit
You are not supposed to manually look at AI-code. If it does not work, update specification in markdown, and re-generate. Repeat until working.
Lucifernistic@reddit
I found it's a lot easier to keep well architects and structured codebases with AI, personally. With the right precommit hooks and architectural guidelines, I'm able to safely refactor and build code that is higher quality and more maintainable than what we get from our average devs.
KitKat_0228@reddit
The cleanup work on ai codebases is brutal because like you said theres no thought process to trace back. one thing that helped me is using glm-5.1 for the refactoring work since it actually traces through the logic across files instead of just rewriting blindly. doesnt fix the root problem of people shipping slop but at least makes the cleanup less soul crushing
Stellariser@reddit
The way LLMs work isn’t even that they pass the next sentence on to someone else, or even the next word, it’s each token that’s being generated one at a time, and then you run the whole process again with that new token at the end and get the next token, etc., so it’s like each person writes a few letters and then passes it to someone else.
VP-of-Vibes@reddit
The skill you built was reading the accumulated decisions in a codebase. Finding the logic, the constraints, the debt. AI-generated code has output without authorship. There's nothing to read between the lines because nothing was written between the lines. That's a genuinely new kind of hard.
VP-of-Vibes@reddit
Human bad code has archaeology. You can read the commits, find the developer who wrote it, trace the decision that made it worse. The reasoning is preserved in the mess. AI-generated code has no author to interrogate. No decision was made — a probability was sampled. Every refactor starts from an absence.
laueos@reddit
Yes, from appreciated expert to “old man yelling”: “I told you so”. Not solving actual challenges, but cleaning up after others. And so much could be avoided. Feels like carrying load that others are too lazy to touch.
Prize_School3346@reddit
sounds frustrating but maybe overthinking?
laueos@reddit
Just a general principle about how the world works. Like employees doing the glue work without getting the appreciation while others report quick wins and get the promotion. There was some natural gatekeeping in software development because effort and hard earned skills were required, but the world caught up. I have empathy for those with some kind of grief. And I fully understand some want to give up and leave this new normal behind. Depends of course on how things are going in your specific work environment.
another_dudeman@reddit
I wouldn't be so quick to call this the new normal. Plenty of people aren't wholesale fucking up codebases.
DependentOnIt@reddit
This is certainly going to be the norm unless the AI genie goes back into said metaphorical bottle
laueos@reddit
In an ideal world I’d hope for people to learn and grow, it in many areas it is normal that some mess up and pretend while others care and clean up.
Downtown-Camera-1469@reddit
definitely feels like the craft is being lost in all this chaos
CSAtWitsEnd@reddit
Part of why LLMs are seeing such adoption is a bunch of people without skills and the knowledge to discern the difference between good and bad creative output can now mass-produce the bad output.
The craft is being lost because the people embracing it are not interested in the craft at all. Which is also why there’s such a backlash - their desire to be rewarded in creative spaces is at odds with their lack of respect for those very spaces and the underlying skills and knowledge.
laueos@reddit
Isn’t that a general problem? Fast food vs. cooking, cheap clothing vs. high quality etc. It just now happened to become possible in software as well.
chefhj@reddit
I tend to think of it more as stone masonry on a building. As a society we have decided to set aside gargoyles and shit in favor of smooth glass and metal.
TribeWars@reddit
Nah the smooth glass and metal in this analogy is something like the framework-ification. AI codebases are completely incoherent, if we built houses like that, they'd collapse. It's the Chinese ghost city skyscraper where the balcony railings break off if you lean on them.
chefhj@reddit
The metaphor I was drawing on was that we are losing “craft” in favor of shit that is more cost effective to build quickly even if people widely bemoan the loss.
A frontend framework would I guess be more like a local building code in this analogy but is not the point I’m trying to make at all…
laueos@reddit
Which mirrors the society. In the case of balcony railings: What is a single life worth?
MoreRespectForQA@reddit
The difference is that software scales infinitely. It doesnt necessarily matter if you can vibe code 50 high speed rail systems which "kind of" work for pennies if what you need is one which is guaranteed to work.
Izkata@reddit
Comparing manufactured goods wasn't quite right anyway. That's more akin to software distribution than to software development - the same template used over and over is more like copy/paste of a completed product than anything else. Development is more like the design process, and shirts aren't getting designed from scratch for each individual one made.
laueos@reddit
You talk about where actual engineering happens. Most software developers don’t work on that level.
Working_Noise_1782@reddit
From and electrical eng view point, you guys were doing it to us with HDL vs software. Back in the 90s everything was HDL regardless if it was on a FPGA or real logical circuits. Then came assembly vs compiled c/c++.
It seems more like the layers are collapsing and merging into fewer.
Has a firmware eng that works on bringing up the first prototype of our PCBs, I have to deal 50% code, 25% logical hardware, pure analog.
In the end, looks like electrical engs are wining from AI. Most of the damage to our profession was already done by software engs trying to replace us with their high level languages.
My job will remain, because they need someone at the periphery of code and hardware. You cant automate that very easily.
MoreRespectForQA@reddit
Until the people who go "if you dont use LLMs youll be a left behind relic" start feeling actual shame I think the output of our profession will continue to get more crap.
SnugglyCoderGuy@reddit
If LLMs get better, then they will ostensibly be easier to use so the effort to 'catch up' will be less in the future than it is now.
subma-fuckin-rine@reddit
i dont even think its that, its more like corporations dont want to pay high salaries for devs. until now it was fairly specialized and now AI is making it not nearly as much. the barrier to entry is way lower. what i can see ending up happening is teams will be 1 real software engineer and 5 or 10 "prompt engineers". they pump out tickets with AI while the one actual dev handles architecture and deep diving problems
Ratiocinor@reddit
Yeah this is absolutely it. Good and bad developers existed before AI of course. Our field is so abstract it's hard to immediately tell the difference between good and bad devs or code
But even bad devs were forced by sheer brute force and trial and error to eventually learn at least some good practices against their will over time. Even if they didn't care about their craft or learning at all it just wasn't possible to make it to senior level without picking up at least some stuff by osmosis
Now though the genie is out of the bottle and it's never going back
I am done reading delusional posts about how one magical day in the future companies and management are going to realise the error of their ways and we're all going to be rehired on triple salary to "fix the mess" and have jobs for life. It's not going to happen. They will just double down and get the AI to fix the AI, or eventually start rehiring juniors and just throw more juniors at it (who will of course use AI)
This is like the perpetual cycle of tech and it's hilarious to see play out time and time again. Every generation thinks they are the last true devs and they are irreplaceable, but every time they just replaced by eager new young people who adopt some new technology instead
COBOL devs said "you know they're not hiring and training any juniors to replace us right? We've got jobs for life dude we're gonna be so rich". Reality: They were just replaced by C++ and C# juniors who re-wrote everything from scratch
C++ / C# devs said "you know they're not hiring and training and juniors to replace us right? We're the last to write code by hand without AI! We've got jobs for life dude we're gonna be so rich". Reality: They were just replaced by vibe coding AI prompting juniors who are re-writing everything from scratch as we speak
Suspicious_Bed_8261@reddit
what inspired you to write this part about the unexpected turn
60days@reddit
It’s a transition. The old methods settled in over decades, and we’re just starting on this one.
laueos@reddit
The craft is moving. Like with cars: can’t repair as much yourself anymore. Doesn’t mean the craft is gone. Engineers are still designing these systems.
MrDilbert@reddit
This is more like, everyone has an ability to build a car now, but they don't understand how the parts connect to each other or what's their purpose, but it's fine as long as it works. And then their car breaks when it has to go 3/4 of the way through a roundabout.
laueos@reddit
To make a car “work” and even drive to the roundabout you need to get quite a few things right. 🤔
MrDilbert@reddit
"You" have an "agent" that does it for you today.
laueos@reddit
Is that much different from putting together the components of IKEA furniture?
MrDilbert@reddit
Yes, because when you put together the IKEA furniture, you know what each part connects to and it's function, at least to a point. This would be more like buying the furniture for the whole house, with assembly and placement done by the seller's handyman team.
another_dudeman@reddit
It's early and lots of people are carelessly fucking shit up. Others are taking the time to be professionals.
laueos@reddit
Why are people buying crazy cheap stuff from overseas? Because they don’t care, they’ll throw away. Code has become cheap. Doesn’t mean it’s good. But being careless and messing up is so affordable that many will fall into the trap although “to buy cheap means to buy twice”.
garlicNinja@reddit
That's the point.You ever hear about the industrial revolution and what that did to craftsman.
Gazelle-Unfair@reddit
Heh! I'm changing my LinkedIn job title from CTO, aka "appreciated expert", to OMY "Old Man Yelling".
laueos@reddit
“I give reason a voice.”
Glad_Butterscotch151@reddit
what inspired this topic
AllTheWorldIsAPuzzle@reddit
Same. I have the same rep of being the person to look at processes that don't work and figure out what is happening, but it has now multiplied many-fold because people that used to be too incompetent to produce a working solution before are now producing MANY non-working solutions.
In the AI fervor management seems to have forgotten that 95 percent of the work happens in the last 5 percent of the project. Where I work, people that couldn't think and produce before are now building projects by plugging in documentation and AI is producing code they don't understand, and management is eating their "productivity" up. In the meetings they crow about their productivity and then throw in the caveat, "some validation still needs to be done".
And the "validation"? Numbers and counts are many times off from the original system they are comparing back to, but they did their hard hard work of telling AI what to do and now they can pass that on to the guy that figures the problems out. So I get stuck trying to trace AI generated code trying to figure out where the breakdowns are while they move on to new fun stuff to screw up.
And for anyone that thinks I am ripping AI unfairly? I am using it to generate code that I then test and ACTUALLY validate. I have lengthy discussions with it while looking at the code (understand code... crazy, right?). I mean, I have to because it's not like there is anyone for me to pass my "validation" work off to. And I use it when trying to diagnose the slop I have to figure out that is wrong, because while the idiot that fed in documentation has no idea what they were doing, the AI has at least some insight.
Practical-Piglet-933@reddit
You’re not imagining it—AI just removes the discipline humans used to impose on code, so messy teams produce even messier systems.
The shift for you is from “fixing bad code” to “enforcing structure on AI-generated code through reviews, standards, and ownership.”
Hot-Profession4091@reddit
Hot take: It has never been easier or faster to rehabilitate a bad code base thanks to AI. It can generate diagrams and documents based on current state faster than I ever could. It can write characterization tests faster than I ever could. Refactor faster. Rewrites are fast enough to be possible now.
It just takes an experienced hand, like yours, to guide it.
fuckoholic@reddit
Nah, it can't do any of that. It can't refactor well, because it does not know how you want to have it and you don't know it either, because you don't understand the original architecture.
The only thing it's good at is explaining the code.
Hot-Profession4091@reddit
Oh no, you have to actually tell it what to do because it’s not sentient. Skill issue.
New-Locksmith-126@reddit
I can tell by your replies that you've never worked on a complex system.
Hot-Profession4091@reddit
lol. You’d be very, very, wrong.
New-Locksmith-126@reddit
if you think AI can one-shot refactor complex distributed systems you're telling on yourself.
There's more to engineering than prompting.
Hot-Profession4091@reddit
Who the fuck said anything about one shot refactoring complex distributed systems? I sure didn’t. Don’t put words in my mouth. It’s rude.
New-Locksmith-126@reddit
Fair enough. I'm sorry about had.
But you're alsodropping "skill issue" in the comments.
If you're saying you can use AI to help refactor a large system, well, that's obviously true. But you actually need to know what you're doing AND you need to review every step of the way.
Many people here are just pointing out that unsupervised AI will fuck things up. I see it every day. I was wrong to assume you were inexperienced, but I think you're wrong to think the other people here just need to prompt harder.
I think most people here are worried about what the bottom ntile of devs are doing to the codebase they work on.
Hot-Profession4091@reddit
I mean, it literally is a skill issue. The serious among us have had time now to learn how to use the new tools effectively and how far they can be pushed. We’re not yet to a place where we can just let these things fly on their own, but guided by an experienced hand they are a serious force multiplier, which was kind of my whole original point in my original reply.
It’s fair to be concerned about what the sloppiest and laziest of us are doing. These things give us much more of whatever we were producing before. Sloppy devs are now generating 10x slop. On the flip side of that, a disciplined dev can repair a sloppy codebase 10x faster than we’ve ever been able to before.
New-Locksmith-126@reddit
I think I agree with everything except the last sentence. It's always easier to break something than it is to rebuild it. The problem I see is that business dependencies build up around crap designs. Yes AI makes it easier to rearchitect, but it doesn't convince stakeholders why that's necessary. A lot of people will get hurt before the rewrites ever get started.
Hot-Profession4091@reddit
Possibly.
I just know that I’ve already used it to rehab several sloppy codebases. Some were handwritten and essentially abandoned until we needed to make some updates. Others were essentially entirely vibed just this year. I know it’s anecdotal, but the sheer speed in creating characterization tests alone was a game changer for legacy rescue.
fuckoholic@reddit
I'm sorry, you lost me. How can you know what to do, if you have unreadable mess on your hands?
The reason I know you are full of s is because I use all three big models daily. They don't know how to refactor well, create a lot of indirection. They don't even know how to abstract well at all.
You will just have swapped one spaghetti with another. You will not be able to tell if what is new is better than what was before, because you don't even know what "before" is.
Hot-Profession4091@reddit
polypolip@reddit
How confident are you that the diagrams are not hallucinations? What's different from using a normal code-to-diagram tool on the codebase.
Substantial_Toe_411@reddit
As long as you are within the context window of your query LLMs are *very* good at parsing code. Code is structured and unambiguous and this works very well with LLMs. It's the other way around (Human language -> code) where you see most of the hallucinations.
New-Locksmith-126@reddit
they're not "parsing" anything.
Substantial_Toe_411@reddit
You’re right, they are not parsing. Wrong word to use. It’s just statistical pattern matching, which works better for highly structured inputs and outputs.
polypolip@reddit
I've seen some Claude hallucinations over or codebase.
Still, why use LLM instead of specialized tool?
Substantial_Toe_411@reddit
The tool you’re proposing (code -> diagram) like mermaid or plantuml still needs something to generate the code that gets rendered to the diagram. Typically that’s an LLM so this proposal doesn’t solve the issue. To get something closer to deterministic you’d have to parse your code using something like https://tree-sitter.github.io/tree-sitter/ and export that data via MCP to an LLM. So an LLM would gather information from your codebase from the tree-sitter MCP and then generate a diagram. There’s still an LLM in the middle coordinating this so there’s still always a possibility of hallucination. But like it said it’s usually very code about reading code. I do agree that it still misses things, but for analysis purposes you just need to review and inquire why it failed to find the missing pieces and add context directly in the code base so that the next time the LLM is queried it will do a better job.
polypolip@reddit
What kind of diagram are we talking about? Because if I see anyone generating a class diagram using AI I'll dropkick them.
_predator_@reddit
Why not use the LLM to use the specialised tool?
/s
ZackWyvern@reddit
Unironically. Just tell it to use the tool. If it doesn't exist, have it write the tool.
polypolip@reddit
> Just tell it to use the tool.
Have we reached that level of laziness and/or stupidity?
not-halsey@reddit
Honestly it needs to be a twofold thing. Claude can follow function and dependency chains, retain the info, and identify their purpose far more efficiently than a human can. I think that’s useful for identifying and documenting intent. But you also have to use that knowing there’s a chance there’s a bunch of inaccurate info in there. Verify what you can, and keep a living documentation moving forward
That’s how I’d do it, anyways. I haven’t worked on a big enough AI generated codebase to justify doing that yet
JuanAr10@reddit
As with any LLM - there is a probability it is OK - and another probability it is a hot mess.
Mostly, from what I've seen, it is correct while at the same time mixed with a lot of crap.
ZackWyvern@reddit
By reading them. How else?
polypolip@reddit
So you waste more time than with a purpose built tool?
Hot-Profession4091@reddit
As confident as I am that I didn’t misunderstand something when coming in cold and investigating an undocumented codebase.
wyldstallionesquire@reddit
You have to check and validate as a human. But joining the hot take, with a little bit of care reminders not to guess, etc, AI tools do genuinely often get you a lot further than you could with previous automated tools.
So_Rusted@reddit
the problem is you can make the code look like it is good code but still nobody knows what its for and what it does
Hot-Profession4091@reddit
Humans can do that completely unassisted by AI too.
People need to stop blaming the hammer and start looking at the craftsman.
Venthe@reddit
You are absolutely right. Unfortunately, with LLM's we have a tail wagging the dog situation. The tool is actively making the developers worse; while producing a junior level, unmaintainable output.
Hot-Profession4091@reddit
If you’re getting Jr level, unmaintainable output, that is on you, the craftsman.
Venthe@reddit
No, I am not responsible for the output of an LLM. I'm responsible for the outcome of my work regardless of the tools I'm using.
And if the topl is incapable of producing good abstractions, encoding the domain, architecture and generating a code that can be maintained over the years; that's on it. And as hard evidence proves, no amount of CLAUDE.md, SKILLS.md and guardrails can mitigate that.
But hey, it's literally the job security for me.
Hot-Profession4091@reddit
But you are responsible for the output of an LLM. Like a human, its output will only be as good as the context you provide it.
Venthe@reddit
And the content it was trained on. And the bias that was baked in during the training. And the fundamental limitations of the tool.
It does not think. It does not reason. It does not understand. Context can only approximate that; and it does that quite poorly - on a junior level. Please don't equate amount & speed with the quality.
Hot-Profession4091@reddit
Well, it’s a good thing I’m not doing that.
MindlessTime@reddit
I think it can speed things up and be used responsibly. What I’ve experienced, and what it feels like OP is getting at, is the pressure to go 110% hands-off yolo vibe code having the agent do every thing is so pervasive now. Doing it the right way using AI still takes manual work and time and that is seen as inefficient and antiquated and a reason for firing you. It’s like the high-velocity slop is the expectation and anything more refined is seen as a waste of time.
Hot-Profession4091@reddit
Ok. Sure, I guess? I don’t see how it’s different from folks trying to tell me not to “waste time writing tests”. I wrote them anyway because that’s what gave us better results sooner.
itsgreater9000@reddit
I have a coworker who generates tons of docs about rearchitecting the system and every document is filled with giant holes that I would hope had he been writing the document entirely himself, would likely not have been generated. At this point I just don't trust the AI because our legacy codebase is so bad at having any consistent patterns that it became a mess.
Hot-Profession4091@reddit
Yeah, except that’s not what I’m talking about, is it?
BoringBuilding@reddit
The same careful hand is needed during doc and test generation which is why you end up with outcomes like this, generally an even more careful hand than test generation.
Do you find that the docs and tests you have AI write are of the same quality of your coworker, if you are doing so currently?
Was this coworker previously writing solid code/tests/documentation and his quality has suddenly plummeted?
It sounds like it could be more of a coworker problem than an AI problem.
__calcalcal__@reddit
Sell yourself as the one that can create the validation process in the ai-development loop. Tests, linters, and other code analyzers that are enforced in the CI/CD. Once you have enough e2e and integration tests, you can refactor the spaghetti code in a good piece of work.
What do you think? Is it doable?
HedgehogFlimsy6419@reddit (OP)
Spaghetti code, linting, type safety, formatting - these are not really the problems I’m talking about. I know how to plan and execute major refactors, and I already did this many times. I’m not stuck or looking for technical solutions here.
The real issue is that fixing this kind of code takes so much more effort than cleaning normal human-made mess, that it makes me question whether I’m still fit for this career. Fighting against laziness drains me very fast and leaves me feeling miserable and hopeless.
Refactors, architecture rules, or better processes will not solve the main problem - the laziness that AI seems to introduce in a lot of developers.
People feel it’s acceptable to generate a lot of low‑effort code just because there is a styleguide in CLAUDE.md and Opus tells them their idea is absolutely brilliant and that they are geniuses. Your engineering lead complains? Don’t worry about him - you’re the genius here.
I have never been so frustrated with my job as I am now. I can make teams execute a refactor, but what is the point if it the time needed consumes all the benefits of “going fast” and next week they try to push more AI‑generated garbage again?
The problem is not the code, LLMs, model choice, or tools. The problem is how easily engineers and developers gave up caring about quality and gave in to laziness.
Western_Objective209@reddit
the failure patterns are easily understandable if you understand how the tools works. you'll see parallel implementations of the same pop up everywhere if no one is paying attention. giant modules that keep growing if people don't keep subsystem boundaries clean. poor testing, giant functions and objects. all these can be easily refactored if you just learn to use the tools and recognize failure modes.
you can say it's actually slower all you want, but it's just not true based on the way the industry is going. you can call people lazy all you want for not doing things the way you're used to them being done, but again they aren't lazy, they are going to be working much faster than you. just because you're not used to the failure modes now doesn't mean you're right and everyone else is wrong
Tiny_Ad_7720@reddit
Problem is the devs writing the slop don’t even realise it is bad
They aren’t working faster, they are just writing shit code that mostly works and making it someone else’s responsibility to clean up.
Western_Objective209@reddit
writing shit code that mostly works for someone else to clean up is what software dev has always been. like what are you using to gauge that it's not faster? because by any measurable metric it's much faster
ProbablyNotPoisonous@reddit
I mean I guess if your aspirations don't go any higher than shit...
Western_Objective209@reddit
whether code is shit or not depends on the person working on the code base, not the tools they use
ProbablyNotPoisonous@reddit
Of course. I just find it the thought "AI produces shit, but that's ok because we've always been producing shit" to be a little defeatist :P
Western_Objective209@reddit
okay but that's not what I'm saying; I'm saying the devs that produce shit with AI would have produced shit without AI too
ProbablyNotPoisonous@reddit
?
Western_Objective209@reddit
???
HedgehogFlimsy6419@reddit (OP)
What are you using to gauge that it is faster?
Western_Objective209@reddit
just watching people who have adopted vs people who haven't. I work with a lot of SWEs, read a lot of code, run a few projects, write a lot of code.
KPIs are never great, but personally I can read and write code an order of magnitude faster. I notice people who use AI can onboard much more quickly, they can handle more complex tasks with less hand-holding, and have a higher velocity based on number of PRs and PR complexity.
I mean I still read the code, if it's AI trash where they are casting everything to Any rather than updating contracts or writing the same code in multiple places or making a giant function body with 50 different responsibilities, it's still easy to spot and I make them change it
HedgehogFlimsy6419@reddit (OP)
Funny because I’m in a similar position and see the opposite. Maybe it comes down to the domain, idk.
Western_Objective209@reddit
are you actually allowed to use AI tools integrated into your dev env or is it people copy/pasting into chatgpt because they are clueless?
DerelictMan@reddit
Which model(s) they are using and what tools makes a world of difference. I had a coworker who was very down on AI for weeks, and then he made a comment that revealed he was using Copilot in code completion mode only, compared to the rest of us using Claude Code w/Opus 4.6. I was like... no wonder! There's a night and day difference.
Western_Objective209@reddit
hah yeah I could see that. I have spent the last 10 years of my life working in jetbrains IDEs; I loved the code navigation, debugging, linting, test runners, like truly I was a master at using it. I have not touched it in months; I just use CLI tools and claude code. I can imagine how hard that is for people who don't like change, but it's just a different way of developing software that makes reading/writing code trivial, when everything about dev environments before was to make reading/writing code faster to make up for human limitations
DerelictMan@reddit
I'm using CC's CLI via the IDEA "plugin", which really just runs it in the terminal window. It allows it to see what file is in your active editor tab, as well as what lines you've selected, but that's available even if you just use the plain CC CLI. I still use IDEA quite a bit, they are orthogonal in my opinion. I like to occasionally refactor CC generated code by hand, if nothing else to keep the muscle memory active in case this crazy AI world gets turned on its head in some way.
Western_Objective209@reddit
yeah intellij refactor tooling alone is really great. I've mostly just built my own code observability tooling and read the code through gh pr interface, but I have seen people who prefer CC in VS Code/intellij, so that's fair. I just like sitting in the terminal, using CLIs, and using nvim better than an IDE I guess
HedgehogFlimsy6419@reddit (OP)
We are allowed to do whatever, even sandboxed MCPs, use the latest models(Sonnet, Opus) and have a lot of freedom in general.
Western_Objective209@reddit
okay. I seriously want to see an AI coder vs "natural" coder competition, like a hackathon. I'm like 99% sure the AI coder would be able to build a better, more ambitious, more feature rich piece of software given the same time constraints.
HedgehogFlimsy6419@reddit (OP)
Hackathon software is not meant to support a business for the next 10 years. You’re talking to a wall. Hackathon approach works for hackathon and noone is aruging in this post that you can't reach POC faster with AI.
Western_Objective209@reddit
it's measurable. I can see the software my team builds, where everyone has claude code/opencode and uses it, and the teams who are just raw-dogging their IDE with maybe copilot. we add features and fix bugs significantly faster, everyone can tell, even in the business units. There's no measurable increase in defects, because I read the code before merging, just like I did before.
I only brought up a hackathon because it's something that can be open and staged, not just the vibes people get from their workplace
corny_horse@reddit
People with major rose colored glasses on about some fictional path where corporations weren't pushing half-baked Java applications constitute bulk of software engineering for the last 30 years
Western_Objective209@reddit
lol I've worked on so many of these, literally seen features thrown in the trash because the person who wrote the java monstrosity 10 years ago was long gone and nobody knew how to run it or where the source data came from anymore
corny_horse@reddit
Yeeep. Substantial part of my career has been maintaining/migrating off these systems.
Tiny_Ad_7720@reddit
Much much faster to a POC, but not necessarily faster to production. There is a lot of slop debt that adds work later in my experience. Of course, experienced devs use the tools much more effectively…
Western_Objective209@reddit
yeah, I would argue the people who can't get it to production with AI also can't get it to production without AI, the user probably matters even more because the coding bottleneck is largely gone
ImportantSignal2098@reddit
Excellent observations. You're right about them pushing more garbage right next week, and the primary reason for this is that this is enabled by the leadership. Previously terrible "move fast break things don't think" coders were somewhat contained. Now not only do they have a magic tool in their hands that can 10x their garbage, they're also actively encouraged to use it by the leaders, and their "achievements" are celebrated, anyone pushing back is "slowing everyone down". I think you're enjoying the direct consequences of this "synergy", this will be increasingly widespread and lots of more reasonable devs are on the fast path to misery and burnout. Where do you see yourself in 5 years? Bwahaha
turboronin@reddit
I have this theory that in a few years, when critical systems start to fail and no one understands what the fuck is going on in the codebase, grizzled developers will be brought out of retirement to fix the mess and prevent global meltdown. Could probably make a movie out of it, lol.
ImportantSignal2098@reddit
It's a good dream that many other Redditors expressed, but the reality is that we have no clue where the world is going, and dreaming can get in the way of making rational decisions.
AConcernedCoder@reddit
Maybe. But assuming that the pushers of this new wave of AI never managed to succeed where generations of researchers, philosophers and thinkers failed to crack what intelligence is, meaning that AI isn't, and will never live up to its name, then AI as it is being presented is more of an addiction to orgs. I'd expect this to follow something that resembles the cycle of drug addiction. Some orgs will figure out how to navigate this. Others won't turn around unless they've hit rock bottom, and survived. Eventually the script will flip, maybe not in favor of devs, but the narrative of survival in this industry will be one of orgs ridding themselves of the bad practices causing these problems and the people pushing them.
ImportantSignal2098@reddit
It seems you might be conflating AI with AGI. Applications of AI are already pretty scary in terms of job displacement. This doesn't mean we'll reach AGI, but it's not a prerequisite - things can get pretty dire without that. They just love bringing it up to get attention.
AConcernedCoder@reddit
There's no conflation here when the term implies that there exists an intelligence of some kind. But if the smartest minds up until now haven't actually figured what intelligence is nevermind how to create one, then what do you think the label actually represents?
ImportantSignal2098@reddit
It's not about what I think, it's what the term is referring to for the wider audience. The meaning of "AI" has long been substituted. You can insist on preserving the original meaning but that's only going to get you misunderstood. What you have in mind is currently referred to as AGI. You don't have to believe me, look it up.
AConcernedCoder@reddit
I just wrote an implementation of Dijkstra's. Did I write an "AI?" What do we even mean by this term?
Obviously we've been writing algorithms into games to simulate opponents and have been calling it "AI" for years. I studied AI in college. None of it concerned building a real intelligence. But when the term is leveraged to encourage fear confirmation in the larger population or to encourage people to think there's something more to algorithms that can actually think, that's when questioning the use of the language is warranted.
ImportantSignal2098@reddit
Currently AI mostly refers to LLMs. I understand the drift in meaning is confusing and annoying, but I don't know why you're acting like it has anything to do with me personally. I'm just using the same terminology as everyone else, and yes I know it's being intentionally misguided - it's just irrelevant.
AConcernedCoder@reddit
The OP states in the title " AI codebases are making me miserable" and elsewhere "AI-written codebases, though, are just completely incomprehensible to me and make no sense most of the time..."
My stance is, obviously. I don't think we should expect anything else from even a highly advanced, highly synchronized system of non-thinking and unintelligent machines. Why is this even an issue? It's because of marketing. People in business unfortunately don't actually understand what they're buying, and it's being pushed like crack for companies.
You think I'm conflating "AI" with "AGI." Personally I don't really care about what terminology these people have invented unless there's any real merit to the research they're doing, and I've yet to hear of anything groundbreaking, but if there's any conflation going on here, it's not on my part.
ImportantSignal2098@reddit
The issue is that those non-thinking and unintelligent machines are good enough to displace a lot of jobs. They don't have to displace them fully, just in tandems with humans. Have you tried Claude or Codex with frontier models? You seem to be talking very theoretically and making incorrect assumptions.
AConcernedCoder@reddit
I've used Claude as part of my work, but sparingly. Personally I don't believe these LLM's are good enough to displace jobs. They're good enough to feed companies more lies, not so unlike a drug. As long as they believe they're good enough to displace humans, or that the work itself is simple enough that an unintelligent machine can do it, it will fuel the addiction cycle. The real cost just hasn't yet registered in the public's awareness.
Sure it could be used to some benefit, though so can a lot of tooling, though I can't imagine it could ever be used for anything but generate cheap disposable code.
ImportantSignal2098@reddit
I think you're vastly overestimating the amount of intelligence required for many "knowledge worker" kind of jobs. Some of the SWE jobs are in the more intellectually challenging domains, but even there many of them really aren't rocket science. Think frontend design - how much intelligence is really required for that stuff? And don't forget that it's vastly over-engineered with all the fancy libraries and unnecessary concepts, which I suppose contributes to the intelligence requirements somewhat but it's hard to quantify. There are many domains like that where people aren't really doing any rocket science and just plumbing things together. Those domains used to employ a LOT of people, and they're being hit with major displacement forces. I'm with you on the cost though, the heavy subsidies are making this harder to reason about - but if you put that aside for a moment and focus on the pure time-efficiency aspect, it's not even close.
I think this just shows that you personally haven't found the right approaches to this tooling. Just last week I used Claude to identify a performance bottleneck in a complex system, and then it basically made a fix in the upstream code resolving the issue. Nothing disposable about this. It required some guidance here and there, not fully autonomous, but it would have taken me so much longer before - and I kinda know what I'm doing with a couple of decades of root causing experience. It's just tedious. And this tooling has no problem with that. You can make it run in a loop for hours if you want. It's not intelligent but it's able to vibe-hypothesize and its intuition isn't that bad, so it works at least some of the time. It's an excellent tool to quickly check ideas - sometimes results in major speedups when you guessed things right (and can keep working on something else while it's going around confirming your theory).
The cost argument is real but it's also not as obvious as you seem to assume, as the open source models keep getting better too. At this point it's almost tractable to have a local setup which can be good enough to be useful. It can't currently compete with online offerings due to the subsidized prices and the global hype-driven hardware shortage is making things harder, but we can't know how this plays out in the future. I find it very hard to make predictions as there are so many factors including geopolitics which is getting kind of wild.
AConcernedCoder@reddit
I also have used LLM's for analysis. Not for pinpointing bottlenecks, though if the solution had been designed intelligently bottlenecks should either be a non-issue or much easier to identify. Architecture matters.
Nobody is saying that software engineering is rocket science, but speaking from experience, I can be so much more productive without LLMs on my own code bases, written the way I think that they should be, with unit testing and strategic code coverage. Would I consider the use of LLMs at all? Sure, but only for limited subsections that I would prefer to not waste any time on, and wouldn't cause issueus to have replaced cheaply. I would not, however, generate the entire solution using LLMs and I cannot conceive of how this is beneficial at all to do unless the entire project can be considered disposable. This is something people in business aren't going to get without experience or advice from professionals that they actually value.
ImportantSignal2098@reddit
lmao thanks for the laugh. Again, I was talking about a fix upstream - that's a repo outside not just my control but control of my org altogether. You sound like someone who works on small personal projects and talking from a horse that high is kinda insane.
But how do we know - maybe you're speaking from the experience of someone who just doesn't know how to use LLMs effectively? Then your claim would make sense and doesn't contradict my observations.
Why are you talking about this though, did I suggest this somewhere?
I wonder if you are misunderstanding what job displacement means. It doesn't mean 1 human gets replaced by 1 AI. N humans get replaced by M humans with AI in their hands, with M < N.
AConcernedCoder@reddit
How do I know you're not just another person drunk on the cool aid? I mean, if you think that UI work simple enough for an unintelligent machine and all of those third-party libraries amount to nothing but unnecessary over-engineering, I'm having a hard time believing that we share any of the relevant experience here.
ImportantSignal2098@reddit
There is no way in general for anyone to verify any of the claims made online. Yes I could be lying about that upstream fix. I just have no reason to, I'm not selling you anything and as you should've been able to notice my perspective on AI is mixed - but feel free to fight a strawman if you're so inclined.
YSK that those unintelligent machines are pretty good at React and massively speed up the dev process - while introducing glaring security holes obviously, if you hold them wrong. And sorry about hitting a nerve on the UI spaghetti topic, but it's not that uncommon of a stance. Good luck with your hand-crafted, artisanal projects!
cuntsalt@reddit
the other possibility is a collapse/reign-of-the-luddite where we wind up losing and moving away from such heavy reliance on tech. there have been prior collapses and losses in history where humanity loses a bunch of technical know-how/infrastructure/etc.
I'm honestly okay with either future, both seem good compared to what the AI overlords want to deliver to us. in one i will make lots of money, in the other i will make lots of farm crops. all good with me either way.
but_why_n0t@reddit
It's already failing. Experienced devs are being told to use AI to fight more fires. There's no movie
cloakrune@reddit
I've been wondering if scaling this starts to look like making a pedantic as fuck agent that's blocks reviews for this type of thing, and one that maps back to architecture, it may not have enough context or be too goldfish for it but possible you can prompt engineer your way through?
Tiny_Ad_7720@reddit
I feel the pain. One of my devs submitted this big PR for a library which looked great in the demo app. I tried to make it work with the main app and could not get it going. Took a deep dive into the code and fuck me. Layers upon layers of abstractions, duplicate method everywhere, a giant function chain that goes nowhere, etc. Just had to rewrite the thing from scratch.
Thing is, I used ChatGPT to try to help me understand the code, eg summarize the huge classes etc. ChatGPT thought the code was amazing and didn’t need improvement.
I think the problem is each iteration accumulates a bit of slop until the whole thing is a mess, especially when they are repeat prompting to try fix some odd big. The devs see small snippets which look good in isolation but don’t realise Claude is duplicating existing methods or rewriting core library methods or adding unnecessary guards etc etc. it’s worse if the fundamental architecture is wrong to begin with.
They of course need to stop and review the entire code every so often to make sure it is on the right track, but usually they are past the point of no return and can’t understand the code to do that anyway.
austinwiltshire@reddit
It's interesting. Pure vibes has a lot of the same problems as big up front design.
They try to tell the agent what to do and you get giant changes. They may or may not work. You do it again if it doesn't work. Keep pulling the prompt casino crank.
Versus just doing small changes at a time, even with Ai, small iterative changes keeps things small and clean. But "feels" slower than just pulling the crank until it appears to work.
mirageofstars@reddit
That’s what will happen. Codebases will become brittle garbage, and get replaced in 2-3 years with something new on a new stack from a new team. Used to happen before, will happen again.
washtubs@reddit
I think you hit the nail on the head. It's hopeless because AI software is the product of laziness and that no one bothered to write it in the first place. You're fixing no one's mistake, and no one will learn from it. Even when I'm working with people who are ass developers, I still have hope that they will listen to what I'm saying, and everything I did didn't amount to just staving things off. What's the payoff here? Other than just validating some corporate dipshits who think this is the way to do software development now.
_SnackOverflow_@reddit
The “nobody learns from it” part is so frustrating.
I used to enjoy doing code review and discussing different implementation techniques with coworkers.
Now half the time they just copy my comments into Claude and then make the same mistake in the next PR
HedgehogFlimsy6419@reddit (OP)
Oh man this so much. You have put it in a way nicer way than I did. Thanks.
__calcalcal__@reddit
I would rather ask them to work on e2e and integration tests, set the functionality in stone, and refactor de code. Then, I can make the effort to understand it.
If not, I just reject the pull request.
Character_State2562@reddit
Why not just let them collapse then?
If the engineering is horrible and nobody cares, don't be the sucker trying to save them from their own hubris, clearly they need to collapse and fail, just let it happen imo, they'll only learn once everything starts failing and they began losing customers/money.
I've worked with plenty of these types, you can keep rolling the ball upwards forever and "saving" them and they'll never learn, or just let it collapse.
aristarchusnull@reddit
I am right there with you, my friend. I did not expect this formerly awesome career to become so nightmarish so quickly.
james__jam@reddit
Usually you can ask someone “why is it done this way?”
Wait. I thought this was your niche? How come you have people to ask? That’s legacy code in easy mode.
Reason I say this is because I treat AI just like any other code - original devs have long been gone and you’re like the 4th generation of hand over - and there were no overlaps in those generations
I know you say you’re not looking for technical solutions. But looks like you just dont know what you dont know (no shame in that. everybody has that).
the problem is how easily engineers and developers gave up caring about quality and gave in to laziness
It’s a culture problem. And popular way to solve culture problem is through process. And yes, it is a technical solution. Maybe not an engineering solution, but a technical management solution nonetheless
positivelymonkey@reddit
You need to look into Xtreme go horse. It's going to feel foreign at first but eventually I think you'll understand.
HedgehogFlimsy6419@reddit (OP)
Dude that might as well be the best thing I’ve ever read since the grug brained developer. Thank you so much you made my day LOL.
__calcalcal__@reddit
Just looked into that, 😂
EinSof93@reddit
It's like taking a watchmaker craftsman out of his workshop and putting him in an automated manufacturing line to supervise the quality of the mass produced watches.
All clocks are fully functional. The only thing broken is the watchmaker.
sassyhusky@reddit
Linters and code analyzers…. lol I see you’ve never been blessed by one of the clusterfucks OP is talking about. The 13558 linter warnings aren’t even beginning to scratch the problems these repos have.
__calcalcal__@reddit
But if you have 100% test coverage, don’t you feel a refactor is safe?
NUTTA_BUSTAH@reddit
No, the refactor will break 50% of the tests.
__calcalcal__@reddit
It shouldn’t if they don’t check the internals and have almost no mocks.
cokeapm@reddit
Surely if the interface was so pristine and clear as to follow this principle you wouldn't need the refactor?
LittleLordFuckleroy1@reddit
They’re saying they absolutely despise doing that.
ElasticFluffyMagnet@reddit
It’s a difficult question. A big vibe coded project cannot be fixed by just installing guardrails. Those need to be present during the vibe coding and even then I’ve seen my AI do things that are questionable at best, and downright horrible at worst.
I’ve had my Cursor setup rules for the agents. I’ve had other agents make sure they keep some context of the project structure. I’ve had coding rules upon coding rules to get an approximation to how I would structure and build and code myself. I really took the time to set this up. From tests and defensive programming to naming styles. And even with all that I’ve seen the AI do things that are just wrong.
Small projects seem to be fine but anything remotely bigger than that and it just falls apart.
I’ve seen people say that it’s not that bad if you know what you are doing. But even with my years of knowledge and setting up guardrails and guidance, it fails most times.
And the biggest problem for that is that you just CANNOT trust the AI to do what you tell it should do. I’ve had sessions with hobby projects where it just ignored rules midway through. And then you ask why it stopped using my defensive programming rule. Or why it didn’t abstract a piece of code into a separate function. Or why it didn’t use Enums when I explicitly told it to in my rules. This is why I only use it for small fun projects or small functions or explanations. Because in the end it’ll screw you over if you let go of the wheel.
Scottz0rz@reddit
Bingo.
If the only entity that understands your codebase is Claude Opus, and all your tooling and documentation built up over the years is bespoke CLAUDE.md files, your company is going to keep using Claude Code even if they jack up the prices 10x-50x.
It's like any infrastructure tooling. It's a tremendous pain in the ass to migrate, so you're a customer for life once they pull you in, no matter how much Github/AWS/Azure cause you grief.
Short-sided search for profits and cost-cutting will always win for corporations, because their biggest concern is next quarter's profits. If it means riding the AI hype bubble and leaning fully into the tooling while tokens are cheap and tech debt only is unbearable after 2-3 years, that's not their concern.
The CTO and other execs who shoveled this crap down our throats have their golden parachutes and will just "move on to their next challenge" once the fallout of their disaster is starting to become apparent, and the next CTO will come in and do the next trendy thing.
And then the engineers will clean up the mess.
2AMMetro@reddit
In my experience throwing Claude at messy giant vibe coded code bases, it struggles to understand the software just as much as a human would. It constantly points to dead code and makes false assumptions about how something works. I need to constantly tell Claude to triplecheck if something actually works the way it says it does and follow breadcrumbs. This really doesn’t surprise me. I find that practices that are good for human devs are usually good for LLMs too.
Scottz0rz@reddit
Yeah, it definitely needs a lot of handholding unless you are tackling a small, well-defined problem IMO.
I haven't fully experienced what you're saying first-hand because I'm working more in the backend in self-contained microservice repos, so it's easier for it to maintain full context as far as I can tell.
What you're saying would be a lot more apparent to me if I was working in a big ball of mud monolith or a mono-repo like an old mobile application with vibecoders running rampant: the latter is more likely where the PMs/Designers are touching stuff for POC/prototyping, since backend is boring and isn't needed for wiremocks of a prototype cute thingy.
I've been trying to lean more into the nested sub-agent workflows for a small POC microservice, and as part of that I fully "vibecoded" the corresponding mobile side of the demo. It made some awful choices on where to stick code and how to compose stuff, but I'll partly chalk that into my not being able to give it full, proper direction because I've never touched the mobile side.
But, I think the overall point from my side is that as long as we have the execs pushing AI as magic, we're going to experience these vibecoded monstrosities being built out to be supported primarily by AIs, and we're only going to start seeing things fall apart after a few years.
2AMMetro@reddit
Yeah, I've been working on both. We have our own core application that we built from the ground up following strong engineering practices, and now a client's giant vibecoded mess of an app that we're tasked with helping scale. The difference in how well Claude does in each repository is massive.
Foreign_Addition2844@reddit
This job used to be interesting work with an added bonus of a good paycheck. Now, its just a paycheck.
tsereg@reddit
Saving this post.
Curious_Owl197@reddit
Big tech here. It's a mess. Leadership expectations now require engineers to pump out code like crazy, 3-5x what we used to do before. Code is written by AI, reviewed by AI, nobody knows the fucking codebase anymore. Slop upon slop. And they act surprised when things go wrong
allllusernamestaken@reddit
our CTO said the expectation is that "low value work" like bug fixes are handled 100% by AI. It writes the code, it writes the tests, it reviews and approves the PR.
Curious_Owl197@reddit
Is a new bug created by AI is considered low or high Value work?
allllusernamestaken@reddit
well we're in finance, so i guess it depends if the bug will cause a client to go prison
kappale@reddit
Just put the ai in prison.
Curious_Owl197@reddit
It's so Myopic haha
Hot-Profession4091@reddit
We’re not there yet, but we’re absolutely heading that way. If you’re not experimenting with hooking agents up to your observability platform to at least attempt to auto-resolve issues you should be.
MindlessTime@reddit
And even more surprised when their AI token bill is seven figures per month.
caboosetp@reddit
I've also worked a lot in fire fighting and modernization over the last decade. I feel you mean.
I'm currently using AI to build a game engine and 75% of my tokens are going into .md files to plan architecture and rules for the AI. It's the only way i can keep it on track.
You basically need to strong arm the AI into being relatively consistent by making sure all the decisions get put in the prompt. Heavy planning, refactoring the planning by hand, having AI code the plan, and fixing the code by hand. Then having it go write rules for itself to follow the patterns it established. It's not perfect, but it's more tolerable. Still ends up faster than completely by hand, but it's mentally draining babysitting the AI
I've been slowly dragging this methodology, forcing docs and self- updating inductions, over to work. It's made AI shit other people write so much less painful. When they pull the repo, it pulls the rules and docs, and the rules say to read and update both when done so they don't need to remember.
But when i run into repos that haven't done this or similar things, it's crazy. Some people don't know our don't care how to coax the AI into being consistent. The bloat ends up growing so fast that it can't keep everything in context. Then you get this like massive code duplication or completely completely different patterns because it doesn't know things exist. That just causes more bloat makes it harder to keep context and leads to even faster tech debt growth. It's like bacteria that gets in your system and starts multiplying exponentially.
I'm also considering a transition out of software now. I work as a contractor, and these repos getting dumped on me every job-shift is mentally draining. Even with the tools and plans for how to fix the AI generation,
I'm under no false idea that my game engine will be viable. But it's the thing i enjoy coding the most and it's the only way for me to practice working with AI that's not just making me depressed.
sudosussudio@reddit
I have an app that I own and the backend is crafted like this and it’s pretty good to work with. The front end I vibe coded and honestly every time I deal with it I think about restarting it from scratch and being more careful like I was with the backend bc it’s a terrifying disaster that feels out of control.
itsgreater9000@reddit
One problem I've had at work is that people go back and forth between models, context sizes, etc. and I work on a large, old, legacy codebase. I've done a bunch of work preparing AGENTS.mds, SKILL.md files, etc. along with a bunch of local files that I use to help build context and circulate, but we still get piles of mud in PRs. So, between different model usage, people not doing as much as possible to try to make things more consistent, we still get a lot of "waste". The variance between models is really astounding at times. Do you have any advice on how to deal with this?
caboosetp@reddit
The biggest thing is getting everybody in sync with the same models. Different agents are looking in different places for rules. Different agents respond better to different formats for rules. Unless you want like 4 separate repeated rules files, it really helps if everyone uses the same thing. The other benefit is the same models tend to make the same mistakes, so it's easier to catch issues as you learn the model. New models might be more powerful but if they respond very bad to the 20 hours you put into guard rails, it might not be saving you any time to switch.
The other big thing is actually helping mentor people in how to prompt the agents. The agents are trained on human conversation. They respond well to conversational language and lots of context. They respond poorly when you are vague and imply you want them to engineer. One of the biggest things that leads to better code is being verbose and specific.
If you want them to engineer or you need to be vague, put it in planning mode. If it's a big problem, have them write a todo file first. Agents are good at small specific tasks. Make sure by the time you're having them code that the instructions are specific. They lose context if they need to do too much at once. Walk through the planning with them, update the docs and plan in the file as you go along, then ask it to do one step at a time. You're basically writing out a feature and breaking it down into user stories. Then when you ask it to do a step in the file, it's going to create small subtasks rather than cram user stories into the actual agent tasks. You can clean up the todo files after.
Then you need to make sure your team is doing the same thing. Don't be afraid to meet with the team (even if it's async in a group chat because people hate meetings). They might have other experiences with what works best for the agents you are using. The most important thing is that you're all in sync so you know what to look for in PRs and while working. Getting your team to be in sync on this is a soft skill you need to develop. Even without AI, getting your team to be consistent is important.
People respond really well to positive reinforcement and praise. It's why all the AI models do it. When people are taking the extra time, make sure to call it out and thank them for it. The difference is you can make sure it feels genuine rather than the AI praising every little thing with hollow messages.
At the end of the day though, you'll still have people that put minimum required effort in at work, and that's fine. It's Just a job and not everyone is gung ho about spending all their spoons on their day job. This is why minimizing the effort needed is important. Things like making sure the rules have instructions to update the rules and reminding people that it's only one extra prompt to get the AI to do it if it forgot.
Tldr Everyone using the same things is often more impactful than everyone using their own wildly different best. Make sure agents are updating their own rules and docs. Try to make sure people feel good when they do it the team way.
itsgreater9000@reddit
This is awesome, thanks for the write up. Appreciate all the learnings. Some of this I knew but haven't been able to formalize it (and you did), some I had no idea. Appreciate the advice.
subma-fuckin-rine@reddit
thats how i've been using it too, it gives okay results. you spend way more time creating all the guardrails and ai skills. sometimes it works great, sometimes its junk and you have to throw it out and start over, sometimes its close and i manually refactor to get it right. i'm often left questioning whether it was worthwhile.
the real problem with it so far is you cant trust it enough. so you still have to test and verify everything. i guess when you can full trust it and its always good, everyone will be out of work lol
jhartikainen@reddit
I think it slipped out in one of the interviews, forget who it was, maybe Altman. They talked about "utility". As in, AI would be an utility similar to electricity and water.
It's quite clever, really. How do you get a slice of nearly every business? You become an utility they can't work without, just like electricity. The demand for the utility also scales as the user's business scales up. Best of all, you're not in a niche. Usually business tools are limited to some particular niche, so the size of the potential pie is limited, but with AI it's nearly universally applicable. In theory you've found a way to extract money from nearly every business on the planet, and that's probably why the AI company valuations are so insanely bloated.
Gazelle-Unfair@reddit
Yep. See Wardley Mapping if you are interested in how tools become utilities.
mikkolukas@reddit
gizmodo.com/sam-altman-says-intelligence-will-be-a-utility-and-hes-just-the-man-to-collect-the-bills-2000732953
Local-Yogurt-9499@reddit
are you sure it's only AI's fault though
ZenaMeTepe@reddit
Banking 3.0
me_n_my_life@reddit
Some people here suggest to use AI to crawl the codebase and create diagrams. The problem with that is when the codebase contains passwords and other secrets, you’re basically sending company secrets to OpenAI.
I hate where AI has brought us. I love using it as a sparring partner, but nothing more.
Wonderful-Habit-139@reddit
I literally still crawl the codebase manually. I refactor things along the way, I clean up unnecessary stuff, and I get to take a look at the actual source of truth.
All the meetings in the world couldn't give me the same understanding that I got from going through the code myself.
eng_lead_ftw@reddit
i feel this deeply. the skill that made you good at saving projects - building a mental model of what went wrong and why - is exactly what AI codebases break. you can't diagnose a system you don't understand, and AI code is generated without the reasoning trail that human-written code carries.
the thing making you miserable isn't the code quality (though that's bad too). it's that nobody documented the WHY behind the decisions. with human-written messy code, you could at least talk to the person who wrote it or read their commit messages. with AI code, the "person" who wrote it has no memory and the commits say "implement feature X."
the teams i've seen handle this well are investing in product context as infrastructure - structured knowledge about why things were built, what customer needs drove decisions, what constraints existed. it doesn't fix the existing mess but it prevents the next round from being equally opaque.
is the problem mostly that the AI code is architecturally wrong, or that nobody can explain why it was built that way when something breaks?
d0ntreadthis@reddit
All the recent comments of this account follow an identical structure. They're clearly AI generated:
But you've converted uppercase characters to lowercase and replaced EM dashes with hyphens to try to obfuscate that this was produced by an LLM.
Why are you trying to trick people? If you generated this for translation purposes, why wouldn't you indicate that somewhere?
OmnipresentPheasant@reddit
Think of it like the path integral formulation of quantum mechanics - you just need to somehow figure out how to consider and deal with the entire set of all possible paths to a solution weighted by their probability.
bighappy1970@reddit
I’m the same type of specialist. My wife says I should use the line from pulp fiction “ I’m Mr Wolf. I solve problems “
Anyway, it’s just a new skill that you haven’t developed yet. You’re forgetting how hard it was to get to this point. AI written code is just as comprehensible as human written code once you learn how to deal with it. It’s like a native English speaker learning to read Chinese, super hard at first but if you stick with it you’ll learn how it works.
KallistiTMP@reddit
I am also in the thick of this, as a senior champion of the dumpster fires, but have a different perspective. I think it's absolutely fascinating.
I have seen every kind of software engineering dumpster fire made by man. Everything from the garden variety post-startup feature velocity tech debt dumpster fire, to the eternal vendor lock in dumpster fire, to the rotating cast of bottom dollar contractors dumpster fire, to the fossilized dumpster fires of banks, to the flaming dumpsters of extended interdepartmental war.
And the AI one is new. And different. And fucking wild.
This is literally frontier dumpster fire research. These are the dumpster fires of the future. And most of the techniques that we have established in the context of other dumpster fires do strongly rely on the assumption that humans were lighting the fires, and that at the code is at least human-comprehensible, because a human had to understand it at one point in order to write it.
And it is of critical importance that we learn how to fight these dumpster fires, because this is where half the codebases in the world will be in a few years. And I am confident that they can be fought - the techniques to un-fuck an AI slop codebase must exist, they just haven't been discovered yet.
I do think it is absolutely reasonable to refuse to work with clients that won't budge on vibe code only mandates. Let Deloitte handle those ones, if they are only open to what they want to hear then there are plenty of much cheaper services to have consultants come in as sycophants and nod their heads at whatever dumb plan the C-suite has already decided to take.
But there will be a lot of companies in that position soon, including a lot of them that realize they fucked up and are desperate enough to actually dig themselves out of the hole. So, someone needs to figure out how to effectively combat this new species of dumpster fire.
I haven't found any silver bullets yet, and maybe there aren't any. But we have barely scratched the surface here. I do think there's a lot of promise in old hat static analysis techniques and trace sampling approaches to clear out all the inactive code paths, and also a lot of potential experimental approaches that could actually work to some degree, like analyzing patterns surfaced with semantic code analysis - which isn't really a thing yet, but absolutely could be.
But it is a genuinely new and unique type of dumpster fire. Of course the overwhelming majority of existing approaches won't work on it. Finding out what does is the interesting (and soon to be very lucrative) part.
410_clientGone@reddit
idk what you’re crying about. so it is difficult? get good at it then. do you think you were highly paid because it was easy? it was something that nobody wanted to do i.e clean up other’s mess. you came in, made it better and got paid for it. if everyone could do it, why would it be highly paid? the next is cleaning up AI mess. tech was always like this. new things come up and you have to adapt or get outdated.
bestjaegerpilot@reddit
You're overthinking it and being overly sensitive.
Look at this way. Pretend you learned assembly first. Holy cow C/C++ is a godsend compared to push/pop etc. Then Java comes in. Holy cow reading user input no longer requires 100 lines of pointer math and streams.
At each stage: (1) the new abstraction enabled more use cases by lowering the bar, (2) at each stage, you could say each framework made things worse (Java is a poorly written piece of crap). But you know what WHO CARES? It enables new use cases and you can go back to earlier abstractions as needed
Literally the same thing is happening before our eyes---we are moving to a new abstraction layer---natural language.
What matters is architecture resulting in clear issues---memory leaks, performance bottlenecks, etc
What matters is keeping the same behavior across refactors
And we need to start thinking in writing AI harnesses that keep it from shooting itself in the foot
HedgehogFlimsy6419@reddit (OP)
I see this sentiment a lot, but I do not agree. This analogy is very close, but has one major glaring issue - if something breaks in my C++ program, I fix it using C++ code. I don't have to go directly to compiled assembly to fix it.
On top of that assembly is deterministic, if I write te same code and use the same compiler, I will get the same result which is not true with AI.
bestjaegerpilot@reddit
Analogy is fine. The problem is you're not accepting engineering is changing.
Specs/tests stay the same... who cares if the implementation changes... that's the whole point of specs
_mkd_@reddit
Nah, words have meaning and the AI slop is not engineering.
bestjaegerpilot@reddit
You keep saying to yourself it's slop. Say it three times fast and you'll go back to the past
ZackWyvern@reddit
AI work like engineers. Do two engineers implement a spec the same way?
When a junior engineer you delegated to breaks something, you might fix their code, no? Do you not coach them to do better, install processes (pre-commit hooks and CI/CD -> *.md/skills/MCPs) that make it easier to do it right?
libre_office_warlock@reddit
I resonate with you. The fun part is that the human-spaghetti monolith that half our customers still rely on isn't going anywhere, and we're expected to neglect it daily in favor of churning out shiny new LLM things based on contextless LLM-generated confluence pages. Just let me refactor, dangit.
aeroverra@reddit
Now that you say that it's sort of been my job to transform spaghetti into new codebases and I have enjoyed it.
It's been a few years since I have had to do it. I'm not sure I want to be the fixer anymore but I'm confident if you hold onto your skills and don't let ai take them from you, those types of people will be far more valuable given enough time.
ilyas-inthe-cloud@reddit
I feel this in my bones. The difference between human spaghetti and AI spaghetti is that human spaghetti has intent behind it. Wrong intent maybe, but intent. You can trace the logic, even if it is flawed. AI code just... exists. There is no thread to pull on. I have been doing the same rescue work for years and the vibe coded stuff hits different. The worst part is leadership thinking AI output is a substitute for understanding. It is not. It is just faster production of stuff nobody understands. The real money is going to be in people who can actually untangle these messes, but the burnout is real right now.
GargantuanCake@reddit
This is just a continuation of the problems you've seen in the past; all that matters is "get the new feature out now." This quarter's numbers are all that matter. Ignore the technical debt; we can pay it off later. Yet later never seems to come.
LLM-generated code is just creating more technical debt faster. It's even worse than what you get when you hire whoever will work the cheapest and telling them to get it done as quickly as possible. Sure in the short term you can get something that looks functional but in the long term you get an unmaintainable mess that breaks constantly.
All the shitheads with MBAs and enshittifiers saw was "more code faster" so they went all in.
pmkiller@reddit
Yo same experience. Wanted just to validate you are not alone with your opinion.
I've had ample overly enginnered projects, running kafka 20min processes on 5 microservices for 200 users ( becuase we have to be ready for 10 mil users tomorrow ...any time now ). They still had an idea tough which could be cut to a bare minimum or fixed.
I suggest something I've found out from many greenfield projects that had an uptime of 19.999%, before LLMs.
Usually the codebases are small ( not in a I did a script small, but in a few hundred files small which is still a small-medium IT project ). Throw it to the bin and start over. Use it as a guideline as how it should work. Take each functionality and rebuild it, talk back and forth what is needed and what can be dropped. I think it should take between 0.2-2 months to have a functional backend again.
I've done a few such procedures with management of course not being on board, but what do they know, I could sell them a carrot as a vibrator for all their programming knowledge, hence the fiasco we're in now.
subma-fuckin-rine@reddit
i've definitely had this same thought. codebases created with heavy AI will only be maintainable by AI.
ProbablyNotPoisonous@reddit
Maintenance needs context, which is exactly what AI doesn't have.
MuggleAI@reddit
Something that's been rattling around for me on this: there's exactly one artifact LLMs cannot regenerate from source alone, and it's the one we never save. Not the code, not the tests, not the schema. The behavioral spec — what the system is supposed to do, as distinct from what it happens to do.
Paleontologists run into a harder version of the same problem. You've got the skeleton, you can see joint angles and tooth morphology, you can infer body plan. Whether the claws retracted is gone. Whether the animal nursed its young, how it hunted — also gone. The fossil underdetermines the question, and most of what would make a live specimen useful is not in the fossil.
Legacy rescue works because the authors were humans who left fossils of intent — the git log, the ticket tracker, the outdated design doc that's wrong but wrong in a way that tells you what they were thinking in 2019. Even the naming conventions carry information. With AI-generated code the fossil is thinner. You have the artifact and essentially nothing else. The prompts that shaped the branches weren't saved, and even if they were, they don't fully specify the intent — the model filled in the gaps with whatever was statistically likely.
This is why tests matter more in that setting, not less. A test suite is the only thing that can preserve "what the system was supposed to do" as a separate artifact from "what the code happens to do." Most AI codebases don't have them, or have ones the same model wrote. Where the two converge the pain isn't visible. The real damage shows up in the silent divergences.
SnooTangerines4655@reddit
The kind of 'skills' built in my org makes me want to throw up. I have also seen a trend of absolutely disastrous P0 issuee that make no sense at all coming up every now and then.
Wonder who takes care once the garbage piles up.
_mkd_@reddit
Ah, who cares. It'll be some other Sr VP, Director, CTO's job. I'll be relaxing on the beach or ~~fucking up~~ working at my next company.
/s
_Kine@reddit
The direction with these full AI coding initiatives seems to be that what you're doing is akin to debugging complied machine code. Not exactly the same because it's a non deterministic output, but it would be approached similarly. A company going all in with AI generated code really shouldn't be trying to fix that code in the traditional way, no more than most C developers should be directly fixing complied assembly. They should be reprompting until they get something that "works". If they can't get there then they've reached a capability limit of the LLM.
This is different from AI assisted code which is curated by an engineer just like you would any code generated from a template. Mixing the two approaches is asking for trouble imo. I see company leaders being sold on the full AI model but the LLMs aren't actually at that level, so their employees are forced into fixing near unfixable generated code which just leads to significant frustration and a worse result.
Nervous-Tour-884@reddit
This is just a symptom of poor usage of AI for coding honestly. When you vibe code and don't have the arch and standards set up, you end up with a mish mash of pieces that don't have an overlaying arch. It is a bunch of pieces that all do their own thing, but work poorly as an efficient whole. AI often don't have nearly enough context without you, the human, being aware of it.
Bad devs make bad code, and bad devs with AI make large amounts of bad code.
Quick-Ad2386@reddit
yeah, i get it. the whole 'save the doomed project' thing used to have a point now you're just polishing a temp thing that everyone expects to be replaced in six months when the prompt changes. it's maintenance without a future.
roger_ducky@reddit
Think of AI as “swarm of interns.”
So yes, without an actual design, coding standards, etc, they just… do whatever.
Easiest way to realign is to make those post hoc and then tell the interns to make it fit the documentation.
And, once you’re done, yell at the people that didn’t do that the first time around.
SigmaSil@reddit
I don't agree with it, but mods are closing posts like this, even with high quality discussion in them
Dangerous-Sale3243@reddit
Get a grip, honestly. AI tools can make codebases grow large and complicated quickly, but they also allow you to do things like dispatch 20 agents in parallel to trace through said complicated codebases.
AI is a logical brick, you can build with it if you know how to compose them into workflow, combining procedural elements, checkpoints, decisions, error handling, and human input. It’s a lot like like composing software in the 90s or 2000s.
HedgehogFlimsy6419@reddit (OP)
Correct me if I'm wrong, but aren't you basically saying is that AI codebases at some point are basically impossible to comprehend by humans alone, and I need to rely on an expensive product controlled by 3rd party to get an idea what it does?
Because it sounds very much like it and is one of my major complaints in this post.
Dangerous-Sale3243@reddit
Im saying AI makes things easier more than it makes things harder. Rewriting applications used to require huge lobbying campaigns, budgeting, risk vs reward presentations, etc.
Now like fine, whether the legacy code was written by a human or an AI, you can rewrite it to be clean code (by your definition) in your language/architecture/compute of choice in a weekend.
It takes time to invest into learning what tooling/strategies work best, because AI is like a cannon, it can do a lot of good or bad depending on the skill of the operator.
ZackWyvern@reddit
How did he say that? He's suggesting that complicated codebases can be scanned through with AI far more quickly than humans alone can. And he's right.
You're implying that there are "human codebases" and "AI codebases". I'm curious what industry you work in where the production codebase is so clean and so much better than AI. My company's codebase is incredibly large - hundreds of product teams coordinating across numerous platforms and tech stacks - and I can say for sure that AI is far more effective at searching the codebase, integrating knowledge about it, and contributing to it than any engineer who doesn't have experience in the specific parts we're concerned about.
And in what world has a production codebase ever been fully comprehended by one engineer? Only a small codebase solving some small problem I assume.
If you don't like the 3rd party controlling the product that enables AI bullshit, you need to start investing in local LLM models. That is how you get freedom from AI corporations, not by hoping AI will tide over.
Fidodo@reddit
The idea that we should lower our standards to accommodate AI is a trash opinion from stupid morons. If AI is so great why would we LOWER our standards?
I do think AI can be used in a workflow to generate high quality code but it requires using your brain and building very diligently. Ever since AI has come out I've had to think harder and deeper than I ever have.
ooqq@reddit
It's the classical problem of a book beign written by a million apes. Now imagine the book is an instruction manual that someone or something has to follow in order to make the entire economy of a city to work and you'll start to visualize the magnitude of the problem but not at local but global scale.
waitses@reddit
Let them cook, then swoop and fix everything for 5x your hourly rate, same situation played out with outsourcing to crap coders in India.
mxldevs@reddit
I'm sure even AI coders have no idea how to maintain their AI projects.
They just figure "maintain? Just have AI rebuild a new project with the new requirements!"
StrawberryWaste9040@reddit
AI has increased complexity of your job by order of magnitude.
We're all going from " I don't want AI to take my job" to "please AI take my job I don't want to deal with sh**sh** this anymore"
VisitCautious163@reddit
what's the context for this
djnattyp@reddit
System prompt: You are a bot to post useless noise comments on reddit.
ng37779a@reddit
The niche hasn't disappeared — it's mutated. You used to dive into humans' garbage; now you'll dive into AI's. Same skill, different generator.
What's getting scarcer is the ability to read code you didn't write and understand why the decisions in it were made. AI ships more code per hour, and almost none of it comes with the tacit reasoning that used to travel with a human author.
The work isn't maintenance anymore, it's comprehension. The pay-band for people who can reconstruct intent from artifact is about to get weird. My bet is upward.
Curtilia@reddit
You sound like AI
david_daley@reddit
There have been all kinds of TV shows and movies about forensic psychologists. They gather evidence and can then predict what the “suspect” will do next.
Working with code bases is similar because once you understand the psychology of the original teams you’re able to navigate through the code because understand how they think.
AI generated code doesn’t follow any of that. It is like performing forensic psychology on a “crime” committed by a schizophrenic sociopath with multiple personalities and then trying to predict what they’re going to do next.
ashultz@reddit
If you tell that to people who haven't done code forensics they just dismiss it but this is very true, at least half my considerable "what is happening here and why" ability is destroyed by having code with no motive.
Character_State2562@reddit
The reality is, almost no one cares at all about their job. They sign in to earn $, so any cognitive effort is effort too much. So if there's an easy way out, AND the c-suite all demand that you take it, everyone will.
You either have to find a way to enjoy it, join them and make slop, or leave and try to find a job you still love (good luck lol).
Personally I contract development and don't care about it much - if ai is faster, then that's what I use. I work on an extremely complex video game for the satisfaction and love of programming.
Perhaps that's an area you could move in, detach love and craftsmanship from your job and start a hobby project.
Additional_Rub_7355@reddit
Exactly, jobs have been a bunch of bullshit for a long time now, even without AI.
You wanna do real programming? Pet projects is the way.
wisconsinbrowntoen@reddit
Frame it as "this is irreparably bad. I need to start from scratch."
serpix@reddit
that is not at all different to what an inherited old codebase made by humans looks like.
paraleluniversejohn@reddit
Look at it this way. You might be the first human on the planet who might understand what the AI code is doing in these vibe coded projects
IdeaJailbreak@reddit
I mean, with AI it’s probably cheaper to rewrite most things wholesale with your better judgement than try to spend time understanding the weird structure. Assuming someone can state the critical features
bakawolf123@reddit
>Maybe that is the endgame of these agents. AI companies want us to rely on their products to debug this mess and learn what the code actually does. I’ve found that using AI to fix these codebases is basically a requirement at this point.
Not quite, from what I've seen the AI projects are usually handed over by owners when they cannot do anything with them using their AI tools anymore. Doesn't mean that a project cannot be fixed with a different toolset, but chances are way higher with the help of an actual SWE.
No_Reality9607@reddit
human intuition still plays a big role in understanding messy code
stevenr12@reddit
Sorry but it sounds like you have to check your ego and it sounds like you’re difficult to work with. You claim you gained satisfaction from discovering someone’s thought process as they “went down the wrong path” but it also sounds like only your path was the right way in your opinion. Codebases will always have parts you don’t want to touch but you can still use new tools to improve it and increase your efficiency. Your post feels like you are bothered by not being the go to person anymore.
HedgehogFlimsy6419@reddit (OP)
Nah I honestly don’t think so. I’m obviously not a native speaker so maybe I came off as someone being happy that someone else made a mistake. I meant I just enjoy the process, and often that someone else who made a mistake was me.
I am the go to person still so I’m not sure where did you get that from. I’m just less happy and engaged working on ai generated codebases than ones written by humans.
You are really reaching for straws here man.
So_Rusted@reddit
are you ai?
PermabearsEatBeets@reddit
This subreddit is dead. AI slop post after AI slop post
SpritaniumRELOADED@reddit
So do AI codebases. Next
ZenaMeTepe@reddit
How much did you cost the company if you worked on their codebase full time for a month, or a year?
ivancea@reddit
That's an overreaction indeed. You're confusing "vibecoding" with "coding with an agent". My company makes extensive use of agents, and we didn't change a single step of the reviewing process, which is as strict as it was before. And trust me, it's very strict and in-depth.
It looks like you're only looking at company's that don't have process. But let me enlight you now: those companies where also bad before AI; AI just multiplies outcomes.
Now, because this is the post #57772 on this topic, I'll tell you: if you don't like reviewing code, improving technology and automating tasks (including your own job), you were already in the wrong career. The earlier you find this out, the better!
vismbr1@reddit
I dont agree that all vibe coded projects are a piece of garbage.
If its vibe coded by a none engineer that fed the AI with constant changes that re-builds the code base over and over, then yes it will most likely be a toatal mess. If you have decent instructions on architecture and best practices, and uses Opus or Sonnet, i think the code often is very decent and maintainable.
nana_3@reddit
I mean OP said his job is going into garbage dumpster fires of code and fixing them. He’s not saying all vibe coded work is garbage. He’s saying garbage vibe coded work is much worse than garbage human work.
vismbr1@reddit
Well would anyone disagree? Is there anything to discuss on that take?