Traditional approaches to understanding developer productivity often focus on individual performance metrics, but a new whitepaper from The Developer Success Lab and Uploop argues that this perspective is insufficient. The authors of this study present a compelling case that cumulative culture theory—the collective and social processes through which knowledge is shared and improved over time—has a far more significant influence on developer problem-solving, productivity, and innovation velocity than individualistic traits. By emphasizing the communal and social cognition aspects of developer productivity, the study offers a fresh lens on the factors driving success in software development.
The Limits of Individualistic Metrics for Developer Productivity
Many organizations rely on simple, individualistic metrics such as the number of commits or lines of code to measure developer productivity. While these metrics provide a surface-level view of performance, they fail to capture the complex realities of software development.
In a typical day, developers must tackle a range of cognitively demanding tasks, including:
- Executive functioning: Planning and organizing work efficiently.
- Creativity: Developing innovative solutions to unforeseen challenges.
- Causal reasoning: Understanding the effects of code changes on the system.
- Social learning: Collaborating and learning from peers to solve problems.
These interconnected tasks make isolating productivity into a single metric or quick fix impossible. For example, a developer encountering an unexpected roadblock may need to collaborate with teammates, communicate effectively, and maintain focus despite distractions. Interestingly, high cognitive load can sometimes improve performance. During activities like code reviews, the need for precision and attention encourages developers to allocate greater focus, enhancing the quality of their work.
Understanding productivity requires moving beyond these simplistic measures to embrace a cumulative culture theory approach that recognizes software development's collective and social dimensions. The need for a more holistic view is a significant part of why LinearB advocates using DORA metrics and the SPACE framework to take a team-based approach to measuring productivity.
The Cumulative Culture Theory of Developer Productivity
Cumulative culture theory provides a more comprehensive explanation for developer productivity by focusing on how developers build upon collective knowledge and adapt to new challenges. This theory emphasizes two main types of developer work: innovation and implementation.
Innovation is when a developer needs to create novel solutions to unforeseen challenges, and it requires cognitive flexibility, creativity, and the ability to use tools in unconventional ways. Implementation, on the other hand, involves applying existing solutions to new contexts, and this process relies on the cognitive capacity to evaluate, adapt, and reuse known tools and practices. While innovation often stems from individual creativity, you ensure implementation via social learning and imitation, resulting in refinement, sharing, and preservation. Combining both teaching and imitation is the essence of cumulative culture.
Developers engage in this process by balancing multiple objectives:
- Understanding the problem and desired outcomes.
- Navigating technical constraints and anticipating future impacts.
- Collaborating with peers to ensure their code integrates seamlessly into the more extensive system.
When cumulative culture operates effectively, it creates a “ratcheting effect,” where productivity, quality, and complexity continuously improve as teams build on collective knowledge.
Practical Applications for Engineering Leaders
To harness the benefits of cumulative culture, engineering leaders must foster both innovative and imitative work within their teams. Here’s how:
Encourage Both Imitation and Innovation. Provide structured on-ramps for adopting existing technologies while creating space for novel ideas and experimentation to thrive.
Leverage Familiar Technologies for Imitative Success. Introducing widely known technologies can smooth the adoption process. For example, Node.js revolutionized full-stack development by extending familiar JavaScript norms to backend development, enabling frontend developers to adopt full-stack roles with minimal learning curve.
Prepare for the Future with Innovative Practices. Developers should design innovations to support future imitation and adoption. For example, Rust enforces secure coding practices by default, such as requiring pre-defined data types for variables. This forward-thinking design encodes best practices into the programming language, ensuring that future developers adopt secure habits.
Conclusion
You can’t understand developer productivity in isolation. It is not just about individual performance but collective problem-solving enabled by cumulative culture. By balancing innovation and imitation, engineering leaders can create an environment where cumulative culture thrives, ensuring that productivity and quality improve over time. Read the Engineering Leader’s Guide to Developer Productivity to continue on your journey of engineering excellence.
