Seamlessly Continuing GitHub Copilot Sessions in VS Code

Transferring a GitHub Copilot session to Visual Studio Code (VS Code) allows developers to shift from automation to hands-on coding without losing momentum. If you're using GitHub Copilot to generate code but prefer VS Code for review and adjustments, there's a seamless way to continue your session. Let's explore the method and why it matters.

Why Move GitHub Copilot Sessions to VS Code?

The GitHub Blog outlines a workflow that lets users continue sessions from the GitHub Copilot app directly in VS Code. This is crucial for developers who rely on VS Code for its rich features and streamlined environment.

Using the Copilot app, you might complete a bulk of your coding tasks effortlessly. However, the detailed review, editing, and local testing typically require the power of a dedicated code editor like VS Code. By transferring the session seamlessly, you retain the history of the task, plan, and conversation—eliminating the need to start afresh.

How to Continue a GitHub Copilot Session in VS Code

Moving your session from the Copilot app to VS Code involves these straightforward steps:

1. Start with Your Current Session

First, ensure that your session in the Copilot app is active. The session records all the modifications, task details, and conversations. You don't need to recreate this context when transitioning.

2. Open the Session in VS Code

Select the option to "Open in VS Code" from your session in the Copilot app. Your VS Code will open with all the relevant files, conversation threads, and a dedicated worktree, replicating the Copilot session environment.

This feature preserves the session's context, displaying the task, plan, and any conversation aspects you've had with Copilot. The associated worktree ensures that any changes remain isolated, just as they were in your original session.

If the app presents multiple options for editors or VS Code installations, choose the one that fits your workflow best. This selection can impact the extensions and settings you have configured.

3. Review the Changes Made by Copilot

Inspect the agent’s changes using the Source Control view in VS Code. Open each file to go through the changes line by line, assessing the implementation against the specified problem, ensuring repository conventions are followed, and verifying that appropriate error handling is in place.

"Explain why you changed this function instead of adding a new helper." This prompt helps maintain continuous collaboration within the editor.

Evaluate whether the test coverage is sufficient for the modifications. If it's not, you can integrate additional tests directly in the session.

4. Make Manual Edits if Needed

For minor tweaks or precise coding standards, you can directly edit files. Adjustments might include refining messages, renaming variables, or adding tests. This approach builds directly on what's already in the worktree without requiring file transfers or manual branch re-creations.

You can leverage VS Code's intellisense and other integrated debugging tools to refine and optimize changes quickly.

5. Test Locally in VS Code

Utilize VS Code's integrated terminal to run tests and verify your code. Typical commands might involve:

npm install
npm test
npm run lint
npm run dev

Run all necessary commands to ensure the implementation is solid and that changes perform as expected, just as you would with any human-generated code.

It's crucial to also manually test the operational changes in a browser or other appropriate interface when your project is running, especially for UI components.

6. Continue or Edit More

Choose between prompting Copilot for further assistance or making direct edits. This flexibility allows for iterative refinement, utilizing Copilot when broader changes are needed or sticking to manual edits for nuanced adjustment.

If a broader understanding of your repository is required, prompt Copilot. When specific knowledge of a module or function is needed, manual edits might be faster.

7. Finalize and Push Changes

Once satisfied, the final step is to commit and push your changes back to the repository. Since VS Code retains the session worktree, you can push directly, updating the pull request tied to your session.

git status
git add .
git commit -m "Refine session changes"
git push

Follow your team's established practices for code review and approval, ensuring the changes meet all required standards before merging.

What to Check First

I'd start by ensuring your VS Code setup is ready to handle the session switch. This means updating any extensions needed for interaction with GitHub Copilot sessions and confirming access to the repositories involved.

Check if your team has specific coding conventions and testing protocols integrated with VS Code. Aligning these aspects can make the review and edit processes more streamlined.

Limitations and Considerations

This feature extends an efficient bridge for developers, but not without certain limitations. If your project depends heavily on plugins or configurations unique to another editor environment, the transition might not be entirely seamless.

My concern is with complex merge scenarios where Copilot's suggestions need heavy context or multiple repository insights. In such cases, it might be necessary to iterate more on the workflow or integrate additional tools within VS Code.

Also, ensure your environment matches the repository's technical requirements to avoid unexpected behavior during local testing.

For large-scale projects, you may encounter performance issues if your session involves extensive file changes. In such cases, breaking down the changes into smaller, manageable commits might help maintain clarity and performance.

Trade-offs

While moving sessions to VS Code is convenient, it may not cater to all workflows. If your work heavily relies on specific tools that aren't supported by VS Code, consider integrating those capabilities within your VS Code setup.

Some developers may feel that the interaction with Copilot in VS Code isn’t as intuitive as in the standalone app. This can lead to a learning curve during the transition. Evaluating these trade-offs will help determine if this workflow enhances your productivity.