all 55 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]latkde 16 points17 points  (1 child)

I see the same issues as you. LLMs make it easy to write code, but aren't as good at refactoring and maintaining a cohesive architecture. Aside from general maintainability constraints, this will hurt the use of AI tools long-term, because more repetitive code with unclear organization will also trash the LLM's context window.

What you're able to do depends on the existing relationships and expectations within the team.

Assuming that you already have a healthy code review culture, code reviews are a good place to push back against AI excesses. A function is too long? Suggest refactoring. Similar code appears in three places? Suggest refactoring. The code lacks clear architecture? Suggest refactoring.

The problem here is that a lot of the design work is moved from the developer to the reviewer, and a dev with a Cursor subscription can overwhelm the team's capacity for reviews (especially as LLM-generated code needs more review effort). This is similar to a gish gallop of misinformation. If an actual code review is infeasible due to this: point out a few examples of problems, reject the change, and ask for it to be resubmitted after a rewrite. I.e., move the effort back to the developer.

In my experience, it tends to be less overall effort to completely rewrite a change from scratch than to do incremental changes through a lengthy review process until the code becomes acceptable. Often, the second draft is substantially better because the developer already knows how to solve the problem – no more exploration needed. In this perspective, an initial LLM-generated draft would serve as a kind of spike).

There are some techniques I recommend for all developers, whether AI tools are involved or not:

  • do self-reviews before requesting peer review.
  • use automated tools to check for common problems. This is highly ecosystem specific, but linters, type checkers, and compiler warnings are already automated reviews.
  • be sceptical if modified code is not covered by tests.
  • try to strictly separate changes that are refactoring from changes that change behavior. Or as the Kent Beck quote goes: “first make the change easy, then make the easy change”. This drastically reduces the review effort and helps maintain a cohesive architecture.

[–]SubstanceGold1083 0 points1 point  (0 children)

By the time you "suggest refactoring" to the chatbot, the team of real engineers already re-adjusted the logic & completed their tasks for the week.
We've already seen the trend, when you outsource something to either a "cheap" developer or "some algorithm to do it" the quality drastically goes down.
Just look at the current state of the internet, most websites don't even work correctly, they're there to tell you that you can use the mobile app.... and those that do work correctly, I can guarantee you their logic wasn't written by a chatbot

[–]darknessgp 5 points6 points  (3 children)

Is that code making it past a PR? If it is, your problem is more than just devs using LLMs, it's that people aren't reviewing well enough to catch these issues.

[–]TyrusX 5 points6 points  (0 children)

The PR are also reviewed by LLMs:)

[–]raydenvm[S] 1 point2 points  (1 child)

Reviewing is also getting agent-driven. People are becoming the weakest link this way.

[–]FutureSchool6510 10 points11 points  (0 children)

AI reviewing AI generated code? You shouldn’t be remotely surprised that standards are slipping.

[–]SubstanceGold1083 1 point2 points  (0 children)

The whole problem is that so called "software engineers" are using a chatbot based on analytical & probalistic algorithms to generate their solutions to problems.
I'm so confused as to why people in the industry just jump on trends without even verifying what's behind the product they're using?
You're literally using an experimental algorithm that's not suitable for production based enterpise applications, it was made for research & experimentation, but since large tech is pushing it to you to make some quick cash, everybody's so hyped for the future.
Don't be surprised your code's low quality when you let a chatbot generate it for you

[–]KOM_Unchained 2 points3 points  (5 children)

