Keep the Session, Change the Editor: Reviewing GitHub Copilot app Work Inside Visual Studio Code

Delivery friction in an assisted-coding workflow usually shows up at one precise moment: the agent has produced most of the change, and now you must read it, correct it, and prove it runs before anyone else looks at it.

That moment does not require a restart. Visual Studio Code is where engineering teams normally inspect diffs, debug code, and apply final adjustments, while the task, the plan, and the conversation were built in the GitHub Copilot app. A handoff between the two can be a continuation of the same unit of work instead of a copy-and-paste exercise.

The sections below trace the full path: open the Copilot app session in your editor, read the agent diff line by line, edit files by hand, run npm checks in the integrated terminal, keep prompting Copilot when the next step depends on stored context, and push with git into the pull request already linked to that session.

What a session actually carries

Open the session you want to carry forward, then spend a moment on two things: the task it was given and the work Copilot finished. A session is not only a set of modified files. It also captures the task, the plan, and the conversation that produced those changes.

That stored context is what lets you ask why a specific implementation was selected, or request a revision without restating the problem from scratch. There is no summarizing step and no copying of history into a new chat before moving to VS Code.

Three pieces that arrive together

Select "Open in VS Code" from the session. If the app lists more than one supported editor or more than one VS Code installation, pick the one you intend to use. VS Code then opens the project at the worktree associated with the session and displays the existing session in the Copilot sidebar. You land on three connected pieces of the original work:

• Session context — the task, plan, and conversation remain available.
• Diff — the files and lines changed by the agent are ready for review.
• Worktree — the editor opens the same isolated working tree the session used.

You are continuing an existing session, not reconstructing it in a new editor window.

Where each tool does the heavier work

Stage of the handoff	Copilot app	Visual Studio Code
Task, plan, conversation	Created and held here	Read through the session in the Copilot sidebar
Bulk or repetitive implementation	Performs the work	Continue prompting when repository-wide analysis is needed
Change review	Produces the change	Line-by-line diff in the Source Control view
Targeted corrections	Not the usual place for these	Direct edits inside the session worktree
Local verification	—	Integrated terminal (npm), integrated browser, localhost URL
Delivery	The pull request already tracks this work	git add, git commit, git push update that pull request

Step 1 — Inspect the agent's changes before touching anything

Open the Source Control view to see the changed files, then choose a file and review its changes line by line. Read the implementation as you would read any other proposed change, and confirm that:

• The code solves the requested problem.
• The implementation follows the repository's conventions.
• Error states and edge cases are handled appropriately.
• Tests cover the behavior that changed.
• No unrelated files or behaviors were modified.

The preserved conversation explains how Copilot arrived at the implementation. When something is unclear, keep prompting in the sidebar, for example: "Explain why you changed this function instead of adding a new helper. Identify any behavior this could affect." You can also ask for another change; because the session and worktree remain connected, you do not have to describe the task from the beginning.

Step 2 — Edit the work by hand where typing is cheaper

Once you understand the proposed changes, edit any file directly in VS Code. Manual work is usually the faster route for small, well-defined adjustments such as:

• Refining a label or error message.
• Renaming a variable for clarity.
• Adjusting layout or styling.
• Adding a missing test case.
• Applying a repository-specific convention.

Because you are editing the session's existing worktree, those manual changes build directly on the agent's work. No files are copied between directories, and the branch is not re-created by hand.

Step 3 — Run and verify the project locally

Use the VS Code integrated terminal for the repository's normal validation workflow. Exact commands depend on the project, but a web app pass may include:

• npm install
• npm test
• npm run lint
• npm run dev

Treat agent-generated output the same way you treat code written by a person: run the relevant tests, inspect failures, and verify the behavior yourself. If the development server prints a localhost URL, open it and exercise the change in a browser; where your VS Code setup supports it, use the integrated browser so the inspection stays inside the editor.

For a user-interface change, verify the requested behavior and the nearby states. Check the modified component at different viewport sizes and confirm that loading, empty, and error states still work.

Step 4 — Alternate between prompting and typing

At any point, choose the interaction that fits the next step:

• Prompt Copilot when the change requires repository-wide analysis or repetitive edits.
• Edit directly when you already know the exact change you want.
• Use both iteratively as you test and refine the implementation.

After a manual UI adjustment, for instance, you might ask: "Add a test for the updated label. Run the relevant test file and do not modify unrelated components." Since you are still inside the original session, Copilot keeps the context needed to interpret that reference.

Step 5 — Commit and push the finished changes

When the implementation is ready, review the final diff one more time, then commit and push through the Source Control view or the integrated terminal:

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

Apply your repository's normal branch, commit, review, and approval practices. Because VS Code opened the worktree and branch associated with the session, pushing that branch updates the pull request already tracking the work — no copying into another checkout, no manual reconnection.

Common misconceptions about the handoff

• "A session is just changed files." It also holds the task, the plan, and the conversation, and that context is what makes follow-up questions precise.
• "I need to re-explain everything in the editor." Opening the session in VS Code preserves the conversation; you continue rather than reconstruct.
• "Manual edits mean leaving the agent's work." Your edits land in the session's own worktree, so they build directly on what Copilot produced.
• "Agent code is already verified." It is not. Run the tests, read the failures, and check the behavior in the browser yourself.
• "The pull request has to be relinked afterward." Pushing the session branch updates the pull request already tracking that work.

FAQ

Do I lose the conversation when I move to VS Code?

No. The editor shows the existing session in the Copilot sidebar, and the task, plan, and conversation stay available.

Which working copy does the editor open?

The worktree associated with the session — the same isolated working tree the agent used.

What if several editors or VS Code installations are listed?

Choose the one you want to use when you select "Open in VS Code".

Can I still prompt Copilot after editing by hand?

Yes. The session and worktree remain connected, so follow-up requests are interpreted against the current state of the work.

Which commands should I run before committing?

Whatever your repository normally validates. Common npm examples are npm install, npm test, npm run lint, and npm run dev.

Does the push create a new pull request?

No. The finished updates go into the pull request already linked to the original session.

Action plan for your next agent-assisted change

1. Finish the bulk of the implementation in a Copilot app session, then select "Open in VS Code".
2. Read every changed file in the Source Control view against five checks: problem solved, conventions followed, edge cases handled, tests covering the change, and no unrelated edits.
3. Ask the sidebar for rationale before you rewrite anything by hand.
4. Apply the small, precise corrections directly in the session worktree.
5. Run the validation workflow, open the localhost URL, and confirm loading, empty, and error states plus different viewport sizes for UI work.
6. Loop between prompting Copilot and typing yourself until the behavior is verified.
7. Review the final diff, then git commit and git push to the session branch.

To start with a concrete task instead of a rehearsal: download the GitHub Copilot app, open a session, and switch into VS Code the moment you want hands-on control of the diff, the local run, and the final push.