Productivity Used to Look Simpler
Measuring the productivity of individual developers, teams or entire organizations has never been straightforward. Various models and approaches exist, ranging from individual output metrics such as lines of code, tickets completed or story points to broader engineering frameworks like DORA metrics, flow metrics or SPACE. Yet all of these approaches eventually run into limitations.
Software development is knowledge work. Productivity therefore cannot be reduced to output alone. High output may still produce poor architecture, increasing complexity, technical debt or unnecessary functionality. At the same time, some of the most valuable engineering contributions, such as reducing complexity, improving system clarity, preventing incidents or enabling better collaboration, are difficult to measure directly.
A simplistic way of thinking about productivity is to focus on visible output: more features, more tickets, more code, more delivered functionality. Many engineering metrics implicitly follow this logic.
What changes with AI is that output can suddenly increase dramatically. But once software artifacts become significantly easier to generate, “more” no longer automatically appears valuable. AI exposes a problem that has always existed in knowledge work: output and value are not the same thing.
AI Massively Increases Output
AI-assisted development significantly reduces the marginal cost of producing software artifacts. Code can now be generated, modified and extended at a speed that would have been difficult to imagine only a few years ago. Even if many criticisms of AI-generated code are justified today, it seems difficult to deny that these tools will continue to improve, making software generation increasingly reliable over time.
In recent months, I have repeatedly heard statements suggesting that coding is becoming a solved problem. I do not believe this is entirely true. Software development still requires context, trade-offs, architectural understanding, prioritization and coordination. Generating syntactically correct code is only one part of building effective systems.
Nevertheless, the productivity gains enabled by AI across many forms of knowledge work are difficult to deny. AI coding assistants can accelerate implementation, reduce repetitive work, support exploration and lower the effort required for many common development tasks.
As a result, the overall capacity to produce software artifacts is increasing rapidly. The ability to generate output is becoming less constrained than before.
Organizations Do Not Primarily Suffer From Lack of Code
AI clearly increases implementation capacity. Features can often be delivered faster, repetitive work can be automated and certain development tasks require significantly less manual effort than before. And yet, software organizations rarely operate in environments where implementation speed alone determines overall effectiveness.
Managers typically ask for additional developers, budgets and engineering capacity whenever new initiatives emerge. Feature requests continue to grow, delivery pressure remains high and many organizations still struggle to satisfy business demand fast enough. At first glance, this appears to confirm that software development itself is the primary bottleneck.
However, many organizational challenges are not fundamentally caused by an inability to produce code. In practice, organizations often struggle far more with:
- growing system complexity,
- coordination overhead,
- fragmented ownership,
- unclear priorities,
- architectural inconsistency,
- legacy systems,
- decision latency,
- and lack of organizational focus.
Very few organizations explicitly complain that they suffer from “too little code.” What they usually experience instead is the difficulty of evolving complex systems in a coordinated and sustainable way. This distinction matters.
Increasing implementation speed does not automatically reduce complexity. In some cases, it may even accelerate the rate at which complexity grows. As the cost of generating software artifacts decreases, the limiting factor may increasingly shift toward alignment, steering, architecture and organizational coherence.
More Output Can Increase Complexity
AI can significantly improve local productivity. Individual developers and teams may implement features faster, generate code more efficiently and reduce the effort required for many routine tasks. However, higher local productivity does not automatically translate into lower organizational complexity.
As software artifacts become easier to produce, organizations may also generate:
- more services,
- more pull requests,
- more architectural decisions,
- more dependencies,
- and more system interactions.
This can increase the overall coordination effort required to evolve and maintain systems coherently over time. As the volume and speed of generated changes increase, teams may need to spend more effort reviewing, understanding and coordinating modifications across the broader system landscape. AI-generated code may still introduce architectural inconsistencies, unnecessary abstractions, duplicated logic or additional maintenance obligations if changes are not sufficiently aligned with the larger system context.
This does not mean that AI is inherently harmful for software quality or maintenance. In many situations, AI can significantly support refactoring, documentation, debugging, testing and operational work. The underlying challenge is that complexity in software organizations is not created by code alone. Complexity also emerges from interactions between teams, systems, responsibilities, dependencies and continuous change.
As a result, organizations may experience a paradoxical situation: the local efficiency of software production improves, while the global complexity of the overall system continues to grow.
Productivity Shifts From Production to Steering
Coding will remain an essential capability in software development. AI does not eliminate the need for engineers, architectural thinking or technical expertise. However, AI may gradually change where the primary organizational bottlenecks emerge.
As implementation becomes faster and software artifacts become easier to generate, other constraints become increasingly important. Organizations still need to make good decisions, maintain architectural consistency, coordinate across teams, manage interfaces between systems and reduce unnecessary complexity over time. Faster implementation alone does not solve these challenges.
In many organizations, the central problem is no longer simply producing software. The harder challenge is ensuring that systems, teams and decisions continue to evolve coherently as the pace of change increases.
This gradually shifts productivity away from pure production and more toward steering. Once many organizations gain access to similar AI capabilities, the ability to generate code quickly becomes less differentiating. More important may become the ability to provide clear context, align teams effectively, maintain system understanding and make high-quality decisions in increasingly complex environments.
In AI-assisted organizations, the limiting factor may therefore no longer be implementation capacity, but organizational coherence. The bottleneck shifts from producing software to steering increasingly complex socio-technical systems effectively.
Implications for Management and Metrics
If AI changes the nature of productivity, it also changes how organizations should think about management and measurement. Many traditional productivity metrics simply assume that higher output directly translates into higher value. More features, more tickets completed, more pull requests or more lines of code have often been interpreted as indicators of effectiveness and progress.
As AI dramatically increases the ability to generate software artifacts, this assumption becomes increasingly problematic. Pure output metrics may become less meaningful and potentially more misleading. A larger volume of AI-generated code does not automatically indicate better software systems, better customer outcomes or higher organizational effectiveness.
This increases the importance of measuring broader engineering and organizational outcomes instead of focusing primarily on production volume. Questions around system quality, maintainability, reliability, coordination overhead, delivery flow and decision quality may become more relevant than measuring raw implementation output alone.
The central management challenge therefore shifts from maximizing software production toward ensuring that increasing production capacity actually translates into sustainable organizational effectiveness and meaningful value creation.
Conclusion
AI is not simply making software development faster. It is changing the relationship between output, complexity and organizational effectiveness. For many years, software productivity was often implicitly associated with implementation capacity and visible output. More code, more features and faster delivery were widely interpreted as indicators of progress and performance. AI challenges this assumption because software artifacts can now be generated at a scale and speed that fundamentally changes the economics of production.
As implementation becomes less constrained, the central organizational challenges increasingly shift elsewhere. Complexity, coordination, architectural coherence, decision quality and organizational alignment become more important relative to the pure act of writing code. This does not reduce the importance of engineering. On the contrary, it may increase the importance of good engineering judgment, system thinking and organizational clarity.
The ability to steer complex socio-technical systems effectively may become more valuable than maximizing raw implementation output alone. AI therefore does not merely change how software is produced. It changes what organizations should optimize for and what productivity in knowledge work actually means.