I keep running into the same complaint lately, mostly from people with a decade or more of experience: they don’t feel like they know their codebase anymore. It used to be simple. You started something from scratch and made every architectural call yourself, or you joined an existing project and spent a few weeks poking around until it clicked. Either way, you eventually reached a point where you understood how the whole thing fit together. With AI writing a growing share of the code, a lot of senior devs say they never quite get there anymore. It’s more hands-off than feels comfortable, but the productivity bar keeps rising, so slowing down to fully absorb everything isn’t really an option either.
What’s interesting is that this hits senior people harder than juniors. Ten-plus years in, and the imposter syndrome that mostly went away is suddenly back, except the trigger isn’t “am I good enough,” it’s “did I actually build this, or did I just approve it.”
Here’s the thing though, and I say this as someone who has never once memorized a language’s syntax by heart: almost nobody actually “knew” their codebase the way this framing implies, even before AI. What experienced devs built up was pattern recognition. Most of programming is recognizing which design pattern the problem in front of you maps to and applying it again, not deriving it from first principles every time. System design is the one piece that hasn’t really moved to AI, at least not past small-project scale, because it still needs someone who understands the business and the tradeoffs, not just the syntax.
So the anxiety isn’t really “I forgot how to code.” It’s closer to “the ritual I used to prove competence to myself, reading every line until I owned it, doesn’t exist in the same form anymore.” That’s a real loss. But it’s a different problem than skill decay, and it’s worth being precise about which one you’re actually dealing with.
Karpathy, of all people, said something at AI Ascent this year that gets at this better than most of the imposter syndrome discourse does: “you can outsource your thinking, but you can’t outsource your understanding.” I’ve seen that line get quoted and built on a lot this year, for good reason. One of the better expansions on it compares outsourcing your understanding to skipping a rep at the gym, the output looks fine on the surface, and you get weaker without noticing until the gap is already big.
That tracks with something I already wrote about after the vibe coding thread blew up on X: the failure mode isn’t the AI, it’s disappearing from the loop. If you read every diff, argue with the model about architecture, and ask it to explain what it did and why, you end up with the same kind of understanding you used to build by typing every line yourself, just arrived at differently. If you just approve whatever comes back because it runs, you genuinely do lose the thread, and that’s not imposter syndrome, that’s just true, you don’t understand the thing you shipped.
There’s also a decent, underrated blog post from a dev going through exactly this in real time, half in love with Claude Code and half unsettled by it, frustrated by the gap between people confidently predicting intelligence will become a utility you pay for like electricity, and the much messier reality of actually pairing with these tools every day. No neat conclusion in that post, no reassurance that everything’s fine, just an honest account of feeling more capable and more uncertain at the same time. I found it more useful than most of the “how to beat imposter syndrome” listicles, because it doesn’t try to resolve the tension, it just names it.
Worth throwing in the counterpoint too: not everyone experiences this as a loss. There’s a chunk of devs, especially ones who fought the classic pre-AI version of imposter syndrome for years, who say the opposite, that using AI coding tools actually surfaced how much expertise they already had, because knowing what to ask for and when to trust the output turned out to be the hard part, and they were already better at that than they gave themselves credit for. That doesn’t cancel out the senior-dev anxiety I opened with, both things are true depending on where you’re standing, but it’s a good reminder that “AI is eroding my skills” isn’t the only honest reaction to have.
Where I land on this: the actual value was never in producing code, that’s why “code monkey” became an insult and not a compliment. The value is turning business context and domain knowledge into the thing your company actually needs, and that step hasn’t gone anywhere. If you use an LLM to skip that step entirely, you’re automating the one part of the job that was never replaceable and outsourcing the part that was, which is backwards, and yes, that will eventually make you replaceable. If you use it to think out loud with, argue with, and double check, you keep the part of the job that matters and just get faster at the part that didn’t.
And for what it’s worth, even before any of this, plenty of devs with twenty years in still wondered if they were over or underpaid, still didn’t fully trust their own competence, still felt like they were making it up as they went half the time. That was never an AI problem. Most people in this field are figuring things out in real time and getting comfortable with not knowing yet, that’s basically the job. AI changed what the not-knowing looks like day to day. It didn’t invent it.