Survey of 1,000+ GitHub Developers: Why Efficient Software Is Becoming a Must-Have

Developer Demand for Efficient Software Is Growing Louder

A new joint study by GitHub and the Yale Program on Climate Change Communication reveals strong demand among developers for tools, metrics, and practical guidance to reduce wasted compute. The survey, covering more than 1,000 GitHub users, reflects a shift in which software efficiency is moving from a niche concern to a mainstream priority.

As AI model training and inference continue to scale, cloud costs and energy consumption have become increasingly pressing issues. Developers are no longer just asking whether their code works — they're asking whether it works efficiently: consuming less compute, less power, and ultimately less money. This shift is driven by both a sense of responsibility toward sustainability and very real economic incentives.

What Developers Actually Need

Based on the directions highlighted in the study, developer needs fall into three main areas.

Usable Tools

Developers want ready-made tools that can help them identify and reduce "wasted compute." This means tools must integrate into existing development workflows rather than adding extra operational overhead. Ideally, efficiency optimization should become as routine as linting — a natural part of daily work.

"Wasted compute" refers to computational resources consumed during execution that produce no useful output. Common sources include redundant loop iterations, unused model parameters, over-provisioned cloud resources (such as virtual machines running at low utilization for extended periods), and unnecessary repeated inference requests. In large-scale AI inference scenarios, this waste is particularly significant — some research estimates that average GPU utilization in production environments consistently falls below 50%. The analogy to linting is intuitive: just as linting tools flag potential issues in real time as developers write code, an ideal efficiency tool would automatically catch inefficient patterns at the CI/CD or IDE level — without requiring developers to learn an entirely new workflow.

Reliable Measurement

"You can't improve what you can't measure" is an old adage in software engineering. The research indicates that developers need reliable ways to quantify software energy consumption and computational efficiency. The absence of unified, trustworthy measurement standards is one of the core barriers preventing efficiency optimization from gaining traction. Only when efficiency data becomes visible and comparable can developers make targeted improvement decisions.

Measuring software energy consumption faces challenges on multiple levels: at the hardware level, power consumption characteristics vary enormously across different chip architectures (CPU, GPU, TPU); in cloud environments, virtualization and resource sharing make it difficult to accurately attribute actual electricity usage to individual workloads; and at the application level, there are no widely accepted cross-language, cross-framework standard metrics comparable to FLOPs (floating-point operations) or CO₂ equivalents. Some exploratory tools — such as CodeCarbon, Scaphandre, and Green Metrics Tool — attempt to estimate carbon emissions or energy consumption at the application level, but none have achieved industry-standard status. The lack of a standardized measurement framework means optimization results across different teams cannot be compared, and makes it difficult to establish certification and incentive mechanisms for "efficient software."

Practical Guidance

Beyond tools and data, developers also want actionable best-practice guides. Abstract slogans like "write efficient code" offer limited value; what's truly useful is optimization advice tailored to specific languages, frameworks, and scenarios. This kind of practice-oriented knowledge lowers the barrier to entry for efficiency optimization.

Why This Matters More Than Ever Right Now

In the era of generative AI, compute consumption is growing exponentially. Every model inference call, every training job, carries massive electricity and hardware costs behind it. Software efficiency is therefore no longer a matter of technical aesthetics — it directly affects cost control and carbon emissions in very concrete ways.

GitHub's decision to partner with the Yale Program on Climate Change Communication is itself a signal: software efficiency and sustainability are now intertwined. For businesses, more efficient software means lower cloud bills; for the industry as a whole, it means a smaller environmental footprint. This dual incentive is gradually transforming efficiency optimization from an "optional" consideration into a "required" one.

The energy consumption of generative AI has attracted widespread attention. According to the International Energy Agency (IEA), a single GPT-4-level query consumes roughly 10 times the electricity of a standard search engine query, and training a large language model can produce carbon emissions equivalent to the entire lifecycle emissions of several automobiles. Meanwhile, major tech companies are building data centers at massive scale to meet AI compute demand, placing significant pressure on regional power grids and water resources (used for cooling). It is in this context that "Green Software Engineering" has begun to emerge as a new discipline, with organizations like the Green Software Foundation working to standardize related practices and development guidelines.

Implications for Developers and Platforms

The value of this survey lies not only in surfacing unmet needs, but also in pointing platform builders toward a clear product direction. When more than 1,000 users explicitly express demand for tools, measurement standards, and guidance, they are effectively sketching a roadmap for GitHub and the broader developer tooling ecosystem.

For individual developers, this is an opportunity to start paying active attention to computational efficiency in their projects, and to experiment with energy monitoring and performance profiling tools. For teams and enterprises, incorporating efficiency metrics into engineering evaluation frameworks and establishing internal best practices could yield meaningful returns in both cost savings and sustainability.

Efficiency optimization is evolving from the hobby of a small group of performance enthusiasts into a shared concern of the entire developer community. This research is just a starting point — the gaps in tools, standards, and knowledge that it reveals are waiting to be filled.