GitHub Next Logo

Copilot Workspace

How can developers overcome the high effort of getting started on complex tasks and truly collaborate with AI to make progress quickly?

What's it for?
Simplifying the process of making repo-wide edits, using verifiable AI-generated plans and code
Research prototype
Who made it?

How often have you been faced with a task that involves a repo, programming language or framework you are not familiar with? Not knowing where to start can be overwhelming, and the mental effort needed to make sense of the task and its context in order to decide what to do can be just enough to keep you from going into the task at all. So maybe you don’t send a PR to fix that bug you came across in an open source project, or address that issue in your own project that would require you to learn a new skill. Copilot Workspace is our exploration to help you with exactly these challenges.

Copilot Workspace is a reimagined developer inner loop. The focal points of the experience are selecting a task, expressing intent, and then collaborating with AI towards a solution. We believe this can dramatically reduce complexity, improve productivity, and delight developers, without taking away the aspects of software development that they value most, such as decision making, creativity, and ownership.

You can give Copilot Workspace an issue and it will automatically propose a solution. Copilot Workspace has the full context of both the issue -- including all comments and replies -- and of your codebase, so it understands both what you are trying to do and the specifics of your code. If the solution Copilot Workspace proposed isn’t quite right, you can edit any step of the process, from behavior, to plan, to code, all in natural language.

The current generation of AI developer tools operates like a second pair of hands, helping developers get through tedious and repetitive tasks quickly. Copilot Workspace showcases a new generation of AI developer tools that can be a second brain for developers and help with larger, more complex tasks. Copilot Workspace operates at the granularity of an entire repo and makes coherent changes to multiple files across different programming languages. It can handle both core coding tasks and scaffolding-type tasks like “set up a testing framework” or “write a GitHub Actions workflow for continuous integration.”

We are already dogfooding Copilot Workspace in GitHub Next, both for developing Copilot Workspace itself and for other projects. Even though it’s early, we are already seeing practical value, and we only expect our usage of it to increase.

Task-centric workflow

Copilot Workspace is intended to help developers complete full development tasks, which are often specified and tracked as GitHub Issues. Therefore Copilot Workspace can take an issue as input and automatically extract the current behavior of the code, propose new behaviors that would address the issue, formulate a plan, and implement the plan (i.e., write the code). Copilot Workspace has the full context of the issue, including all comments, and can even follow links from the issue to extract information to help it complete the task.

User feedback and iteration are a first-class concept in Copilot Workspace. You can edit every step of the process, from proposed new behavior, to plan, to implementation. For example, after implementing a plan and seeing the code, you can go back and tweak the behavior or plan and try again. You can even open the same issue in multiple tabs and explore a few different paths.

Prior attempts at completing developer tasks with LLMs have focused on chat, but we believe that Copilot Workspace’s more structured task-based UI has clear advantages:

  1. The full context of the issue is available to Copilot Workspace to help it propose the right solution.
  2. The structured outputs (original and modified behaviors, plan, and implementation) make it easy to steer Copilot Workspace at just the right level of abstraction.

Currently Copilot Workspace starts with an issue, but over time, we’ll add support for other entrypoints. For example, Copilot Workspace could help developers address security alerts found through CodeQL, migrate to new versions of dependencies or from one library to another, and resolve comments on a PR review.

Cloud-powered agent

LLMs are not perfect, and the tasks we are asking Copilot Workspace to complete are complicated and not fully specified. Therefore, it’s critical to make it easy to validate that what Copilot Workspace has proposed matches the user’s intent.

We enable this validation through a combination of AI agent technology and GitHub Codespaces as headless, ephemeral, secure compute. When the user clicks the “Run” button, behind the scenes we create a new codespace, push the modified code to it, and attempt to build the project. If the build fails, we feed the error message and code back into Copilot Workspace and ask it to repair the build. Once the build succeeds, we sync the modified code back into the Copilot Workspace UI, so the user can see how the build was repaired. Finally, we run the project, and, if it’s a web app, we forward the port on the codespace to a URL that can be accessed only by that user. The user can click and see a live preview of the web app, letting them visually verify that Copilot Workspace did what they were expecting.

Because LLMs are not perfect, we expect many tasks to require “last mile” finishes, and so Copilot Workspace lets you open the Codespace and pick up from where it left off, so that you can finish the task in a full cloud IDE with a secure runtime.

We plan to extend our agent to other tasks, such as debugging, test execution and repair, performance profiling, etc. -- any task that needs a live development environment.

Designed for collaboration

Copilot Workspace makes it easy to share a workspace by simply clicking the “Share” button. This makes it easy to share your state with your teammates and encourage collaboration. Since the UX is structured, it captures the entire activity log of a session, which is a great way to understand why the implementation proposal is the way it is. In addition, we’ve designed the Copilot Workspace experience to feel a bit like a code review with AI. You can see the plan, watch each step as it is implemented, and then navigate to the respective code change(s) by clicking on the plan step in the UI. This can pave the way for a rich form of code review, in which not only the code diff but the reasons for the code diff are clear to the reviewer.

Over time, we expect to add commenting and multi-player editing. Once that happens, Copilot Workspace will be able to handle both the developer inner loop and review loop in one tool.

What's next?

We are very excited to share our progress on Copilot Workspace, and we would love to hear your thoughts! Tweet us at @GitHubNext or send us an email at