Cosmic Module

S

Qubits of DPK

March 30, 2026

Core SWE @ Google
One of the most difficult questions in software engineering is:
How do we measure the productivity of engineers?
In many industries productivity is easy to measure.
Examples:
  • Factory work → number of items produced
  • Sales → revenue generated
  • Manufacturing → units produced per hour
However, software engineering is fundamentally different.
Engineers do not simply produce “units of software”.
Instead, they build complex systems that evolve over time.
This chapter explains why measuring engineering productivity is difficult and how organizations like Google approach the problem.

Why Measuring Productivity Is Difficult

Software development involves many activities that are hard to measure directly.
Examples include:
  • designing system architecture
  • debugging complex issues
  • writing tests
  • reviewing code
  • mentoring other engineers
These activities are essential for building reliable systems but may not produce visible output immediately.
For this reason, simple metrics often fail to represent true engineering productivity.

The Problem with Simple Metrics

Many organizations attempt to measure productivity using simple numbers such as:
Although these metrics appear easy to measure, they often create misleading conclusions.

Why Lines of Code Is a Bad Metric

Measuring productivity using lines of code can produce harmful incentives.
Example:
Engineer A writes 500 lines of complex code.
Engineer B writes 50 lines of simple and efficient code that solves the same problem.
If productivity is measured by lines of code, Engineer A appears more productive even though Engineer B produced a better solution.
In many cases, less code is actually better because simpler systems are easier to maintain.

The Real Goal of Engineering Productivity

The true goal of engineering productivity is not to maximize output.
Instead, it is to maximize the value delivered by engineering work.
This includes:
  • building reliable systems
  • delivering useful features to users
  • maintaining high software quality
  • enabling engineers to work efficiently
Therefore productivity should be evaluated at the team and system level, not just the individual level.

Measuring Developer Experience

One of the key insights in this chapter is that productivity depends heavily on the developer experience.
Developer experience refers to how easy it is for engineers to perform their work.
Examples of factors affecting developer experience include:
  • build system speed
  • testing reliability
  • debugging tools
  • documentation quality
  • development environments
When these tools work well, engineers can focus on solving problems rather than fighting infrastructure.

The Impact of Slow Tools

Poor tooling can dramatically reduce engineering productivity.
Examples:
Organizations must invest in tooling infrastructure to improve productivity.

Measuring Productivity at the Team Level

Instead of measuring individuals, successful organizations evaluate team productivity.
Key indicators include:
  • speed of feature delivery
  • system reliability
  • code quality
  • collaboration effectiveness
These indicators better reflect the overall effectiveness of engineering work.

Developer Surveys

One method used by large organizations is developer experience surveys.
These surveys ask engineers questions such as:
  • Are your development tools reliable?
  • Do you understand the systems you work on?
  • Are builds fast enough?
  • Do tests give reliable feedback?
Survey results help organizations identify productivity problems that may not be visible through metrics alone.

Using Data to Improve Engineering Systems

Organizations collect data about engineering processes to identify improvement opportunities.
Examples of useful metrics include:
These metrics help engineering teams understand where productivity bottlenecks exist.

Continuous Improvement

Engineering productivity should be treated as a system that can be continuously improved.
Organizations should regularly:
  • analyze productivity metrics
  • gather feedback from engineers
  • invest in better tools and infrastructure
  • improve development processes
This approach ensures that engineers can work efficiently as systems grow larger.

The Role of Engineering Productivity Teams

Some companies create dedicated teams responsible for improving developer productivity.
These teams focus on building tools such as:
  • build systems
  • testing infrastructure
  • development environments
  • code search tools
By improving the engineering environment, these teams increase productivity across the entire organization.

Key Lessons from Chapter 7

This chapter highlights several important insights.
  1. #
    Measuring software engineering productivity is complex.
  2. #
    Simple metrics like lines of code often produce misleading results.
  3. #
    Productivity should be measured at the team level rather than the individual level.
  4. #
    Developer experience has a major impact on productivity.
  5. #
    Investing in tools and infrastructure significantly improves engineering efficiency.

Simple Explanation (For Non-Technical Readers)

Imagine a construction team building a large building.
If workers constantly wait for tools, instructions, or materials, their productivity decreases.
However, if they have:
  • good tools
  • clear plans
  • reliable equipment
they can work efficiently.
Software engineering works in the same way.
Organizations must create environments where engineers have the tools and systems they need to work effectively.