| Before filtering | 453 |After filtering | 454 |
|---|---|
| Before filtering | 468 |After filtering | 469 |
|---|---|
| Entrypoint | 8 |Screenshot | 9 |
|---|---|
|
12 | GitHub Issue If you've already got a GitHub issue which describes a task you'd like to perform, then you can simply open the issue and click the "Open in Workspace" button on the right side panel (underneath the "Development" section). This will open the issue within Copilot Workspace, and begin analyzing how to solve it. 13 | |
14 |
15 | |
17 |
|
20 | Ad-hoc task (CW dashboard) If you open the Copilot Workspace dashboard, you can click the "Choose a repository" option underneath the "Start a new session" section. This will let you search for the repository you want to work on, and after selecting it, will allow you to define a new task from scratch (kind of like a draft issue). And after you've performed a task against a repository, it will appear in the session list under the "Start a new session" section on the dashboard. That way, you can easily start new tasks against projects you're actively working on. 21 | |
22 |
23 | |
25 |
|
28 | Ad-hoc task (repo page) As an alternative to the previous entrypoint, you can also navigate to the repository page for the project you'd like to work on, click the green "Code" button, and enter in a new task from the "Copilot" tab. Once you submit the task, it will take you into Copilot Workspace and begin analyzing how to solve it. 29 | |
30 |
31 | |
33 |
22 |
23 | *A fully-implemented workspace session*
24 |
25 | ## Features
26 |
27 | 1. [Task](#task)
28 | 1. [Specification](#specification)
29 | 1. [Plan](#plan)
30 | 1. [Implementation](#implementation)
31 | 1. [Iterating on Files](#iterating-on-files)
32 | 1. [Integrated Terminal](#integrated-terminal)
33 | 1. [Session Sharing](#session-sharing)
34 | 1. [Task Completion](#task-completion)
35 | 1. [Session Dashboard](#session-dashboard)
36 |
37 | ## Task
38 |
39 | Everything in Copilot Workspace begins with a “task”, which is a natural language description of intent. The task always has a context: a GitHub repository.
40 | For this technical preview, Copilot Workspace supports four types of tasks: solving issues, refining pull requests, [creating repositories from templates](creating-repos.md) and ad-hoc tasks. Here we focus on solving issues, which are the most common entry point.
41 |
42 | Once enrolled in the technical preview, then on every issue in GitHub you will find a new "Open in Workspace" button:
43 |
44 | 
45 |
46 | *Open an issue in Copilot Workspace*
47 |
48 | This will open Copilot Workspace contextualized to this issue. For issue tasks, the task is based in the title and body of the issue, plus the issue’s comment thread. Copilot Workspace will immediately progress to the next step in the timeline. This looks like this:
49 |
50 | 
51 |
52 | *The task is labeled as “Issue” and analysis begins*
53 |
54 | ## Specification
55 |
56 | In order to help summarize a non-trivial task definition (e.g. an issue with a long comment thread), Copilot Workspace first generates a “topic” for the task, which takes the form of a question that can be posed against the codebase, and used to define the before/after success criteria (see the [specification](#specification) section below).
57 |
58 | 
59 |
60 | *Note how the topic introduces clarity that is completely missing from the issue title*
61 |
62 | You can think of the topic as a way to distill the task down to its essence, and to give you an early and fast opportunity to see if Copilot Workspace is on the right track. If the topic is wrong, you don't need to continue. But if the topic is right, it helps you better understand the task, and to focus on the most important aspects of the codebase that are relevant to the task.
63 |
64 | After producing the topic, Copilot Workspace generates a bulleted list describing the current behavior of the codebase, based on the task and topic being posed. This helps build your confidence that Copilot Workspace is on the right track, and serves as a means of onboarding you to the context, in cases where you might not fully understand the current state.
65 |
66 | 
67 |
68 | *The current specification answers the question in the topic based on the current state*
69 |
70 | And if Copilot Workspace gets anything wrong, then you can easily edit/delete steps from the current spec, or even choose to regenerate an entirely new spec (“try again”). In practice, we find that these tend to be pretty good on the first try.
71 |
72 | After the current specification, Copilot Workspace generates a “proposed specification”, which is a bulleted list which articulates the state that the codebase would be in after resolving the task (effectively answering the question in the topic). And in particular, the proposed specification is focused on defining the success criteria of the task, as opposed to getting into implementation details (which is the role of the [plan](#plan)).
73 |
74 | 
75 |
76 | *The proposed specification indicates how to edit the codebase in order to solve the task*
77 |
78 | ## Content Selection
79 |
80 | To generate the current and proposed specifications, and for all following steps, Copilot Workspace needs to identify which files in the codebase are relevant to understanding and completing the task. It does this by a combination of LLM techniques and traditional code search. The contents of the highest-ranked files are then used as context for nearly all steps in the workflow.
81 |
82 | Users may review the files selected by Copilot Workspace using the "View references" button in the Specification panel. To adjust which files are selected, users can edit the task and use natural language to specify which files are relevant.
83 |
84 | 
85 |
86 | *The references that the model used to generate the original and modified specifications*
87 |
88 | ## Plan
89 |
90 | Once you are happy with the current and proposed specs, you can request Copilot Workspace to generate a plan, which is a list of the files that need to be modified (e.g. edited, created, deleted, moved, or renamed) in order to accomplish the success criteria of the proposed spec. Additionally, each changed file includes a list of specific steps that indicate the exact changes that need to be made.
91 |
92 | Like the spec, the plan is fully editable and regeneratable, which allows you to refine and steer Copilot Workspace in the right direction.
93 |
94 | 
95 |
96 | *A plan, showing the steps needed to edit one file and add a second one*
97 |
98 | ## Implementation
99 |
100 | When you are happy with the plan, you can click the “Implement” button in order to begin implementing it. This will update the UI to display a series of queued file updates on the right side, and then begin generating the updated file contents one-by-one. When a file begins generating, its associated entry in the plan will show it as being in progress. And when it completes, the plan will indicate it as being done.
101 |
102 | Once a file is implemented, Copilot Workspace renders a diff view for it, and automatically scrolls to the first change. The diff editors are editable, which allows making minor tweaks directly to the code, as opposed to iterating via changes to the task, spec, or plan.
103 |
104 | ## Iterating on Files
105 |
106 | Copilot Workspace doesn't always get everything right, and so it makes it easy for users to iterate on the implementations file by file. Simply add, remove, edit the items in the plan steps for each file, select the checkbox, and click the "Update selected files" button. This will re-generate the contents of the selected files and update the diff view.
107 |
108 | For example, you can edit the diff directly, or you can go back to the plan and make changes there. And if you need to make more extensive changes, you can regenerate the plan entirely.
109 |
110 | 
111 |
112 | *The plan panel enables users to iterate on implementation file by file*
113 |
114 | ## Integrated Terminal
115 |
116 | Once you have implemented the plan, Copilot Workspace enables you to validate the changes for correctness by bringing up an integrated terminal and executing shell commands. This allows performing a build, lint, test, etc. against the changes, and can be a quick and effective way to gain confidence about the task and its completion status. The terminal is backed by a Codespace, so it is a secure sandbox with a full development environment installed.
117 |
118 | 
119 |
120 | *Integrated terminal, showing the generated branch name and access to just-in-time compute*
121 |
122 | If you want to make any more extensive changes or leverage rich editor features (e.g. step debugging), you can open the Copilot Workspace session in a Codespace, using any of Codespace’s supported clients.
123 |
124 | ## Session Sharing
125 |
126 | In order to make it easy to share a workspace session with others (e.g. for doing an ad-hoc code review or sharing an initial implementation idea), Copilot Workspace allows users to generate shared links. These links can be shared with guests, even if they are not part of the Copilot Workspace preview.
127 |
128 | Shared sessions are copies of the original session. Non-guest users can use them as a starting point to continue the task or explore alternative solutions without interfering with the original session. Guest users can view the session but cannot use the workspace to make changes.
129 |
130 | 
131 |
132 | *Generating a share link from the header bar*
133 |
134 | When working with issues and pull requests, you can also
135 |
136 | * Publish to issue comment. Copilot Workspace automatically generates a comment with a share link for the session, which is included in the issue. This allows reviewers to quickly access the workspace session and see the proposed changes.
137 |
138 | * Publish to pull request comment. Similar to the issue comment, Copilot Workspace automatically generates a comment with a share link for the session, which is included in the pull request. This allows reviewers to quickly access the workspace session and see the proposed changes.
139 |
140 | ## Task Completion
141 |
142 | When a task is implemented, validated, and reviewed, you can complete the task in different ways, depending on the type of task you’re working on.
143 |
144 | 
145 |
146 | *Creating a pull request for the implemented changes*
147 |
148 | | Task type | Available completions |
149 | |-----------| -------------------- |
150 | | Issue | — Create pull request 
160 |
161 | *The Copilot Workspace dashboard showing recent, bookmarked and completed sessions*
162 |
163 | Undo and redo are supported within the session via buttons on the toolbar.
164 |
165 | ## Appendix: Glossary
166 |
167 | | Term | Definition |
168 | |------|------------|
169 | | Copilot Workspace | A Copilot-native dev environment that’s designed for exploring and completing every day tasks |
170 | | Target | A branch of a codebase at a specific commit |
171 | | Task | A natural language description of a change to a target |
172 | | Topic | A brief single-sentence summary of a task, usually in question form |
173 | | Specification | A description of the current and proposed state of the target as it relates to the task |
174 | | Plan | A list of files to add, remove or change, with notes about each of them, that together transform the target from its current state to its proposed state |
175 | | Implementation | A set of changes to the target that, when applied, will complete the task |
176 | | Session | A user’s saved progress towards completing a task, a single task can have many sessions |
177 | | Snapshot session | A snapshot of a user’s session, created when you click “Share link”, including both the task progress and UX state |
178 |
--------------------------------------------------------------------------------
/repo-maintainers.md:
--------------------------------------------------------------------------------
1 | # Copilot Workspace for Repository Maintainers
2 |
3 | Copilot Workspace can assist you as a repository maintainer in several ways:
4 |
5 | 1. Copilot Workspace can help you explore potential solutions to issues.
6 | 2. Copilot Workspace can help you generate sketches of solutions to issues for potential contributors, lowering the barrier of entry.
7 | 3. Copilot Workspace can help encourage a culture where issue-creators leave additional helpful notes on how to solve issues, for use by both contributors and AI assistants.
8 |
9 | For example, when a new issue is filed in your repository, you can use Copilot Workspace to generate a sketch of a solution to the issue. You can then use the "Share" button to publish this sketch back to the issue thread, with additional comments about whether you think it is useful or not, and where it might need improvement. This can help potential contributors understand the problem better and provide a starting point for their work.
10 |
11 | Similarly, when a new issue is filed, you can ask the contributor to create a Copilot Workspace session for the issue. This may help the contributor understand the problem better and provide a starting point for their work. You can also include this guidance in the issue template for your repository, assuming your users have access to Copilot Workspace. You can also ask contributors to leave additional notes in the Copilot Workspace session, which can help future contributors and AI assistants understand the problem better.
12 |
13 | ## Restricting the use of Copilot Workspace in your repository
14 |
15 | It is possible for undisciplined contributors to over-use AI-assisted code generation. Because of this, we give repository maintainers the option of disabling the direct use of Copilot Workspaces for creating pull requests and/or issue comments in their repositories.
16 |
17 | To disable the direct creation of pull requests using Copilot Workspace, create a file `.github/copilot-workspace/policy.json` in the default branch of the repository containing the following content:
18 |
19 | ```json
20 | {
21 | "allowPullRequests": false
22 | }
23 | ```
24 |
25 | To disable the use of Copilot Workspace to directly generate issue comments that contain links to Copilot Workspace sessions, add the following content to the `policy.json` file:
26 |
27 | ```json
28 | {
29 | "allowComments": false
30 | }
31 | ```
32 |
33 | Users of Copilot Workspace will still be able to:
34 |
35 | - create sharing links to Copilot Workspace sessions and paste them into issue comments
36 | - push to new branches in your repository (if they have write access)
37 | - push to new branches in forks of your repository
38 | - manually create pull requests from branches
39 | - use Copilot Workspace to generate code snippets and files for their own use in their own pull requests and issue comments to your repository
40 |
--------------------------------------------------------------------------------
/responsible-ai-faq.md:
--------------------------------------------------------------------------------
1 | # Responsible AI FAQ
2 |
3 | ## What is Copilot Workspace?
4 |
5 | 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.
6 |
7 | ## What can Copilot Workspace do?
8 |
9 | Copilot Workspace takes in a development task from a user, for example, a GitHub Issue, and produces a natural-language specification of the current behavior of the code, a plan for how to modify the code to complete the task, and eventually the actual code changes to all relevant files in the repo. Each step (task, spec, plan, and implementation) is editable by the user, enabling the user to steer the AI to complete the task in the best way.
10 |
11 | ## What is/are Copilot Workspace’s intended use(s)?
12 |
13 | Copilot Workspace is intended to:
14 |
15 | 1. Accelerate software developers, helping them make small- and medium-scale code changes quickly and correctly.
16 | 2. Reduce the activation energy for developers to start tasks, by giving them an AI-generated starting point.
17 | 3. Help experienced developers work with unfamiliar programming languages and frameworks.
18 | 4. Help developers contribute to unfamiliar codebases, for example, to open source projects.
19 |
20 | ## How was Copilot Workspace evaluated? What metrics are used to measure performance?
21 |
22 | Copilot Workspace was evaluated in the following ways:
23 |
24 | * Offline evaluations. We have a corpus of known tasks and an entrypoint that allows us to run Copilot Workspace over those tasks in a headless mode. When we make changes to our prompts, switch to a different model, etc., we run those benchmarks and manually validate the changes to Copilot Workspace’s outputs. If we see regressions, we iterate on the prompts until there are no more regressions. In addition, we have a larger set of benchmarks that are mined from GitHub, and we use model-driven evaluations to ensure consistent quality.
25 | * User studies. In January, we ran a round of user studies with GitHub employees where we gave them a standard task and asked them to complete the task using Copilot Workspace. We are planning additional user studies as part of the Technical Preview.
26 | * Extensive dogfooding within our team. We used Copilot Workspace to build Copilot Workspace.
27 | * Red teaming. We have prepared a set of malicious prompts and run Copilot Workspace in headless mode over those prompts. Then we do both human- and model-driven evaluations of the output for harmful responses, and if we see those, we update our prompts and filters so that users do not encounter them.
28 |
29 | ## What are the limitations of Copilot Workspace? How can users minimize the impact of Copilot Workspace’s limitations when using the system?
30 |
31 | Copilot Workspace is not always correct. Users should carefully validate its output and should not blindly trust it. If users detect inaccuracies in Copilot Workspace’s outputs, we have made it easy for them to edit and correct any model-generated outputs. We have also built validation tools, particularly a terminal which allows the user to execute the generated code in a sandboxed environment. The user should use these tools to validate and correct Copilot Workspace’s outputs.
32 |
33 | ## What operational factors and settings allow for effective and responsible use of Copilot Workspace?
34 |
35 | Copilot Workspace will perform best on common programming languages and frameworks and when the natural language is English.
36 |
37 | Code generated by Copilot Workspace should be held to the same standard as human-written code – it should be code reviewed, have automated tests, be analyzed by linters and static analyzers, etc. Copilot Workspace can help add automated tests to in-progress PRs, helping improve the overall health of a software project.
38 |
39 | ## What should a user do if they encounter offensive content while using Copilot Workspace?
40 |
41 | Please report any examples of offensive content to copilot-safety@github.com. Please include a share link so that we can investigate.
--------------------------------------------------------------------------------
/settings.md:
--------------------------------------------------------------------------------
1 | # Copilot Workspace Settings
2 |
3 | These settings are preferences for how you want Copilot Workspace to behave with your workflows.
4 |
5 | ## Collapse timeline on implement
6 |
7 | When this setting is enabled, the timeline panel on the left side of the workspace will automatically collapse after you click the "Implement" button. This allows you to focus more on the code changes and less on the timeline, while still being able to revise with natural language.
8 |
9 | ## Spin up a codespace when a session is created
10 |
11 | When this setting is enabled, a Codespace will be automatically created when you start a new session. This provides a full development environment with language services, making it easier to work on your tasks. Note that selecting this option may cause code generated by Copilot Workspace to be executed before you are able to review it. By selecting this, you acknowledge the risks of auto-running AI-generated code.
12 |
13 | ## Spin up a codespace on start of implement
14 |
15 | When this setting is enabled, a Codespace will be automatically created when you click the "Implement" button. This provides a full development environment with language services, making it easier to work on your tasks. Note that selecting this option may cause code generated by Copilot Workspace to be executed before you are able to review it. By selecting this option, you acknowledge the risks of auto-running AI-generated code.
16 |
17 | ## Show notification after implementing
18 |
19 | When this setting is enabled, Copilot Workspace will notify you when it has completed its implementation. This allows you to get back into the flow as soon as possible, without having to constantly check the status of the implementation. You can enable or disable this setting based on your preference.
20 |
--------------------------------------------------------------------------------
/tips-and-tricks.md:
--------------------------------------------------------------------------------
1 | # Tips and Tricks
2 |
3 | This document contains assorted tips and tricks for using Copilot Workspace effectively. We'd love to hear your tips and tricks, too! Please share them with us in [feedback channels](README.md#feedback).
4 |
5 | ## Edit the Issue or Task
6 |
7 | ✨ TIP: You can edit the issue or task to guide Copilot Workspace.
8 |
9 | The Issue/Task panel may be prepopulated with content depending on how you entered Copilot Workspace. For example, if you started from an Issue, the Issue panel will be prepopulated with the content of the issue. This content is ephemeral -- edits aren't synced back to the issue -- and so feel free to edit it to provide more context or to steer Copilot Workspace towards better results.
10 |
11 | ## Tasks can be short!
12 |
13 | ✨ TIP: You might be surprised at the effectiveness of simple tasks like "Add unit tests"
14 |
15 | Tasks don't have to be long. Simple, clear statements of intent like "Switch to use Python numpy" or "Add more unit tests for the server code" can get you a long way. You can easily add more clarification and iterate.
16 |
17 | ## Clarify the Issue or Task
18 |
19 | ✨ TIP: A few words clarifications can make a huge difference!
20 |
21 | Just a few words of clarification can make a big difference in the quality of the results you get. For example,
22 |
23 | * _add corresponding unit tests in `test/server`_ or
24 |
25 | * _the problem is in the convolution code_ or
26 |
27 | * _don't change any existing code just add unit tests_
28 |
29 | are examples of useful clarifications. Use as many of these as you like!
30 |
31 | ## Consider using Examples
32 |
33 | ✨ TIP: Giving examples of what you want can be a great way to clarify a task
34 |
35 | For example, you can say: _Here are some examples of command line invocations that should work after the change..._ and give a few examples. Or you can say: _Here are some examples of the expected output..._ and give a few examples.
36 |
37 | ## Check the Topic and Specification
38 |
39 | ✨ TIP: Check the topic and specification - if they're accurate, then Copilot Workspace is on the right track
40 |
41 | The Topic is your first quick glimpse of Copilot Workspace's analysis of your task in the context of your repository, and the Current Specification follows soon after, then the Updated Specification. If these are accurate, then Copilot Workspace is on the right track. If they're not, then you may need to provide more context, clarifications and hints in the Issue/Task panel, or you may be performing something beyond Copilot Workspace's current capabilities.
42 |
43 | You can edit all of these to correct them, and checking them quickly can save you a lot of time. You can also go back and clarify the issue or task and try again.
44 |
45 | ## Check the Content Selection
46 |
47 | ✨ TIP: Check the content selection and use short notes in the issue or task to say where to look
48 |
49 | You can [check the content selection used](overview.md#content-selection). Often the content selection can be improved, and right now you do this through natural language and notes on the issue/task. If you know where the code that needs to be changed is, you can say so in the issue/task panel. For example, you can say: _Look in `src/server.js`_ or many other variations.
50 |
51 | To determine how to address a task, Copilot Workspace must determine which files in a repo are relevant to the task. This is hard, and Copilot Workspace may not always select the right files. If that happens, you may see low-quality results.
52 |
53 | To review the files that were selected, in the Specification panel, click the "View references" button:
54 |
55 |
56 |
57 | To steer Copilot Workspace towards better file selection, you can mention file names, directory names, etc. in the issue/task panel. Just write it naturally, as if you were writing a normal issue.
58 |
59 | ## If at First You Don't Succeed...
60 |
61 | ✨ TIP: Try regenerating the spec or plan
62 |
63 | If you're not happy with the results you're getting, you can try regenerating the spec and/or plan. To do this, click the "Regenerate" button in the Spec or Plan panels:
64 |
65 | 
66 |
67 | ## Iterating on the Implementation
68 |
69 | ✨ TIP: Add short notes to files in the plan, then iterate
70 |
71 | Often Copilot Workspace will get a task *mostly right*, but may have trouble with some parts. In this case, you can reimplement specific files with new or additional instructions. After implementing and reviewing the code, you can select file(s) in the Plan panel and add bullet points, then click "Update selected files" to reimplement those file(s) with the new instructions that you've provided.
72 |
73 |
74 |
75 | ## Add New Files and Iterate
76 |
77 | ✨ TIP: You can add new files and iterate on the implementation
78 |
79 | If you need to add new files to the implementation, you can do so by clicking the "Add file" button in the Plan panel. This will add a new file to the plan, which you can then implement and iterate on.
80 |
81 | ## Consider Generating New Files
82 |
83 | ✨ TIP: Generating new files can be better than appending to existing files
84 |
85 | This technical preview of Copilot Workspace uses "whole file rewriting". This means that when you ask Copilot Workspace to add code to a file, it will replace the entire file with the new code. When performing tasks like writing unit tests or generating documentation or new implementation code, it can be easier and quicker to generate new files, then rename them.
86 |
87 | ## Share Early, Share Often
88 |
89 | ✨ TIP: You can share your session at any time, including with people who are not part of the Copilot Workspace preview.
90 |
91 | You can share your Copilot Workspace session with others by clicking the "Share" button in the top right corner of the screen. This will generate a link that you can share with others. These links can be shared with guests, even if they are not part of the Copilot Workspace preview. They will need to log in with their GitHub account to view the session.
92 |
93 | Shared sessions are copies of the original session. Non-guest users can use them as a starting point to continue the task or explore alternative solutions without interfering with the original session. Guest users can view the session but cannot use the workspace to make changes.
94 |
95 |
96 |
97 | ## Use the Sessions
98 |
99 | ✨ TIP: Return to your work at any time
100 |
101 | Your sessions are automatically saved, so you won't lose work if you close the browser or navigate away from the page. You can return to your session by going to [your Copilot Workspace dashboard](https://copilot-workspace.githubnext.com).
102 |
103 | ## Configure the Terminal for Your Repository
104 |
105 | ✨ TIP: Set up a `devcontainer.json` file in your repository to configure the terminal
106 |
107 | We provide a built-in terminal so that you can validate the code changes that Copilot Workspace suggests. We use GitHub Codespaces to provide this terminal, and we use the `devcontainer.json` file in your repository to configure the container that powers the terminal. If you need to make changes to the default container to e.g. install necessary software, etc., you can do so by creating a `devcontainer.json` file in your repository. Learn more about Development Containers at https://containers.dev/.
108 |
109 | ## Use the Codespace
110 |
111 | ✨ TIP: Full editing in the Codespace is simple and quick
112 |
113 | Modified files are two-way-synced between Copilot Workspace and the terminal/Codespace. Feel free to edit in either place, and your changes will be reflected in the other.
114 |
115 | Check out [Codespaces Guide](./codespaces-guide.md) for more information.
116 |
117 | ## Explore the Experiments!
118 |
119 | ✨ TIP: Explore our experiments and send us feedback!
120 |
121 | We're always trying new things in Copilot Workspace. You can opt into our current experiments by clicking on your avatar in the top right corner of the screen and selecting "Experiments":
122 |
123 | 
124 |
125 | ## Work Around Model "Laziness"
126 |
127 | ✨ TIP: If the model is "lazy" and elides chunks of edited files, copy and paste the missing parts from the diff
128 |
129 | Sometimes the model will be "lazy" and elide chunks of edited files. If you see this happening, you can copy the missing parts from the left-hand side of the diff and paste them into the right-hand side. We know that's not ideal, and we're working hard on this issue.
130 |
131 | ## Edit code in Copilot Workspace
132 |
133 | ✨ TIP: Make edits directly in the code editors per file
134 |
135 | When Copilot Workspace has generated a suggestion, it is presented to you in the implementation panel. But those suggestions aren’t just read-only! You can edit them, and make changes as you desire.
136 |
137 | 
138 |
139 | And if you have a GitHub Codespace open, those edits will sync between Copilot Workspace and the GitHub Codespace too!
140 |
141 | ## Need to go back?
142 |
143 | ✨ TIP: You can use the undo and redo buttons to travel between an older and newer state of your workspace.
144 |
145 | You can use the undo and redo buttons to navigate back to a previous state of your workspace. That can include reverting an implementation, or the additions and tweaks that you may have made to your spec or plan.
146 |
147 | 
148 |
149 |
150 | ## On the go? Try Copilot Workspace on Mobile
151 |
152 | ✨ TIP: Copilot Workspace is mobile-friendly, so consider making changes on the go!
153 |
154 | Ideas can happen anywhere, whether you’re at your desk, in a coffee shop or on a bus. With that spark of creativity, you can use Copilot Workspace from your mobile to explore ideas! And if you didn’t fully complete your task, you can use the dashboard in Copilot Workspace to pick up where you left off.
155 |
156 | And if you'd like to easily access Copilot Workspace at any time, you can add it to your mobile homescreen by performing the following steps:
157 |
158 | 1. Open your mobile browser and navigate to the Copilot Workspace dashboard at [https://copilot-workspace.githubnext.com](https://copilot-workspace.githubnext.com).
159 | 2. Once the dashboard loads, tap on the browser's menu and select "Add to Home screen" to easily access Copilot Workspace from your home screen.
160 | 3. Confirm the action if prompted, and Copilot Workspace will be added to your home screen, providing a native app-like experience thanks to PWA support.
161 |
162 | ## Regaining access if you revoked OAuth
163 |
164 | Copilot Workspace is implemented as an OAuth application. If you revoked authorization for the application in your GitHub account settings, you'll no longer be able to use Workspace. You can restore your access at https://copilot-workspace.githubnext.com/ by logging out, then logging in and re-authorizing the OAuth app.
165 |
166 | ## Incoming Links
167 |
168 | ✨ TIP: Copilot Workspace has a capability for the task to be specified by query parameters when the subject is a repository, branch or pull request.
169 |
170 | ```
171 | https://copilot-workspace.githubnext.com/githubnext/copilot-workspace/pull/695?task=Add%20more%20unit%20tests%20to%20this%20pull%20request.
172 | ```
173 |
174 | The query parameters supported are
175 |
176 | - `task` - The description of the task. If not specified, and the subject is an issue, the body of the issue is used, otherwise no task body is used and the user must enter one.
177 | - `codeOwner` - The organization or individual for the code repository associated with an issue, e.g. `githubnext` for `githubnext/copilot-workspace`
178 | - `codeRepo` - The name of the code repository associated with an issue, e.g. `copilot-workspace` for `githubnext/copilot-workspace`
179 | - `branch` - The SHA or branch name to analyze the task at, e.g. `main`
180 |
--------------------------------------------------------------------------------
/troubleshooting.md:
--------------------------------------------------------------------------------
1 | ## Troubleshooting
2 |
3 | ### Introduction
4 |
5 | Welcome to the troubleshooting guide for Copilot Workspace! In this section, we will provide you with helpful tips and solutions to common issues you may encounter while working with organizations and private repositories in Copilot Workspace. Our goal is to ensure that you have a smooth and productive experience. Let's dive in!
6 |
7 | ### Troubleshooting access
8 |
9 | If you are seeing an "Access Denied" error when trying Copilot Workspace for the first time, here are a few steps that may help:
10 |
11 | - Make sure you have an active, paid copilot license. Trial licenses only allow access once the subscription is upgraded to a paid plan.
12 | - Ensure there are no [trade restrictions](https://docs.github.com/en/site-policy/other-site-policies/github-and-trade-controls) on your account.
13 | - Verify that any organization with Copilot enabled has both the **Copilot Preview Features** setting and the **Copilot Extensions setting** turned ON. If necessary, reach out to your organization’s administrator for assistance. For more details on configuring organization settings for Copilot, please refer to the [documentation](https://docs.github.com/en/copilot/managing-copilot/managing-github-copilot-in-your-organization/managing-policies-for-copilot-in-your-organization).
14 | - For Enterprise users, enable the Copilot Workspace policy through your enterprise account (note this means accepting the [GitHub Next Terms and Conditions](https://github.com/githubnext/githubnext/blob/main/TERMS_AND_CONDITIONS.md))
15 |
16 | ### Troubleshooting Organizations
17 |
18 | When working with organizations in Copilot Workspace, you may encounter some common issues. Here are some troubleshooting tips to help you resolve them:
19 |
20 | - **You are accessing an org that must approve OAuth apps**. As part of the login you authorize the OAuth app into various orgs, depending on the org policies with regard to OAuth apps. You can request access and the organization can approve the OAuth app. If you need to re-request access or revoke any access at all you can [control the status of your connection with the OAuth app](https://github.com/settings/connections/applications/903eccd8a9d2ff50288f).
21 |
22 | - **Although you appear to have the correct authorization credentials, the `github` organization has enabled OAuth App access restrictions, meaning that data access to third-parties is limited.** This is because an org restricts OAuth apps. Some of authorization attempts for orgs may fail if the org doesn't allow OAuth apps at all. This can affect even access to public repositories in organizations that deny access to OAuth apps.
23 |
24 | - **Resource protected by organization SAML enforcement. You must grant your OAuth token access to this organization**.You may be logging in to an organization with SAML control, e.g. Microsoft. They should
25 | 1. Log out of Copilot Workspace.
26 | 2. Go through SAML auth in the browser by looking at, say, a repository of the organization
27 | 3. Then log back into Copilot Workspace.
28 | - **Other known limitations to working within organizations:**
29 | 1. The enterprise (or org) must opt-in to Copilot feature previews. [Learn how to enable feature previews in GitHub.com](https://docs.github.com/en/get-started/using-github/exploring-early-access-releases-with-feature-preview).
30 | 2. The enterprise (or org) has set the Copilot Extension policy to Enabled. This can be done under your org / enterprise settings under Copilot > Copilot Policies.
31 | **Note:** Due to limitations with Copilot Licensing, all organizations of which you are a member must enable the Copilot Extension policy and opt-in for Copilot feature previews. If any organization of which you are a member disables these settings, you will not be able to access Copilot Workspace.
32 | 4. Developers within the enterprise (or org) must have paid Copilot licenses.
33 |
34 |
35 | ### Troubleshooting Private Repositories
36 |
37 | - **You can't access a private repository in your own account**. After login you should be able to access your personal private repositories unless you have removed access for the OAuth app. If you have trouble, it is possible it is because you landed in Copilot Workspace via a sharing link and have only given public repo privileges. You should log out and log back in again and this should restore access. Failing that you should [check the status of their connection with the OAuth app](https://github.com/settings/connections/applications/903eccd8a9d2ff50288f).
38 |
39 | ## Ambiguity Warnings
40 |
41 | If Copilot Workspace detects that your task is overly ambiguous/unclear (e.g. it doesn’t seem aligned with the goals/focus of the repo), then it may warn you about that and ask you to clarify the task further, before you can carry on. This is done to prevent hallucination in the specification and help guide you towards the “pit of success”, since subsequent stages of the workflow work best with sufficient detail.
42 |
43 | 
44 |
45 | *A warning that a task is too ambiguous and that their intent needs to be clarified*
46 |
47 |
48 | ### Troubleshooting Codespaces
49 |
50 | - **Billable owner could not be determined for a new codespace, Repository may not be used for a codespace.** The CW OAuth app is not installed in the billable owner's organization.
51 |
52 | Please view the [Codespaces Guide](codespaces-guide.md) for more information on Codespaces and troubleshooting common errors.
53 |
--------------------------------------------------------------------------------
/vscode.md:
--------------------------------------------------------------------------------
1 | # GitHub Copilot Workspace VS Code extension
2 |
3 | This Copilot Workspace VS Code extension allows you to use GitHub Copilot Workspace from the comfort of VS Code. Continue an existing session and edit and debug the proposed changes before creating a PR. Whether you use natural language to revise the plan or implementation, or edit files directly, you can use the full power of VS Code and its extension ecosystem all while syncing your local edits to GitHub Copilot Workspace on the web automatically (any saved file change will be visible online within few seconds).
4 |
5 | This is currently an alpha extension and we will be rolling out enhancements to the extension in multiple phases.
6 |
7 | 1. **Continue on:** Browse your Copilot Workspace sessions and sync changes so you can edit and debug your application in VS Code locally, using one of the other [VS Code Remote extensions](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.vscode-remote-extensionpack), or in your own [Codespace](https://github.com/features/codespaces).
8 |
9 | 2. **[IN-PROGRESS] Update your workspace using AI**:
10 |
11 | - **Available:** Brainstorming, natural language revisions to the plan and files in the plan, adding/editing/deleting plan files or steps.
12 | - **Planned**: Support for editing the task and answer text.
13 |
14 | 3. **[FUTURE] Create new:** While not available now, you'll be able to create a new Copilot Workspace session in VS Code.
15 |
16 | ## Getting started
17 |
18 | * [Quick Start](#quick-start)
19 | * [Browsing Sessions](#browsing-sessions)
20 | * [Managing Sessions](#managing-sessions)
21 | * [Planing and Implementing](#plan-and-implement)
22 | * [Natural Language Revisions](#natural-language-revisions)
23 | * [Brainstorming](#brainstorming)
24 | * [Known Limitations](#known-limitations)
25 |
26 | ### Quick Start
27 |
28 | 1. If you haven't already, install [Visual Studio Code](https://code.visualstudio.com/).
29 |
30 | 1. Next, open a session [on the web](https://copilot-workspace.githubnext.com) that you'd like to continue working on in VS Code.
31 |
32 | 1. Click on the `VS Code` button in the session screen.
33 |
34 | 
35 |
36 | 1. Allow your browser to open the link in VS Code when prompted.
37 |
38 | Follow the directions that appear in VS Code and make any selections when prompted, and you'll be guided towards syncing the session to your local machine. That's it! 😎
39 |
40 | Here is generally what you can expect to see:
41 |
42 | 1. VS Code will open (if it isn't already running), and you'll be prompted to install the Copilot Workspace extension and then open the URI. If the extension is already installed, you'll just be asked about the URI. Either way, open the URI.
43 |
44 |
45 | 
46 |
47 | 1. **[One time]** If you haven't signed in already, you'll be prompted to do so. Click the `Sign in` and complete the sign in process in the browser that opens.
48 |
49 | 
50 |
51 |
52 | 1. If the VS Code instance already has a folder with the related repository in it open, the extension will immediately start syncing the session locally. Otherwise you may be prompted to clone the repository or pick an existing folder with it in it.
53 |
54 | 
55 |
56 | Once syncing has begun, your local repository will switch to GitHub Copilot Workspace tracking branch with a `ghcw-session` prefix as you can see in the status bar. This is a temporary branch for this session, so you should **not** push your local changes.
57 |
58 | 
59 |
60 | Any edits make to the local files will be automatically synced back to the web session. You only have to save a local file and your change will be visible within a few seconds online (no need to push anything). This allows you to use the full power of VS Code with GitHub Copilot Workspace.
61 |
62 | However, if you picked a session that doesn't yet have an implementation with updated files to start syncing, you'll be notified that you can start syncing once you [have an implementation](#planning-and-implementing).
63 |
64 | 
65 |
66 | In addition to editing and debugging, you can also make [revisions using natural language](https://github.com/githubnext/copilot-workspace-user-manual/blob/main/vscode.md#natural-language-revisions) or adjust the [plan and implementation](https://github.com/githubnext/copilot-workspace-user-manual/blob/main/vscode.md#planning-and-implementing). When you're done, you can either:
67 |
68 | - Create / update a branch and optionally create a PR by clicking on the **Push Changes into Branch...** icon in the `Plan` view using the command palette (F1 or Cmd/Ctrl+Shift+P).
69 | - Or hop back on the web to push updates to the original branch or create a PR from your session. There's a quick access link in the `...` menu on top of the `Plan` and `Task` views.
70 |
71 | ## Browsing Sessions
72 |
73 | Even if you are not syncing a session locally, you can still browse through your sessions and view their details. To browse and manage your sessions, first click on the `GitHub Copilot Workspace` icon in the activity bar on the left side of the VS Code window.
74 |
75 | 
76 |
77 |
78 | After you've clicked the activity bar icon, you'll either see list of your sessions, or details about a specific session you've already selected.
79 |
80 | The session list is sorted by repository. Any repository that applies to currently opened VS Code folders will be on top. You can always get back to the session list when viewing session details by clicking on the `Back to Session List` arrow in the `Task` view or using the **GitHub Copilot Workspace: Back to Session List** command from the Command Pallette (F1 or Ctrl/Cmd+Shift+P).
81 |
82 | Selecting a session in the session list will hide the list and show the related session details instead. A `Task` (or Issue or Pull Request) view and `Plan` view will be visible. Each view can be expanded into a larger panel by clicking on the "full screen" icon.
83 |
84 | The `Task` view includes a description of the task along with links to additional information. The `Plan` view will include details about the related plan for your session (if one exists yet) any files currently in the plan.
85 |
86 | If the [plan has already been implemented](#planning-and-implementing), you'll be able to view any changed files by clicking on file in the plan.
87 |
88 | 
89 |
90 | When syncing is active, clicking on the file will open a local changes view of the synced contents. This view is editable and the changes will be synced back to the web session. If the session is not syncing, you will see the changes currently stored in the web session in a read-only mode.
91 |
92 | You can also click on the `Open File` icon when hovering on an file in the plan to open the file (instead of the changes view) in a new tab in VS Code. You may be prompted to start syncing the session if you are not already.
93 |
94 | ## Managing Sessions
95 |
96 | You can sync session file changes locally for any session that has a plan and an initial implementation.
97 |
98 | If the session you opened does not yet have an implementation, see [Planning and Implementing](#planning-and-implementing) for information on creating one from VS Code. You can then sync its contents locally once done.
99 |
100 | ### Stopping Syncing Changes
101 |
102 | The quick start highlighted a fast way to start syncing your session's changes locally, so let's cover how to stop syncing changes next.
103 |
104 | If the session list is visible, you will see a green checkbox next to any session that is currently being synced. When hovering over this session, you will see a `Stop Syncing Changes` button. Otherwise, if the session details are visible for a session that is currently syncing, you will find this same button in the `Plan` view. Simply click this button in either location to stop syncing.
105 |
106 | | Session List | Session Details |
107 | | :--- | :--- |
108 | | 
| 
|
109 |
110 | Alternatively, you can use the Command Palette (F1 or Ctrl/Cmd+Shift+P) and select the **GitHub Copilot Workspace: Stop Syncing Changes** command when you have the session details open.
111 |
112 | You'll be switched back to the branch you where on when you started syncing changes, or **main** (or master) if nothing else. Since the changes you made locally are kept in sync automatically when syncing is active, the working tree is also cleaned out so you can easily jump in and out of sessions.
113 |
114 | The next time you sync this same session, the session will go back to this tracking branch and the latest changes in GitHub Copilot Workspace - including your edits - will appear again.
115 |
116 | Note that if you manually change the branch away from the one set when syncing began, syncing will also automatically stop. However, in this case, any changes you made will be kept in the working tree to make sure you don't lose something you intended to keep. Stopping syncing as described above will ensure you've got a clean working tree to continue making other changes.
117 |
118 | ### Syncing Changes Locally
119 |
120 | As outlined in the quick start, you can always click on the VS Code icon in the GitHub Copilot Workspace web UI to start syncing changes locally. But you can also start syncing a session directly from within VS Code.
121 |
122 | However, as described in these previous sections, note that only sessions with a [plan and an initial implementation](#planning-and-implementing) can be synced locally.
123 |
124 | If session list is visible, hovering over a session that is not currently being synced (no green checkbox), will show a `Stop Syncing Changes` button. Otherwise, if the session details are visible instead, you will see this same button the `Plan` view (assuming syncing is inactive for this session). Click this button to start syncing changes for the session locally.
125 |
126 | Note that any other existing session that is already syncing for the same repository will automatically stop syncing first, so you don't have to worry about conflicts.
127 |
128 | | Session List | Session Details |
129 | | :--- | :--- |
130 | | 
| 
|
131 |
132 | Similarly, you can use the Command Palette (F1 or Ctrl/Cmd+Shift+P) and select the **GitHub Copilot Workspace: Sync Changes Locally** command when you are in the detail view for a session to start syncing.
133 |
134 | Next you may be prompted as follows:
135 | 1. If you do not currently have the repository for the session open in VS Code, you will be prompted to open a folder with the repository or to clone the repository in a fresh location.
136 | 1. If you do have the correct repository open, but the current working tree has uncommitted changes, you'll be asked what you want to do with them.
137 |
138 | Either way, once this is done, your local repository will be on a GitHub Copilot Workspace tracking branch with a `ghcw-session` prefix as you can see in the status bar.
139 |
140 |
141 |
142 | Regardless, any edits make to the local files will be synced back to the web session, so you do not need to worry about committing or loosing your changes.
143 |
144 | ### Visibility to Sync Status and Processing State
145 |
146 | Since you won't always have the `Plan` view visible while you work, GitHub Copilot Workspace has a status bar item that can help you understand what the extension is doing at that moment. Here are some examples of what you will see:
147 |
148 | | Example | Description |
149 | | :--- | :--- |
150 | | 
| The extension is signed in, but but idle. |
151 | | 
| Syncing is enabled for a session, but the extension is currently idle. |
152 | | 
| The extension is performing an operation indicated by the text (`Starting implementation...`) and spinning loading or sync icon (when files are transferring). |
153 | | 
| Here, an error occurred while syncing. Clicking on the status bar item will show more information. |
154 |
155 | Clicking on this status bar item will take you to the session details for the session you are syncing (or the session list if you are syncing multiple sessions in a multi-root workspace with multiple repos). The status bar will also turn red if a sync error has occurred, and clicking on it should provide you options to remediate the issue.
156 |
157 | #### Plan View Banner
158 |
159 | However, if you do have the `Plan` view up, you can look at the status banner to see what is happening and in some cases take quick actions based on the current state.
160 |
161 | 
162 |
163 |
164 | ### Pushing Session Changes to a Branch or PR
165 |
166 | While the extension automatically syncs changes to the web, you may want to push your changes to a branch or create a PR from the session. This is useful when you are either done with the session, or you want to keep changes to something that is not automatically synced - like something in the .gitignore file or large files that you received a notification where ignored.
167 |
168 | Thankfully, the you can use following buttons in the `Plan` view when you are syncing a session to perform these actions. Note that the command name in this table is also the name of the command in the **Command Palette** (F1 or Ctrl/Cmd+Shift+P) when the appropriate session is visible in the side bar.
169 |
170 | | Button | Command | Description | Location(s) |
171 | | :--- | :--- | :--- | :--- |
172 | | 
| Push Changes into Branch... | Pushes changes to a new or existing local branch, optionally pushes them remotely too. | Plan view when file syncing is enabled, `...` context menu. |
173 | | 
| Create PR from Changes... | Pushes changes to a specified remote branch, then makes opens the PR UX in VS Code to let you enter details on the request. | Plan view when file syncing is enabled, `...` context menu. |
174 |
175 |
176 | ### Deleting a Session
177 |
178 | To delete a session, you click on the trash can icon next to the item in the session list. If you are currently viewing a session's details, select **Delete Session** from the context menu that appears when clicking on the `...` button on the `Task` or `Plan` views.
179 |
180 | Alternatively, you can use thee Command Palette (F1 or Ctrl/Cmd+Shift+P) and select the **GitHub Copilot Workspace: Delete Session** command when you are viewing a session's details.
181 |
182 | ## Planning and implementing
183 | When the session details are visible (and you see the `Task` and `Plan` views), you can make changes to the plan and its related implementation for the session right from VS Code.
184 |
185 | In fact, can also generate and implement an initial plan if your session doesn't have one yet.
186 |
187 | You will find a number of different options for interacting with the plan by clicking on the `...` button in the `Plan` view. However, the most common actions will appear as icons. The table below outlines what each of these does. Note that the command name in this table is also the name of the command in the **Command Palette** (F1 or Ctrl/Cmd+Shift+P) when the appropriate session is visible in the side bar.
188 |
189 | | Button | Command | Description | Location(s) |
190 | | :--- | :--- | :--- | :--- |
191 | | 
| Generate Plan | Generates a plan for the session and creates an inital implementation. | Plan view when no plan exists. Regenerate plan is available in the `...` context menu afterwards. |
192 | | 
| Implement Plan | Implement (or re-implement) the selected items in the plan view. | Plan view when plan exists, `...` context menu. |
193 | | 
| Revise Plan | Make revisions to the entire plan using natural language. Will automatically implement the requested changes. | Plan view when plan exists, `...` context menu. |
194 | | 
| Sync Changes Locally | See Managing Sessions. Start syncing session changes locally. | Plan view if there is an implementation, and the session is not already syncing, `...` context menu. |
195 | | 
| Stop Syncing Changes | See Managing Sessions. Stops syncing session changes locally. | Plan view if the visible session is already syncing, `...` context menu. |
196 | | | Push Changes into Branch... | Pushes changes to a new or existing local branch, optionally pushes them remotely too. | Plan view when file syncing is enabled, `...` context menu. |
197 | | | Create PR from Changes... | Pushes changes to a specified remote branch, then makes opens the PR UX in VS Code to let you enter details on the request. | Plan view when file syncing is enabled, `...` context menu. |
198 |
199 | The `...` context menu is also available for files and items in the plan when you hover over them. This context menu will allow you to view the files, their changes, or edit, move, delete, or the list items as needed.
200 |
201 | ### Natural Language Revisions
202 |
203 | You can also make revisions to the plan and implementation using natural language. This can be done for the entire plan as highlighted previously, or you can make targeted revisions to a file in the plan. You can even add another file to the plan and revise it in one shot.
204 |
205 | To make file-level revisions easy, there are buttons in the upper-right of any open editor window for a file that can be part of the plan.
206 |
207 | 
208 |
209 | Here's a summary of where you can trigger these kinds of revisions:
210 |
211 |
212 | | Button | Command | Description | Location(s) |
213 | | :--- | :--- | :--- | :--- |
214 | | | Revise Plan | Make revisions to the entire plan using natural language. Will automatically implement the requested changes. | Plan view when plan exists, `...` context menu. |
215 | | 
| Revise File | Make targeted revisions to a file using natural language. Will automatically either add the file to the plan or add a step to an existing entry, and then implement the requested changes. | Plan file items (hover), Editor actions (upper-right), `...` context menu. |
216 | | 
| Add File to Plan | Adds the file to the plan, but makes no revisions to it. | Editor actions (upper-right), `...` context menu. |
217 |
218 | ## Brainstorming
219 |
220 | > Note that this feature is new to Copilot Workspace, so you may encounter more rough edges that other parts of the experience. Please let us know if you have any feedback!
221 |
222 | Brainstorming provides a way for you to interact with Copilot Workspace to refine the task you want to perform. You can ask or select suggested questions to learn more about potential options for your task and then add the answers you like as additional context to use when planning and implementing. This feature is now available in VS Code so that you can refine your initial task and plan directly from your editor.
223 |
224 | ### Accessing the Brainstorming panel
225 |
226 | You can access brainstorming in a few ways. First, you can click on one of the following buttons to get started. As in other cases in this document, the Command column contains the name of the command in the **Command Palette** (F1 or Ctrl/Cmd+Shift+P) when the appropriate session is visible in the side bar.
227 |
228 | | Button | Command | Description | Location(s) |
229 | | :--- | :--- | :--- | :--- |
230 | | 
| Brainstorm | Opens the `Brainstorming` panel. If the question "How should I solve this task?" has not already been answered (aka the "spec" has not been created yet), you will see that start at this point. | Task view, `...` context menu. |
231 | | 
| Answer New Question... | Lets you ask Copilot Workspaces a specific question, and the `Brainstorming` panel then appears with the answer. | Task view, `...` context menu. |
232 |
233 | The `Task` view also includes a list of questions or answers that have already been added to the task in a section after the description. You can click on any of these to see the answer in the `Brainstorming` panel and continue brainstorming.
234 |
235 | 
236 |
237 | ### Using the Brainstorming Panel
238 |
239 | When you open the `Brainstorming` panel, you will see the current answer to a question. By default this will be the question "How should I solve this task?" which is always added to the Task. You will then see a series of buttons at the top with possible actions.
240 |
241 | 
242 |
243 | Let's go through the buttons you may see and what they do.
244 |
245 | | Button | Description |
246 | | :--- | :--- |
247 | | **Add to Task** | Adds the current answer to the task. This will also automatically trigger regeneration of the "How should I solve this task?" question / spec. Note that answer to any question added to the task will appear in below the task description in the `Task` view. |
248 | | **Remove from Task** | Removes the current answer from the task. This will also automatically trigger regeneration of the "How should I solve this task?" question / spec. |
249 | | **Regenerate** | Asks Copilot Workspace to try to answer the question again. |
250 | | **Delete** | Deletes both the question and its related answer from the list of existing answers. |
251 | | **Answer** | Lets you ask Copilot Workspace a new question. |
252 | | **Open Existing** | Displays a list of answers that have already been generated that you can open in the `Brainstorming` panel. Any answers that have been added to the task will have a check next to them. Useful if you did add an answer to the task or removed it, and changed your mind. |
253 |
254 | #### Multiple Answers
255 |
256 | Sometimes you may also be presented with multiple possible answers to a question. In this case, you can select the one you want to add to the task by clicking on the empty circle next to the option - which will then turn into a green checkmark indicating its been added. If you change your mind, you can click on the checkmark to remove it.
257 |
258 | 
259 |
260 |
261 | #### Suggested Questions
262 |
263 | In addition, below the current answer for the question, you will see a list of **suggested questions** that may apply to your task. You can click on any of these to see the answer in the `Brainstorming` panel.
264 |
265 | ### Updating the Plan When You Are Done
266 |
267 | When you are done brainstorming, you can regenerate your plan by clicking `...` in the `Plan` view and selecting **Regenerate Plan**. (And if you don't have a plan yet, you can generate one by clicking `...` in the `Plan` view and selecting **Generate Plan** as described previously.)
268 |
269 | However, if you are generally happy with the plan as it exists, you can make a **[natural language revision](#natural-language-revisions)** to factor in the new information in a more specific way.
270 |
271 | ## Known Limitations
272 |
273 | **Features:** As outlined above, you need to use the web UI for the following as they are not yet available in VS Code:
274 | * Starting a new session
275 | * Direct text edits to the task or an answered question
276 |
277 | **File syncing:**
278 | * File syncing has some limitations placed on it during the technical preview such as not syncing binary files, certain paths or file types, or files over a certain size. These limitations are subject to change as we continue to improve. When using the VS Code extension directly you will be notified when one of these limitations has been hit, and can see which files have been ignored from the **GitHub Copilot Workspace: Show Files Ignored While Syncing** command from the command palette (F1 or Ctrl/Cmd+Shift+P).
279 | * File syncing status does not cross open windows. So if you have multiple windows for the same folder (and repository) open, and each are syncing, you can end up transmitting or applying same file contents multiple times and fail to apply updates. To avoid this, either use a single window for a given repository, or do not start file syncing for more than one.
280 | * Files that where ignored while syncing will not result in a notification when working from a Codespace started by the GitHub Copilot Workspace web UI since the use of the extension in this case is optional. File syncing is handled by a stand-alone process in this case.
281 |
282 | Note that if you see something unexpected, you can check the output view for more details. From the file menu, select **View** > **Output** and then select **GitHub Copilot Workspace** from the dropdown. This can help you identify what happened and can be used to help us diagnose any issues you may encounter.
--------------------------------------------------------------------------------