The engineer has been at the company three years. Senior. Knows the system well. Knew it, anyway. The codebase has been moving fast since the AI tools arrived. New services, new patterns, new surface area every sprint. The features are shipping. The metrics look clean. Someone in a leadership meeting said the word "10x" and nobody pushed back because the PRs are right there on the board, merged and closed. I was in those rooms. I said the right things about momentum.
Then something breaks. And the engineer sits down to debug it.
Six months ago, they would have known exactly where to look. Not because they're exceptional. Because they wrote the relevant code. They had the context in their hands. The muscle memory was there. You build that over years of writing, breaking, fixing, and writing again inside the same system. It lives in you before you think to use it.
Now the code was generated. The patterns aren't theirs. The structure is mostly right. And the engineer is staring at something they technically own that they don't understand at the line level. So they do what you do in that situation. They reach for AI to help them debug it.
AI writes. Human reviews. Human can't debug. Human asks AI. AI writes more.
That loop is what nobody named when the mandate came down.
The Shift Nobody Announced
The throughput is real. I'm not disputing the board.
What the board doesn't show is what the work actually became.
Before AI, a senior engineer's edge wasn't just technical skill. It was orientation. Knowing where to go. When something broke and drug them out of bed, they didn't reason from first principles every time. They had a map built from years of writing the same system. That map was the actual asset. The thing that made them genuinely senior.
AI adoption at speed is quietly erasing it.
AI is generating new surface area faster than anyone can internalize it. The senior engineer reviewing a PR today may have never touched that module. Because AI wrote it. Because the sprint was moving and there was no reason to slow down to build context when the model could generate the function in forty seconds.
The result is a codebase that is nominally owned by the team and practically understood by no one.
That's not on the engineers. That's what happens when you optimize for output faster than the team can absorb it.
The Cycle
An engineer receives an AI-generated function to review. They evaluate it. Structure, logic, edge cases. They approve it. Time was saved. Velocity moved.
Three weeks later something breaks in that function. The engineer who approved it opens the file. The code isn't wrong, exactly. But it's not theirs. They don't have the mental model for why it's structured the way it is. The instinct they would have had if they'd written it ... the one that says "this will fail under this condition" ... isn't there. Because instinct comes from authorship. You can't review your way into it.
So they reach for AI. Ask it to help trace the bug. AI generates a hypothesis. The engineer evaluates it. Maybe it's right. Maybe it isn't. Either way, another layer of generated content sits in the stack that nobody fully owns. The loop deepens.
I'm not just describing what I've watched happen on teams. This is something I've felt. When I go into a codebase to debug something I reviewed but didn't write, the instinct I used to carry isn't there. I reach for AI. The cycle continues. The more I've thought about it, the more I understand it's not a skill gap. It's a context gap. And context doesn't transfer through review.
For many senior engineers, the contrast is sharp and getting sharper. Junior engineers are building their baseline in this environment. The new way of working is just the way working works. For the people who built their careers on knowing exactly where to go, that loss is unmistakable. They feel it every time they open a file they technically approved but don't recognize at depth. They feel it in every debugging session where the first instinct is no longer instinct at all.
They just don't have permission to name it.
Instinct comes from authorship. You can't review your way into it.
What Leadership Sees
Leadership sees the board. PRs merged. Features shipped. Velocity at a number that would have seemed ambitious eighteen months ago. Someone says "AI is working." Everyone nods.
The team is quiet.
Not the quiet of focus. Not the quiet of flow state. The quiet of people navigating something unfamiliar, on the fly, without a compass, and without permission to say it's hard.
Engineers are producing output. They're also making up the methodology as they go, session by session, because nobody told them how to review AI-generated code at the pace they're being asked to review it. There's no playbook for the verification load. There's no training for the judgment work that replaced the writing work. There's a mandate and a dashboard and a stand-up.
The engineers are building the plane while flying it. Leadership is measuring how fast the plane is going.
I've heard the same story from enough people in enough orgs to know this is not an edge case. It's the pattern.
Why Mandates Make It Worse
An AI mandate doesn't just add a tool. It adds the pressure of compulsion to the fog of unfamiliarity.
Engineers who are already figuring out how to do this are now figuring it out under an org-level instruction to move faster. The pressure is real. The permission to name what it costs is gone. You don't raise your hand in an all-hands and say "I used to know this codebase and now I don't" when the company just announced AI is a strategic priority.
The senior engineers feel it most. The ones who built their careers on knowing the codebase. On being the person people came to when something broke. On having that orientation so internalized it felt like instinct. They're the quietest ones in the room. Not because things are fine. Because what they're experiencing doesn't fit the narrative, and they're not going to be the person who slows down the momentum.
That silence is not adaptation. It's people absorbing a loss they were never given language for, while being told the change is unambiguously good.
When the engineers who used to push back in planning stop asking why ... when the people who questioned the framing of a problem start accepting it and jumping straight to solution ... that's not focus. That's depletion showing up as compliance. The same signal I described in the cognitive load piece. The pattern doesn't stop at the individual day. It moves into the team's relationship with its own codebase.
That silence is not adaptation. It's people absorbing a loss they were never given language for, while being told the change is unambiguously good.
What This Requires From You
I'm not arguing against the tooling. I use it. The gains are real.
What I'm arguing for is understanding what your team is actually inside of.
Your senior engineers are not struggling because they can't adapt. They're struggling because something was taken from them that nobody acknowledged. The muscle memory. The orientation. The knowledge of exactly where to go when something breaks at an hour when you'd rather be anywhere else. That was years of accumulated context. AI adoption at speed is outrunning the ability to rebuild it. And mandates don't leave room to say so.
Before you read another velocity dashboard, ask your team one question. Not about output. About navigation.
When something breaks, do you know where to look? Are you going there because you know it, or because you're using AI to find your way back in?
If the answer is the second one, you are not watching a team that's adapting smoothly. You are watching a team in the middle of a transition they haven't been given room to name.
Meet them there. Not with a policy update. Not with a new process. With a conversation. What has actually changed for you? What do you own that you didn't write? What do you not know anymore that you used to? What does debugging feel like now compared to a year ago?
Those answers won't show up in the sprint summary. They will show up in who's still on your team in twelve months, and what shape they're in when they are.
Those answers won't show up in the sprint summary. They will show up in who's still on your team in twelve months.
The Quiet Is the Data
The throughput is real. The sustainability is not something you can see on the board.
The work didn't shrink. It shifted. From creation to judgment. From authorship to evaluation. From knowing exactly where to go to reaching for a tool that didn't write the code you're trying to understand. It is a different category of work, running at a different pace, on a team whose muscle memory was built for something else.
Your team went quiet after AI arrived. That quiet is not a sign things are going well. It's a sign your team is carrying something they don't have permission to put down.
Stop celebrating velocity. Start asking your team what they actually know anymore.
That question is harder than reading the dashboard. It's the only one worth asking before you find out the hard way.
One email a week from The Builder's Leader. The frameworks, the blind spots, and the conversations most leaders avoid. Subscribe for free.
Top comments (0)