You're lucky. Every single person (n of around 10) I've been unlucky enough to review code for lost between 0.5 and 3 promotion levels of competence when they started using LLM code generation, and it's been worse for the better programmers because they have more capacity to lose skills.
My personal "favorite" was when the lead engineer who onboarded me half a decade prior forgot the written policy he'd put in place of "no raw js dates. use this library for everything date related instead" and sent up an MR that not only used javascript dates, but did complex operations on them (incorrectly at that, because it didn't account for timezones, daylight saving, years that had a leap day, and months that weren't 30 days).
From what I can tell, it's the exact same reason people drive faster than is prudent or use their cellphone while driving. It feels safe and good right up until it isn't and you crash. And because most places don't have anywhere close to adequate specification detail, test coverage, or review coverage, the broken bits aren't even noticed until much later.
I think for a lot of people it's that they stopped caring or obsessing over the (perceived) small details; AI makes it very easy to work on a higher level. I suspect (don't quote me on this) that it's the same for a lot of developers that grew to more lead / managerial positions - at some point the details don't matter much to you personally and you need to spend your energy elsewhere.
But I hope people are gathering metrics. We had an extra meeting the other day because we're seeing an upwards trend in outages, the meeting was mainly about how it affects various departments (like customer support) and potential revenue loss (can't sell a product/service if the signup page is down for three days).
Thing is, there's no one cause for any of those - we have hundreds of engineers, dozens of applications and 3rd party integrations, millions of (potential) customers each running their own set of devices, and it's pretty much impossible to control everything.
But this goes beyond whether or not code was written by an attentive hand working under a strict set of policies or an AI that figures it out on the go, and goes up a level to things like realtime monitoring and incident responses.
You're right that as a person moves into management/staff+ that individual details matter less for them, because they begin to deal at a more strategic or operational level, but someone still needs to obsess over the small details (to make things easier, let's assume we're only talking about the details that actually matter and that there's broad agreement what that set is). It's not that those details stop mattering to them, it's that they have to depend on the assumption/promise that someone else is going to mind those details for them, so that they can work on things with a broader perspective.
The problem comes when no one is actually minding those details anymore. If those details aren't actually minded, then the work at the higher levels will be much less useful and effective, and in the worst cases won't matter at all.
I am seeing the same. The skillsets degrading rather rapidly, people not able to maintain focus and becoming less sharp in general. The brain rot associated with short form videos is affecting our industry via LLMs. It doesn't give me any joy to see it happening, especially to people I care about.
I don't know why I haven't been able to see the similarity between short form content and LLMs in our industry until reading your comment, but that is apt. That's the impression I'm getting. I stay away from "agentic code generation" as much as possible, just like I avoid short form content mills like the plague. That said, LLMs have been a huge boon for me as a research assistant. Being able to look up very niche problems, and have responses be tailored to me, is awesome. My brain stays sharp and I still enjoy the fun of putting the pieces together myself much faster than before.
I don't personally like LLMs for research assistance (yet?) because i can't get over the hallucinating or rather, waste too much time validating that it's not currently overcast when they tell me the sky is in fact blue.
But, especially as code gets flung over the wall faster and with less care, I do think they are getting to be pretty great at reviewing code for specific things that a linter can't easily catch and for looking for security, implementation, and architectural flaws before I have to look for them. A couple examples of what i mean: 'does the code use knex.raw with a template literal?', 'does the code do n+1 db lookups instead of something better?' 'do all the added/modified tests follow the test case template defined here?'
Agreed. I trust it more as a codebase query system rather than a codebase writer.