The Managerial Shift: Why AI Adoption Requires Unlearning Muscle Memory

In this conversation, LinkedIn Engineering Manager Sonali Varde maps the shift occurring within engineering teams as AI moves from a coding assistant to an operational backbone. The core idea is that AI adoption is not just a productivity upgrade. It is a fundamental restructuring of managerial and engineering workflows that exposes hidden bottlenecks in code reviews and operational rigor. The implication is that the most experienced engineers, those with deep muscle memory, often face the greatest friction in adopting these tools because their intuition is tied to legacy processes. This analysis is for engineering leaders who want to move beyond surface level token usage metrics and build systems that scale, rather than just accelerating technical debt.

The Hidden Cost of Muscle Memory

The most counterintuitive insight from Varde’s experience is that deep technical expertise can become a liability when adopting AI. Experienced engineers and managers rely on hard coded mental models, the muscle memory of which logs to check or which dashboards to monitor during an incident.

I think for somebody who has a lot more experience, it is harder because your muscle memory, your things with your code base, the things that you know, it is easier almost to do it than to like ask for how to do it.

-- Sonali Varde

When an AI agent offers a different path, the experienced practitioner often views it with skepticism, choosing to rely on their own established, manual processes. The consequence is an asymmetry of knowledge. Newer engineers, unburdened by legacy intuition, often adopt AI agents faster during high pressure moments like midnight on call shifts. To maintain a competitive edge, senior leaders must consciously unload their mental models, treating their own expertise as a legacy system that requires refactoring to accommodate AI assisted workflows.

Why Code Reviews are the New Bottleneck

As AI increases the velocity of feature building, particularly for CRUD style APIs, the system pressure shifts downstream. Varde notes that while teams are shipping more, the joy of code reviews has vanished, replaced by a massive bottleneck.

This creates a systems thinking trap. By optimizing for throughput, or the speed of initial code generation, teams have inadvertently increased the cognitive load on senior individual contributors. If the review process remains manual, the system will eventually stall. The implication is that innovation must now focus on automating the testing and deployment lifecycle. If a team is shipping 3x faster but their senior engineers are drowning in PRs, they have not increased total system capacity. They have simply moved the congestion point.

The Illusion of Productivity Metrics

Varde warns against relying on token usage as a primary metric for success. While it provides a horizontal view of adoption, it is a measure of effort, not impact. The system responds to AI by producing more code, but more code is not the goal.

The throughput metric comes with the number of experiments that the team is able to do. The number of initiatives the team is now able to ship the number of times that has reduced self inflicted incidents, if you will.

-- Sonali Varde

The true competitive advantage lies in shifting from measuring story points, an estimate of effort, to measuring the number of initiatives successfully rolled out to 100% of production. This reveals the hidden cost of AI. Teams that focus on code volume will find themselves managing an explosion of technical debt, while those that focus on operational rigor and system health will create the separation that defines high performing organizations.

The Necessity of Human-in-the-Loop Rigor

The most dangerous failure mode Varde highlights is the hallucination trap during critical incidents. When an AI agent provides a plausible but incorrect debugging path, it can misguide an engineer for an hour, compounding the severity of an outage. The system requires a human-in-the-loop to act as the ultimate validator. This is not a temporary requirement. It is a permanent feature of working with non-deterministic agents. Leaders must build a culture where first principles thinking is the primary defense against AI driven errors, ensuring that the team’s ability to debug manually remains sharp, even as they automate the routine.

Key Action Items

• Audit Your Muscle Memory (Immediate): Identify three tasks you perform by rote, such as specific log checks or recurring status updates. Intentionally delegate these to an AI agent or a custom skill to force yourself to articulate the logic rather than just following the habit.
• Shift Metrics to Outcomes (Next Quarter): Stop tracking lines of code or token usage. Realign team OKRs to focus on initiatives shipped to 100% production and reduction in self inflicted incidents.
• Formalize the Review Bottleneck (Next Quarter): If code reviews are slowing down your team, treat this as a top tier engineering problem. Invest in automated testing and PR gating agents to handle the boilerplate, allowing humans to focus on architectural integrity.
• Implement AI-Native Hiring (Ongoing): Update interview modules to include an AI native component. Evaluate candidates not on their ability to code from scratch, but on their ability to manage agents, validate outputs, and maintain critical judgment.
• Build Skills for Shared Problems (12-18 Months): Don't just build one off prompts. Develop shareable skills, which are atomic units of automation, that can be composed into agents. This creates a library of institutional knowledge that pays off as the team scales.