In-depth analysis · About 6 min read
Copilot app to VS Code: what a continuous session preserves, and what still needs review
GitHub's October 19 guide explains a handoff that keeps the conversation, diff and worktree together; account permissions and validation still matter.
- Published here
- Source published
- Source checked
GitHub published an October 19 tutorial on continuing a Copilot app session in Visual Studio Code. Its central idea is to preserve the existing task and checkout when a developer takes over detailed editing. This is a workflow guide, rather than evidence of a new model release or a measured productivity gain.
Listen to the news
Read this article aloud or keep listening to the news.
Preparing the reader…
Device voice
Speech is handled by your browser or device. AISubHub does not send the text to an audio API. Voice availability and playback with a locked screen vary by device.
Resuming may repeat a short phrase.
At a glance
- The guide says VS Code opens the session-associated worktree and displays the existing conversation in the Copilot sidebar.
- The prerequisites include the same GitHub account in both applications, an existing session with changes, and permission to work in and push to its repository.
The handoff carries a task, not just a folder
A developer often changes tools at the point where broad implementation gives way to inspection: the agent has modified several files, but a specific function or an error message needs human attention. Starting a new chat with copied files would require rebuilding the explanation of what the task was and why a design was chosen. GitHub describes a different path: open the existing session and use Open in VS Code, choosing an installation if the application offers more than one.
According to the guide, three things remain connected: the task, plan and conversation; the changed lines available as a diff; and the isolated worktree used by the session. VS Code also shows that conversation in its Copilot sidebar. This distinction matters because conversation history explains an implementation but does not certify it. A plausible rationale in a retained chat is still a claim that must be compared with the actual changes.
Account and repository access are prerequisites
The stated starting conditions are concrete: install and sign in to the Copilot app, install VS Code and connect it to the same GitHub account, have a session containing changes, and hold permission to work in and push to that repository. The tutorial also assumes familiarity with VS Code, its terminal, Git branches and pull requests. Merely opening a project is therefore not the whole setup described in the article.
The same-account requirement connects the two applications to the intended identity; it does not grant repository permissions that the account lacks. The article does not provide a minimum app version, a complete operating-system support list, or a plan-by-plan availability and billing table. Those omissions should remain unknowns, rather than becoming claims that any free account or every installation can perform the workflow.
A shared worktree makes manual edits part of the same change
A worktree is the checked-out directory in which a branch's files are edited. GitHub says the editor opens the worktree associated with this session, so a developer's manual edits build on the agent's current files. There is no need in this workflow to copy the patch to another directory or manually recreate its branch. The saved session can then receive follow-up questions about the same work.
Consider a teaching example: the agent changes an error label, and the developer tightens its wording by hand. Asking Copilot to add a test for that revised label makes sense because the conversation and edited files remain connected. This is an illustration, not a reported test. It also does not establish that every running process, installed dependency, terminal state or credential is transferred. The source describes session context and checkout continuity, not a complete machine-state snapshot.
Review and execution remain separate checks
The tutorial directs developers to the Source Control diff before further editing. Its review questions include whether the implementation solves the requested problem, follows repository conventions, handles errors and edge cases, tests the changed behavior, and avoids unrelated changes. The retained chat can help locate the reasoning: ask why a function changed and what other behavior might be affected, then check the answer against the patch.
For validation, GitHub lists illustrative web-project commands for dependency installation, tests, linting and a development server. The exact workflow depends on the repository. The article also suggests checking loading, empty and error states and different viewport sizes for interface work. AISubHub's practical recommendation is to inspect project instructions and proposed commands before running them, especially where installation or execution can affect files and environment access. This reporting task ran none of those examples and started no local service.
Continuity reaches the pull request, not automatic approval
After a final diff review, the guide uses the repository's normal commit and push workflow. Because the worktree and branch are those associated with the session, pushing that branch updates the pull request already tracking the work; the developer need not reconnect a second checkout by hand. That is a description of the associated-PR workflow, not a promise that every session already has a pull request or that a push merges it.
AISubHub's analysis is that this design moves the handoff cost away from copying context and towards checking a continuous artifact. A useful acceptance check is to confirm the intended directory and branch, review the staged files, run the repository's permitted validation, and inspect the destination pull request. These are editorial recommendations, not additional automatic guarantees. The source supports a connected editing process; it does not prove faster completion, safer generated code, or exemption from normal review and approval.
Why it matters
AISubHub's analysis: the useful continuity is between the reasons for a change, the actual patch and the branch that will be reviewed. Keeping those connected can reduce manual reconstruction, while leaving acceptance of the implementation with the developer.
Limits and availability
The tutorial gives no minimum-version or subscription-eligibility matrix, and no benchmark. We read its complete text from the preserved official-page cache; we did not execute its commands, test the handoff or verify every supported installation.
Sources and evidence
Source published: · Source checked:
AI-assisted editorial articles checked against linked primary sources. Vendor claims are attributed; inclusion is not endorsement.