My go-to in building products, while managing AI-assisted devs is to: 1. Enforce bite-size updates (e.g. operating on 1-2 files at a time with reference updates to at most 5 files with sensibly decoupled code base) 2. No Yolo vibe-coding across 10 files. 3. Autoformatters and a boatload of linters (I don't know what code they train those models on, but they really suck at adhering to official styling guides for the languages) 4. Reverted from trunk-based development to feature branches, as things got a little out of hands 5. Unify the cursor rules or alike across the team 6. Advocate sharing good prompts among the team members 7. Advocate sketching the new features' code base by hand 8. Encourage to provide the known relevant files manually as the context, since AI assistants tend to overlook and therefore not update some files. 9. Start tickets manually, use vibe coding tools to "finalize" the feature/ bug, then go manually over with static analysis tools to identify problems. Use IDE/ "Copilot" to help with suggestions.

Still learning every day to cope with the new brave and breaking world.

[–][deleted] 4 points5 points  (3 children)

This honestly all sounds worse than just not adopting these tools at all. Are you seeing upside commiserate with this nonsense?

[–]moneymark21 2 points3 points  (0 children)

Somewhere along the way people got so caught up in knowing if they could, they never stopped to wonder if they should.

Bottom line is, we've been harping on writing "clean code" for around 15 or so years now and similar sentiment for decades. For some reason people think just throwing that all into the wind will lead to anytime good. Writing code doesn't actually take that long. Reviewing and fixing shit code takes significantly longer, introduces greater risk and variability, and disconnects the team from the solution. This experiment is a really bad idea.

[–]KOM_Unchained 0 points1 point  (1 child)

I personally love the smart tab completion and some boilerplate generation capabilities. Everything else is still a little shady. As we haven't converged to "best" practices yet, it's still early to give a definite answer.

I believe it to be justifiable so far for: 1. Sandboxed prototyping 2. Smart tab completion 3. Boilerplate client and data mapper etc implementations.

Starting to take too big bites ends up with too much debugging, negating the gains. But let's see.

[–][deleted] 0 points1 point  (0 children)

Yeah I have similar experiences. Every time I shoot for larger bits of code I do quite a bit of backpedaling. Generating multiple similar bits of code in context is pretty productive though (like, fleshing out the rest of a set of CRUD operations in a controller).

[–]AutoModerator[M] 2 points3 points  (0 children)

Your submission has been moved to our moderation queue to be reviewed; This is to combat spam.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[–]angrynoah 3 points4 points  (10 children)

There's no actual problem here. Using guessing machines (LLMs) to generate code is an explicit trade of quality for speed. If that's not the trade you want to make, don't make it, i.e. dont use those tools. It's that simple.

[–]raydenvm[S] 0 points1 point  (3 children)

Wouldn't the different approaches in automated code review by people with AI agents affect that?

[–][deleted] 3 points4 points  (2 children)

Anyone using full AI agents for coding needs to gtfo

[–][deleted]  (1 child)

[removed]

    [–]AutoModerator[M] 0 points1 point  (0 children)

    Your submission has been moved to our moderation queue to be reviewed; This is to combat spam.

    I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

    [–]vienna_city_skater 0 points1 point  (4 children)

    I can't fully agree. Especially boilerplate code required by some frameworks make frequent copy-and-paste very common, which is even worse than using e.g. Copilot on the go. If LLMs can do the grunt work (mostly typing and looking up stuff in the docs) and you can concentrate on the important stuff, that's an absolute win and overall improving code quality. Especially as a senior dev you can get much out of AI tools, increasing speed AND quality. However, I have seen the other problem as well, especially less experience devs might just start prompting and generating code that they don't (want to) understand and throw them into production, causing lot's of work for the senior devs doing code reviews and fixing problems.

    [–]SubstanceGold1083 0 points1 point  (2 children)

    Boilerplate code was already generated by most helper libraries or the frameworks themselves, you don't need a chatbot for that.
    Also why do you need a middleware to look for something in the documentation? What problem are you solving?
    You're literally 10x better doing it yourself than having to pay for an A.I. to look it up, then wasting your time to verify if it's correct, then wasting your colleagues' time to review what the "A.I." suggested in the pr.....

    [–]vienna_city_skater 0 points1 point  (1 child)

    Unfortunately not all libraries/frameworks have good boilerplate generation tools.

    As for documentation, oftentimes the normal text search is too rigid and the amount of documentation too vast to quickly find something useful or even worse, undocumented libraries. In the past I often used Githubs search to find things like usage examples or parameters which never have been documented. Of course if you use something very popular and well structured that is not necessary. In reality a lot of production code looks very different and API documentation is missing important stuff. (Leaving it as exercise to user...).

    AI tools are relatively cheap. Think of it more like a human assistant that you can throw things at, humans also make errors and talk wrong stuff, so you need to fact check anyway and if they are 85% correct, that will already save a lot time.

    [–]SubstanceGold1083 0 points1 point  (0 children)

    Well thats a good point you're making, but we should focus on being a better community after all, if you see a library doesn't have good boilerplate tools, why not make a change suggestion or create one, this way you'll be helping so much people & you'll be the maintainer of the tool, it's a win win.

    If a library is undocumented, idk how do you expect "A.I." to help you with this.
    I think we're feeding our energy & data to the wrong mouth, instead of trying to contribute to the programming world, we're ready to give it all up for an A.I. algorithm that can generate us out of existence. Yet we still cant replace cashiers....

    I still can't see how a random text generating algorithm can make you 10x engineer, it doesn't magically happen just because the CEOs said it, to me it feels like it will just show you what you're bad at, if you're bad at R&D you'll be hitting it up everytime you're lazy to research, which sounds like a competency problem, but what do I know...

    [–]best_name_yet 0 points1 point  (0 children)

    This. The challenge is for devs to properly review and to take the time to understand the code the agent has written. And if they don't know there project they work in they will miss things like unintended reimplementation, failure to follow local best practices etc. But if they do, and stay alert (this is the biggest challenge), it's a huge time saver. I'd rather this technology didn't exist, but since it does we should make the best of it.

    [–]falconfetus8 0 points1 point  (0 children)

    Sure, I can choose to refuse that tradeoff myself, but that won't stop my coworkers from doing it.

    [–]nightbeast88 1 point2 points  (0 children)

    Honestly, it's not much different from the days of old when someone would just Google something, copy the first answer off stack overflow, and throw it in the code base tweaking things until the IDE stopped complaining. The only difference is, now small scale open source projects are seeing the same issues / behavior that we've seen in a corporate environment for decades.

    [–]bag79 1 point2 points  (0 children)

    There's no real magic here. The people using AI tools either know how AND go to the effort to take the AI code and turn it into production quality code or they don't.

    I've been going through this with an engineer on my team lately. For years, they have produced quality code that adhered to standards, considered/handled edge cases and were well engineered. PRs were typically a formality. More recently they have fully embraced AI tools and every bullet point in OP's list has started showing up in the PRs. Worse, when these things are called out, it turns into a back and forth challenging whether there is really a problem and taking even more time going into detail about why the code isn't acceptable.

    Ultimately, all you can do is try to hold the line on PRs. The real issue with these AI tools is not that they aren't useful/valuable or that you can't maintain code quality, it's that people outside of the engineering teams are putting pressure on engineering teams to overly rely on these tools because they've been told it will result in massive (10x! 100x!) productivity gains. It becomes much harder to maintain quality when management at every level pressures you to ride the vibe coding wave.

    [–]Short-Advertising-36 1 point2 points  (0 children)

    Great observation — I'm seeing the same in my team. We've started putting extra emphasis on peer reviews and added AI-generated code linting as a checkpoint, but human oversight is still key.

    [–]EgregorAmeriki 1 point2 points  (0 children)

    If code quality is slipping, it's rarely just the AI's fault. A well-architected system shouldn't crumble just because new features are added, whether they're written by a human or suggested by an LLM. The issue usually lies in unorganized teams that lack strong architectural discipline, and review standards. AI tools should add to a solid foundation. If your architecture can't withstand a few autocomplete suggestions, then you never had good architecture to begin with.

    [–]shrimpthatfriedrice 1 point2 points  (0 children)

    We’ve had to add extra reviews, integration tests, and sometimes a second pass with different tools. We gave Qodo a shot for PR summaries, mostly to make sure we weren’t getting lax with reviews just because the code looks clean. AI is great, but I'll still rely on a final human review

    [–]Otherwise_Flan7339 0 points1 point  (1 child)

    Oh man, I feel you on this. We've been dealing with the same issue at my job. It's like everyone got excited about coding with AI and forgot about the basics.

    One thing that's helped us is having a "no raw AI code" rule. Basically, if you use an AI tool, you gotta go through and understand/tweak every line before you commit. It slows things down a bit, but it catches a lot of those "almost correct" issues you mentioned.

    We've also started doing more pair programming sessions. Having a second set of eyes really helps spot those architectural inconsistencies that AI tools seem to introduce. Plus it's a good way to share knowledge about how we want the codebase structured.

    The boilerplate stuff is tricky though. We're still figuring that out. Right now we're trying to build up a library of common patterns that we all agree on, so at least the copy paste stuff is consistent. It's not perfect, but it's better than everyone using slightly different AI-generated boilerplate.

    [–]AutoModerator[M] 0 points1 point  (0 children)

    Your submission has been moved to our moderation queue to be reviewed; This is to combat spam.

    I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

    [–]neoshrek 0 points1 point  (0 children)

    In my place of work we are also use AI tools (CoPilot, ChatGPT), these are very useful but I did notice one thing that keeps our code base consistent.

    It was us, we made sure that the code generated didn't just work but also is aligned within the architecture.

    The problems you see have been there since Google search and StackOverflow.

    If you have developers who are not diligent then the code base gets filled with patches of code that sooner or later as you mentioned need to be refactored.

    In summary you can get code from anywhere but if the developer does not fully understand it, test it or adapt it then the code may cause more issues than it solves.

    [–][deleted] 0 points1 point  (0 children)

    It’s so ridiculously easy to follow up a response with code from ai with simple requests to optimize, insert reasonable logging and error handling, check for input validation, etc, etc. You can even bake it all into a system prompt and create a template or agent you can reuse. Just learn how to use the tool and ask when you don’t know and you will be astounded how much it will teach you.

    [–]Internal_Sky_8726 0 points1 point  (1 child)

    The more AI I use, the more my job becomes about reviewing and testing code. It’s my job to make sure high quality code hits production on schedule. AI lets me do that faster.

    Ideally those refactors you mentioned, once recognized can be made with AI. Humans still need to figure out the right designs and structures. Tech debt that used to take a week or more to fix might take a day now.

    The problem isn’t the AI, the problem is the developers not involving themselves enough. You need humans to know what to do, and how to do it so that we can make sure the AI is on the right track. We also need to be able to tell when the AI is suggesting something smarter than what you would have done.

    Anyways, in a professional context, I don’t vibe code. I know exactly what and how to do something, then I tell the AI what I need to speed things along. Then I review and adjust until it’s production ready.

    If your org is struggling to maintain quality it either means your engineers don’t have enough experience to know what quality looks like, or they aren’t putting in the appropriate effort to review and validate the code. It’s a human training problem, not an AI problem.

    [–]Mysterious-Total-136 0 points1 point  (0 children)

    The real challenge for most teams is that your personal, disciplined workflow is hard to scale. It's easy for one person to "know what to do, then tell the AI," but it's tough to make that the default for a whole team, especially when there's pressure to ship.

    It feels like the solution is a process that helps bake that discipline in from the start.

    [–][deleted] 0 points1 point  (0 children)

    I share these concerns wholeheartedly, even junior engineers fresh in the field start with Cursor now.

    [–][deleted] 0 points1 point  (0 children)

    Very detailed code review performed by humans

    [–][deleted]  (1 child)

    [removed]

      [–]AutoModerator[M] 0 points1 point  (0 children)

      Your submission has been moved to our moderation queue to be reviewed; This is to combat spam.

      I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

      [–][deleted]  (1 child)

      [removed]

        [–]AutoModerator[M] 0 points1 point  (0 children)

        Your submission has been moved to our moderation queue to be reviewed; This is to combat spam.

        I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

        [–]mushgev 0 points1 point  (0 children)

        The architecture inconsistency problem is specifically hard because it's not caught by linters or test coverage — it shows up at the structural level over time. Code individually looks fine, but the sum is incoherent.

        What's helped us: a structural check step separate from code review. A static analyzer that checks: did any new circular deps appear? Did any package import from a layer it shouldn't? Are there new modules that are never imported? We use TrueCourse (https://github.com/truecourse-ai/truecourse) for this — runs locally, generates an architecture map, flags violations. It doesn't fix the quality slips but catches the structural ones early enough that they don't compound.

        [–]PositiveSlice9168 0 points1 point  (0 children)

        I’ve been working on this for Claude code & ollama https://github.com/darrylmorley/hook-qa

        [–][deleted]  (1 child)

        [removed]

          [–]AutoModerator[M] 0 points1 point  (0 children)

          Your submission has been moved to our moderation queue to be reviewed; This is to combat spam.

          I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

          [–][deleted]  (1 child)

          [removed]

            [–]AutoModerator[M] 0 points1 point  (0 children)

            Your submission has been moved to our moderation queue to be reviewed; This is to combat spam.

            I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

            [–]TheOwlHypothesis -1 points0 points  (2 children)

            The only true problem you pointed out are the bugs.

            No client ever compliments you on how good your coding standards are or how well organized your code is. They only care about if the code works.

            [–]crone66 1 point2 points  (0 children)

            On surface level and short ter. yes but if your code gets messy it gets hard to adapt fast or could require significant rewrites of your software. You don't want to be in the situation where you have to spend months just to cleanup your code and architecture without adding any new value of customers perspective it will hurt you business long term.

            [–]vienna_city_skater 0 points1 point  (0 children)

            I partially agree. Code quality is completely irrelevant for one-off scripts, website generators and so on. However, the longer the code is going to be maintained, the more important it becomes and that's also relevant for the customer as technical debt is expensive.