Build what's next on GitHub, the place for anyone from anywhere to build anything.
Join us October 28-29 in San Francisco or online for GitHub Universe, our flagship developer event uniting people, agents, and the world's code.
Collaboration is crucial to successful software delivery. Let’s dive into how AI can help your development teams decrease their time to delivery, and foster better communication and collaboration using GitHub Copilot.
When it comes to mastering DevOps, it’s often not the technical skills that trip us up, but rather the more critical aspects of collaboration and communication. Communication challenges, vague requirements, and missing documentation can leave us guessing on stakeholder intent. Plus, siloed workflows can cause teams to face inconsistencies in their processes, tooling, and time to delivery, as there are so many moving parts. This all works against DevOps best practices.
In this blog, we will look at ways that we can enhance team productivity, reduce cognitive load, and implement a more seamless collaboration across teams and tools to improve code quality and create faster delivery cycles. Adding a bit of AI into our workflows will get us on the right path.
| 💡 Tip: When using Copilot (or any generative AI), it’s always a good idea to review any suggestions before accepting them. There’s a reason we refer to GitHub Copilot as an assistant. It is meant to augment your abilities, not serve as a replacement for your skills. |
When I get started on a new project, the first thing I do is seek out the README or documentation, if there is any. While we should be writing documentation for our code as we go, the reality is that we often do not. This gap, between intention and practice, creates consistent challenges for our teams as we try to onboard new members or revisit older projects.
Nowadays, to get the documentation that I need, whether it’s working on a legacy code base or joining a new community project, I start by opening either GitHub Copilot Chat in VSCode or in the github.com immersive chat experience to ask Copilot to explain the codebase to me. And when the existing README is lacking, I can then ask Copilot to help me to write a better one.
For example, here’s a typical placeholder README:
Beyond a brief description, there’s not much information. I opened up VSCode and GitHub Copilot Chat, attaching the existing README file to give Copilot context, and asked it to simply make my README more detailed.
After asking Copilot to help create a better README, here’s how it looked:
GitHub Copilot provided a project overview, installation and configuration steps, and some usage instructions. This gives me, and anyone else who visits this project, a better understanding of what the project is doing and how to get started.
You can use GitHub Copilot not only to generate a README once you’ve written your code, but also function and class descriptions. Copilot can improve readability of code by generating descriptions, adding context around what your code is doing, and writing documentation that can reduce the learning curve and onboarding time.
For example, check out this bit of code where Copilot helped write inline comments:
Oftentimes, the various technical teams (operations, security, and development) operate independently, not fully aware of other teams’ standards, dependencies, or changes. Using Copilot to create better documentation and code comments can help us to break down these silos.
So, when we do make a code change that impacts other teams, how can we better review those changes to ensure a more seamless and secure delivery? Let’s take a look.
You know when you submit your pull request and you’re in a rush because of task overload? In the example above, we used docstrings to explain our functions and that is extremely helpful when you’re working with complex functions. Copilot can help write your docstrings to provide clear parameter explanations, detailed method descriptions, and context about usage. This helps to reduce the ambiguity for your code reviewers and provides context to the changes that were made.
When you get ready to submit your commit, instead of having to think of a funny and witty commit message yourself, select the AI-enhanced commit option and let Copilot generate a clear, concise summary of your changes for you:
How often when we are reviewing a pull request there is little to no description? We can use Copilot to help with that, too! After I have committed my code, I can use the “summary” option to generate a summary of my pull request:
Copilot reviews the commit and the files changed, and then outputs a thorough summary of the changes with links to the changed files.
Oftentimes, we submit a pull request and expect the reviewer to figure out what changes were made, as if they had a crystal ball. In this example, I’ve used Copilot to generate a short summary of the changes in my commit, as well as a longer, more detailed summary of the pull request. This saved me time, but more importantly, it has provided a much higher quality output than I would have been able to do on my own.
Copilot’s ability to summarize and document can be hugely beneficial in creating consistent terminology and communication across teams, eliminating collaboration breakdowns and enhancing code reviews.
Along with using Copilot to summarize my pull request before I send up our commit, I can also set Copilot as one of my reviewers by clicking “Reviewers” in the top right hand corner of my screen.
Once I do that, Copilot reviews my pull request before my other team members, allowing me to find typos and other errors, and iterate my code before asking others to review it. This enables me to iterate faster, getting direct feedback more quickly on my changes and lessening the time my teammates need to take to review my code. It also allows me to learn how to improve my code quality, too.
So far, I’ve used Copilot to better define the project README, add inline comments and documentation, and generate more relevant, thorough, and precise commit messages and precise pull request summaries. But most of these changes have been me acting alone—what about when I’m collaborating with my team and I run into a merge conflict? GitHub Copilot can help there, too!
Sometimes, collaboration leads to messy changes and you arrive at a difficult point, trying to decide which version to ultimately commit based on code patterns, environment variables, and comments. There are a couple different ways that Copilot can help you remediate a merge conflict.
When you’re working in the editor, specifically VSCode, it will display the conflicting section of code. You can open a Copilot Chat window or ask inline, “How should I resolve this merge conflict?” Copilot will analyze both versions of code, suggest a resolution, and explain its reasoning. If the suggestion fits, you can accept the solution or ask for alternatives.
If you’re using Copilot on github.com (and licensed for GitHub Enterprise) you can also ask Copilot why a workflow has failed. Just navigate to the pull request, select the details of the failing checks, and click on the GitHub Copilot icon next to the search bar. Then, you can ask Copilot directly, “Why has this pull request failed?”
This is a great way to find a quick resolution to a common problem, especially with long running features branches and automation tasks.
One of the fundamental challenges in building a high performing DevOps team has always been the burden of repetitive tasks that consume valuable developer time daily. By integrating Copilot into my workflow, I’ve watched it suggest entire functions and fill critical logic gaps, dramatically reducing the boilerplate code that once dominated my coding sessions. This has transformed how I work, allowing me to tackle complex architectural challenges and focus on innovation rather than implementation details.
I encourage you to explore these GitHub Copilot capabilities in your own environment. The transformation in both individual productivity and team dynamics might surprise you.
Happy coding!
