Our group has been experimenting with LLM's (I refuse to call it AI because it's no such thing) on a reasonably large and extremely complicated code base. What we're finding is that while the LLM is often right, when it's wrong, it's plausibly wrong. That's problem #1: undue dependence on the LLM weakens the group's sense of "that's not the right answer", leading to bug churn.
Problem #2 is that a newer developer relying on the LLM's for code writing or debugging, misses out on the chance to develop that sense of how it all works. Left unchecked, you get a bunch of guys who don't actually know at a deep level how the system operates. That is not going to end well. (See #1, if nobody has that sense of "that's not right", well ...)
The third finding is that the quality of results depends very strongly on the quality of the LLM prompts. This goes back to the classic "Ask a Foolish Question" conclusion: to ask a proper question, one has to already know at least part of the answer. The only way to get there is to have at least some decent understanding of the code base, which one is not going to get by relying on the LLM's for all one's work. ("Ask a Foolish Question" is an excellent and classic Robert Sheckley short, if you haven't read it, kindly do so.)
Careful use of the LLM by experienced developers who already know the system, at least at a high level if not details of every area, and who can prompt the LLM in the right direction, seems to be an advance. We see more bug fixes; without LLM we might fix (say) 3 bugs in the time that using the LLM can fix 10, even if 3 of those "fixes" are wrong and have to be nak'ed or reverted. Reliance of less experienced developers on having LLM's fix bugs for them is the slippery slope to the nether regions.