I built a lot of apps last year. I approved most of the code and commits that went into them, and a good portion of it I could not explain.
Not "couldn't explain to a junior." Couldn't explain to myself. The tests were green, the diff looked like something I would have written, and I hit approve. If you had stopped me forty minutes later and asked why that function needed a lock, I would have had to go read it again like it was someone else's code.
Which, in a sense, it was. And because most of these were my own projects, there was no second reviewer downstream of me. I was the entire quality gate — and the gate had quietly stopped reading.
I am not going to pretend this is a novel observation. If you read dev.to you have already seen this post four times this spring, and if you read r/ExperiencedDevs you have seen the thread where someone calls themselves "a tourist in their own codebase" and four hundred people say yeah, same. One in five developers in the 2025 Stack Overflow survey picked "I've become less confident in my own problem-solving" as a top frustration with AI tools. The fear is not underreported. It might be the most reported feeling in software right now.
So this isn't a diagnosis post. The diagnosis is done. What I couldn't find anywhere was an honest answer to the next question: every fix anyone proposes for this has the same shape, and that shape is known to fail. Including the one I spent two weeks designing.
The reframe that finally made this click for me came from aviation, and it's about thirty years old.
When researchers tested airline pilots who had trained on manual flight but then spent their careers flying highly automated aircraft, they found something specific. The procedural skills — scanning instruments, hand-flying the aircraft — were rusty but largely intact. The pilots could still fly the plane.
What had cratered were the cognitive skills. Maintaining awareness of where the aircraft actually was. Tracking what the next step should be. Recognizing and handling an instrument failure. (This is Casner et al., 2014; the FAA's response was to recommend that pilots hand-fly for the majority of flights.)
Read that again with your own job substituted in. The typing survives. The model in your head is what goes.
A 2024 review by Brooke Macnamara and colleagues in Cognitive Research extends this to AI assistants specifically, and makes the argument sharper than I would have dared: because AI mimics cognitive work rather than mechanical work, and because cognitive skills decay faster than physical ones, AI-induced skill decay should be worse than the automation decay we already documented in cockpits.
That's the reframe. It isn't that AI makes you slow at writing code. It's that AI is very good at the exact part of the job that used to build your judgment as a side effect, and the judgment does not maintain itself in storage.
Which matters, because look at what the job is now. Reviewing. Catching the thing the model was confident about and wrong about. Knowing what to build. Deciding when the plausible answer is the wrong answer. Every one of those is the cognitive column, not the procedural one. We have automated our way out of the reps that produced the only skills we still get paid for.
Here's the part that changed how I think about the whole problem. There are three independent findings that all say the same uncomfortable thing: you are structurally unable to self-assess this.
One. Macnamara's review names the mechanism directly. Ordinary skill decay you notice, because you stopped doing the task. AI-induced decay hides, because you didn't stop doing the task — you kept shipping, kept reviewing, kept closing tickets. Only the cognitive engagement stopped. A surgeon still completing successful operations has no signal that their judgment has softened. Neither do you, with a green CI badge.
Two. METR ran a randomized controlled trial in 2025 with sixteen experienced open-source developers on 246 real tasks in their own repositories — projects averaging five years of their own contributions. Developers predicted AI would make them 24% faster. Afterward, they estimated they had been about 20% faster. They were 19% slower.
Sit with that. Not "they were wrong about the tool." They were wrong about their own experience, immediately after having it, on code they knew better than anyone. And the slowdown was worse on tasks where they had high prior experience. Whatever perceptual instrument you'd use to detect this in yourself, that study is the calibration check, and it failed.
Three. The classic testing-effect result from Roediger and Karpicke (2006): students who re-read material rated themselves more confident about remembering it than students who self-tested — and then recalled 40% versus 61% a week later. The re-readers read the passage 14.2 times on average. The testers read it 3.4 times. Re-reading felt like learning and wasn't.
Re-reading a diff until it looks fine is the same operation. It builds confidence and not much else.