Developer experience (DX) has been the talk of the town, and for many reasons. Quality DX is intrinsically tied to increased productivity, velocity and developer happiness. Organizations that invest in DX tend to see efficiency improvements and less employee churn, contributing to reduced costs.

As such, much effort is being placed on ways to improve the experience developers have with their internal workflows and tools. But what are some good models of developer experience in practice? For that, let’s turn to GitHub.

Step 1 of 7

14%

Which of the following best describes how you currently monitor and manage systems across your hybrid cloud environment?(Required)

Multiple separate tools for different environments

Multiple separate tools for different monitoring and management functions

Single consolidated dashboard

Custom built monitoring and management solution

No full monitoring and management solution

Don’t know

How valuable would it be for your monitoring and management solution to incorporate predictive analytics to help you identify and address system issues that are critical and not waste time or effort working through all the data and “noise” that is not critical?(Required)

Extremely valuable

Moderately valuable

Somewhat valuable

Slightly valuable

Not valuable

How do you most typically address potential system issues BEFORE they impact your operations?(Required)

Automated workflows and playbooks to remediate potential issues as soon as they are detected

An orchestrated response process that leverages automation, AI, and human expertise to rapidly respond to potential issues

Advanced monitoring tools such as predictive analytics and anomaly detection to proactively identify and address potential issues

Respond to issues as they arise, using manual processes and troubleshooting techniques

A combination of automated remediation, orchestrated response, and/or proactive monitoring to address potential system issues

Don’t know

Other

What methods does your organization use to control and monitor cloud/IT spending?(Required)

Centralized procurement processes

Pre-approved budget thresholds

Automated cost monitoring tools

Department-level spending controls

Regular cost audits and reviews

Cloud cost optimization platform

Approval workflows for resource provisioning

Native financial operations tools provided by the cloud provider

No formal controls in place

Don’t know

Other

Please specify:

Which methods do you rely on most to detect security vulnerabilities in your systems?(Required)

Automated scanning tools

Manual assessments

Vendor notifications

Threat modeling (for early detection)

None of these

Don’t know

Other

Please specify:

What are the TWO most common ways you prioritize vulnerabilities to address within your environment?(Required)

Based on potential impact

Based on exploitability

Regulatory compliance requirements

Based on CVSS scores

Risk-based analysis of multiple factors

First-in-first-out approach

No formal prioritization process

Don’t know

How do you typically handle system updates and security patches?(Required)

Automated updates and patches

Manually review and apply updates and patches on a regular schedule

A combination of automation and manual review

Apply updates and patches on an as-needed basis.

Outsourced update and patch management

No defined process

Don’t know

Other

Δ

GitHub, the ubiquitous code repository and version control platform, is naturally a developer-favorite tool. And internally, GitHub is constantly seeking to improve the experience its own developers have in building, deploying and maintaining software. Below, we’ll explore how GitHub approaches DX and instills these traits into its software development culture.

Allocating Time For Deep Work

The most crucial practice GitHub takes is allowing developers to enter the flow state and stay there. Dr. Eirini Kalliamvakou, staff researcher at GitHub, defines “deep work” as time blocked off intended for focus. “During that time, you experience as little interruption as possible,” she said. According to Kalliamvakou, employees at GitHub actively block off time for deep work — some teams even have “no-meeting Thursdays.”

There is research to support the benefits of allocating time for deep work. As I previously covered, one internal study of Microsoft employees found that developers who formally set aside focus time for coding experienced a significant boost in overall satisfaction and perceived productivity.

More recently, GitHub partnered with research group DX for a study, DevEx In Action, that assesses the observable outcomes of improving developer experience. Impressively, the results found that developers who dedicate significant time to deep work enjoy a 50% productivity boost.

Using AI Pair Programmers

It will come as no surprise that developers at GitHub dogfood GitHub Copilot, the AI-powered code completion tool built on OpenAI’s Codex. According to Jon Peck, senior manager, developer relations & enterprise advocacy at GitHub, Copilot is truly integrated into most of his daily tasks. “Copilot lives with me in any development environment I’m using,” he said.

