In today’s development landscape having the right tools can make all the difference in your workflow and productivity. One of the tools that’s been generating a lot of buzz: GitHub Copilot Workspace . It’s designed to do more than just suggest code; it integrates with GitHub, offering the ability to start new sessions in remote workspaces tailored to various contexts, such as existing issues or new brainstorming sessions. This enables you to build, test, and run code directly in these remote environments, which the assistant can then utilize for further development. The assistant can create and edit files, allowing you to commit changes directly to GitHub via their standard workflows.

It’s important to note that GitHub Copilot Workspace is still in Technical Preview and subject to frequent changes. Whether you’re thinking of adding it to your own toolbox or are simply curious about its role in modern development, this post will highlight some of the advantages, limitations, and lessons I’ve learned so far while using GitHub Copilot Workspace for my pet projects.

The Goal

Before diving into the details and giving my opinion on GitHub Copilot Workspace, it’s important to outline the specific goals I aimed to realise. Let me share the goals for the two projects:

Add plugin support for my Maven plugin

The first project was the Maven Outdated Plugin , which I originally created to check the last published date of Maven dependencies within a project. However, Maven projects do not only consist of dependencies. They also include plugins used at build time. I wanted to expand the plugin to include these plugins in the outdated check. While seemingly not a very complex task, you (or the AI really) do need context about:

  • The Maven API to fetch the correct artifacts;
  • The way custom Maven MOJO’s (plugins) are setup and how to add additional features;
    • Both through command line and POM (XML) configuration, as well as the actual code that needs to be written to support this new configuration
  • Logic to separate dependencies from plugins and provide useful user output in the build;
  • Expand the existing response of the API I was using to fetch the data;
  • Etc…

Take a look for yourself! https://github.com/Giovds/outdated-maven-plugin/pull/74

Create a simple throwaway application to scrape RSS feeds

The second project came about when I was preparing a presentation on contributions made by our company’s Java Community. One way we recognize contributions is through published blog posts, and I wanted an overview of all the blogs they had written over the past year. Manually checking each website was not something I wanted to do, so I aimed to create a simple application to automate the process. The goal was to build a simple JAR that could be run from the command line, fetching blog posts from specified websites and filtering them by publication date. Copilot needed to generate a straightforward JAR capable of scraping RSS feeds and presenting an organised list of articles published in the given year.

The non-human touch project: https://github.com/Giovds/rss-feed-scraper

The Verdict - Should GitHub Copilot Workspace be part of your Toolbox

After using GitHub Copilot Workspace on both the Maven Outdated Plugin and the RSS scraper project, I realised that it can indeed be a powerful addition to a developer’s toolbox. However, as with any tool, its effectiveness ultimately depends on how it is used. that being said. It is surprisingly good.

GitHub

One of the most significant aspects of GitHub Copilot Workspace is its tight integration with GitHub. As the name suggests, it’s currently only available for GitHub-hosted projects. This exclusivity means that if your project isn’t on GitHub, you won’t be able to leverage the tool. However, for those who do use GitHub, this integration can be a good addition to their development process. The tool supports seamless workflows, such as launching a workspace directly from an issue, complete with relevant context to get started quickly. It also allows you to test, make edits, and commit changes to a branch, followed by opening a pull request—all without leaving the workspace and the AI support.

Definitely a Technical Preview

Despite its potential, GitHub Copilot Workspace is still in Technical Preview, and this comes with caveats. Expect to encounter bugs and inconsistencies as it continues to evolve. These issues may range from unexpected hallucinations to integration hiccups that could disrupt your workflow. This level of unpredictability is manageable for side projects and exploratory work but could be frustrating in other production-like development.

In my own experience so far, I ran into only a few issues. One noteworthy issue was that Copilot Workspace once pushed changes directly to the main branch instead of creating a pull request, bypassing pipelines since the commits were pushed through my user account as a super user. Luckily the people that work on GitHub Copilot Workspace are easy to reach, so make sure to let them know your ideas and bugs through their Discord server! Also expect some smaller issues like, moments where Copilot becomes stuck in a loop, repeatedly generating a configuration file, where you need to manually step in and break the cycle.

Find a balance in refining the prompt and writing it yourself

One of the lessons I learned was the importance of finding a balance between refining prompts for Copilot and manually coding. While Copilot Workspace can generate impressive code snippets, create new features and automate boring stuff, there are times when it needs very detailed prompts to align with specific requirements. Not only is this time consuming, but it might just not be in the right context. Striking the right balance ensures that you leverage the assistant’s strengths without becoming overly reliant on it. So you might want to let it do 80 percent of the job, and fine-tune it yourself afterwards.

Small features and Proof of Concepts

GitHub Copilot Workspace at it’s current state shines when used for small features and proof-of-concept work. In the case of the RSS scraper project, it was useful to quickly prototype and test ideas. Similarly, when adding plugin support to the Maven Outdated Plugin, Copilot sped up the early stages of feature development, allowing me to validate approaches before refining the final implementation. For these kinds of tasks, the tool’s ability to help you move swiftly from idea to implementation is a definite advantage.

Don’t trust AI

While GitHub Copilot Workspace can be a powerful assistant, it’s crucial to approach its output (just like any AI tool) with a critical eye. Think of it as working with a junior developer or an intern. Someone capable of producing useful contributions but who still requires oversight and guidance. The code it generates can often be helpful, but it’s not always optimal or entirely correct. For instance, it might overlook project-specific nuances, generate redundant or overly simplified or overly complex solutions, or even suggest patterns that don’t exist at all.

Just as you’d review and refine a team member’s work, it’s important to test and verify everything AI produces. This not only ensures the quality and reliability of your code. AI can be a great tool for efficiency and brainstorming, but the responsibility for correctness and maintainability ultimately rests with you as the developer.