The Management Problem: How Non-Technical Oversight Is Undermining Software Development Efficiency

The recent viral debate around engineering productivity at some of the largest tech companies has spotlighted an uncomfortable truth: inefficiencies in software development are often a byproduct of the very management systems designed to foster efficiency. While much of the discussion has focused on the “quiet quitting playbook” and developers gaming metrics, a deeper issue lies in the way non-technical managers evaluate and oversee development teams. These outdated and misguided practices stifle collaboration, demotivate high performers, and create a cycle of inefficiency that AI alone cannot fix without broader organizational change.

The Management Dilemma: Non-Technical Oversight in a Technical World

In many medium-to-large organizations, software development teams are managed by non-technical leaders who lack the experience to assess the complexities of programming. Instead, they rely on tools, metrics, and frameworks like agile, story points, velocity, and sprint success rates to measure productivity. While these methods are intended to provide structure and accountability, they often fail to capture the true nature of software development work.

For instance, consider a small development team of 8-10 people managed by someone who measures success based on story points completed during a sprint. Developers earn points for code checked in, with managers interpreting these numbers as a proxy for productivity. While this system might seem logical on paper, it introduces several harmful dynamics:

Undermining Collaboration: A developer who spends time mentoring teammates or contributing across teams—valuable work that benefits the product as a whole—receives no recognition in a points-based system.

Discouraging Efficiency: Developers who are fast and skilled, like a “friend” of mine who enjoys solving challenges efficiently, may assign themselves fewer points for a task, penalizing their performance relative to others.

Gaming the System: To avoid falling behind in such metrics, developers might inflate estimates or overstate task complexity, leading to artificial “wins” that do little to improve the product.

These systems force developers to prioritize their individual performance metrics over the needs of the team, the product, and the company’s long-term goals.

The Cycle of Inefficiency: How It Perpetuates

This culture of misaligned metrics and incentives is not new. As smaller companies grow and bring in managers from larger organizations, they often inherit these flawed practices. Over time, these systems become ingrained, creating inefficiencies that are difficult to undo. Here’s how the cycle perpetuates:

Non-Technical Managers: Lacking the expertise to evaluate technical work, managers lean heavily on metrics that fail to account for collaboration, innovation, or quality.

Metrics-Driven Development: Teams and individuals adapt their behavior to optimize for metrics rather than outcomes, prioritizing “winning the sprint” over building great software.

Lack of Feedback Loops: These systems discourage upward feedback, as developers often feel powerless to challenge management practices without risking their own standing.

When developers like my friend face these environments, they are left with unenviable choices: stop mentoring teammates, inflate estimates to pad their metrics, quietly accept their lower “rank” despite contributing in ways that truly matter, or find a new job.

Breaking the Cycle: AI and the Future of Team Management

AI has the potential to disrupt this broken model. By enabling more nuanced and real-time insights into team performance, AI tools can shift the focus from arbitrary metrics to genuine impact. For instance, AI could:

Identify Collaborative Contributions: AI tools can analyze communication patterns, code reviews, and task dependencies to highlight developers who contribute beyond their individual tasks.

Automate Metrics That Matter: Instead of relying on story points or velocity, AI could track code quality, deployment success rates, and user impact, providing a clearer picture of productivity.

Encourage Self-Management: By offering transparent insights into team performance, AI could empower developers to self-manage and collaborate without the need for overbearing oversight.

However, tools alone cannot solve the problem. Organizations must also embrace structural changes, such as:

Reevaluating Management Roles: Managers should focus on enabling teams and removing blockers, rather than micromanaging metrics they don’t fully understand.

Rewarding Collaborative Behavior: Organizations should develop systems that recognize mentorship, knowledge sharing, and teamwork as integral to success.

Cultivating Technical Leadership: Promoting and hiring only technical experts into R&D and software development leadership roles ensures that decision-makers understand the nuances of software development.

Conclusion: Toward a New Model of Development Management

The current model of software development management has created inefficiencies that undermine both individual developers and teams as a whole, which has resulted in a generation of software developers and managers that “understand“ and use the system to their own individual benefit. The rise of AI offers a chance and the tools to break this cycle, but real change requires organizations to rethink their approach to management. By focusing on collaboration, innovation, technical skills and meaningful contributions—not just metrics—companies can create environments where developers thrive and products excel.