Nowadays, the technology can enable complete, viable functions that are contextually and stylistically aware, he said. Furthermore, Copilot Chat now integrates into Jetbrains and VSCode, bringing it closer to the programmer’s accustomed development environment. Peck specifically highlights developer experience gains from using it for boring activities, such as building unit tests for new code or auto-summarizing the functionality of components.

Running Automation in the Background

Having more automation baked in is another way GitHub enhances its developer productivity and experience. “Developer-facing automation allows devs to stay in the flow longer, interrupting them only when something needs their attention,” said Peck.

For example, teams utilize GitHub Actions for all kinds of triggers, such as responses to new code commits or changing the state of issues, said Peck. Running asynchronous tests in the background and notifying the developer only if something breaks enables them to stay head-down in the code for more extended periods. Additionally, asynchronous communication around pull requests and code reviews can ensure teammates collaborate effectively on their own time.

These traits are often adopted in cloud-native software development cultures like GitHub. The more you can make tests and build processes run in the background, the better, explained Kalliamvakou. Plus, reducing notification fatigue is another way to ensure developers aren’t interrupted unless something really needs their attention.

Regularly Collecting Feedback

To optimize developer experience, it’s a good idea to collect developer feedback. For instance, at GitHub, their developer experience team regularly conducts internal surveys to surface areas for improvement — this helps gauge satisfaction with the amount of deep work developers are engaged in. Similarly, LinkedIn regularly collects qualitative input using an internal framework to gauge developers’ satisfaction with their tools.

GitHub also runs a newsletter to spread awareness about what new internal features they’re introducing and to regularly review the state of things. “When you introduce a developer experience initiative, you need to create awareness around it and track how people are responding over time,” said Kalliamvakou. Keeping an active tab on the success of these initiatives is a good health check to avoid burnout.

Shifting Security Left A Bit

Another area where GitHub focuses on improving developer experience is around security. Traditionally, systems perform security scanning after all code is committed. However, this can be a big pain to go back and fix, especially when you need to track down multiple dependencies and don’t have great visibility.

“The closer you get security scanning to the point where the vulnerability was created, the easier it will be to remediate it,” said Peck. Shifting left to detect potential vulnerabilities in the moment and offering “one-click to remediate” options can significantly enhance the developer experience. He also described how GitHub engineers dogfood GitHub’s advanced security features to perform things like ongoing secrets scanning, input sanitization and pattern-based analysis.

Making Processes Understandable and Intuitive

Interestingly, the DevEx in Action study found that developers who report a high degree of understanding of their code feel 42% more productive than those with low or no understanding. So then, how can we enhance our understanding of code?

Often, a developer might forget the context behind something they wrote last year, or something a teammate programmed might seem obfuscated. This is another area where AI could be utilized to generate documentation automatically. However, the future of code understandability goes beyond just static documentation.

“The trend is toward learnability right where they are, to keep them in the flow,” said Kalliamvakou. She indicates that AI-driven insights embedded into the IDE that explain what a program or function means make the developer workflow highly intuitive.

Offering Cloud-Based IDEs

Developers often run into the “works on my machine” problem, which can be a big developer experience hurdle. In essence, applications depend on far more than just the code — they are at the whim of the environment, local dependencies, its configurations, and the actual device running the program.

By using cloud-based IDE like Codespaces, said Peck, GitHub developers are able to spin up a container in the cloud and retain the same configurations. The benefit of this is that you can keep your local editing experience as well, he said.

Retaining An Engaged Developer Experience

According to Kalliamvakou, the benefits of developer experience are no longer just anecdotal — we now have real-world evidence to back up these claims. For instance, developers who find their work engaging feel 30% more productive, according to the aforementioned report.

It seems that having an AI coding assistant by your side trained on a large language model (LLM) can encourage developer satisfaction and productivity gains. Introducing AI-based tooling can help automate away some of the unfulfilling work, leaving more time for more engaging activities, said Kalliamvakou.

But although AI can solve many things, there will always be some degree of toil. Kalliamvakou recommends distributing grunt work across multiple employees and avoiding throwing it all on one person! At GitHub, the DevEx team also analyzes the efficiency of meetings to remove non-high-quality meetings, which can also benefit engagement.