A Different Way to Think About Copilot

AI coding tools often start and end with a chat window. That works for quick questions or generating a snippet, but real development work is rarely that linear. You might be fixing a bug one moment, then jumping to review a pull request, exploring unfamiliar code, or chasing down a new idea the next. The GitHub Copilot app is built around that reality.

Rather than treating AI as a single conversation, the app provides a workspace for managing multiple agent sessions. Each session can be tied to a different task or project, letting you switch context without losing progress on other threads of work.

Start by Connecting a Project

Every agent session starts with a project, which gives the session the repository context it needs for a specific task. From the Copilot app home screen, you can pick a project you have used before or add one from GitHub or a local machine. With the project connected, the session has access to the codebase, files, and tools required to begin.

For example, say you want to add a breadcrumb navigation component to an existing application. Rather than manually hunting down the right file, you can describe the change you want. The session can inspect the project, identify relevant files, make the modifications, and run tests to help validate the work. Having the project attached from the start cuts down on environment setup time and lets you get straight to the task.

Keep Multiple Workstreams Open

Once you have a project selected and a session running, you can spin up additional sessions for other questions or tasks without interrupting the original work. The Quick Chat option starts a new conversation directly from the app’s home screen. Each conversation can focus on a separate area, giving you a dedicated space to explore ideas or work through changes.

You might open a Quick Chat to ask how worktrees function in the app while another agent session continues applying project updates. Or use it to dig into how your codebase works or gather context before deciding on an approach. When you move back to the original session, your progress remains intact—you can review what was changed and pick up right where you left off. This structure means you can follow multiple threads without losing track of any single task.

Visualize Work in a Canvas

For UI work, seeing the result is just as important as reviewing the code behind it. The Copilot app lets you open a browser canvas directly in your workflow so you can preview the application and adjust based on what you see. A canvas is a shared, interactive space built around work artifacts—a plan, a kanban board, a checklist, or a running application. It gives you a visual representation of the task alongside the conversation, moving beyond a purely text-based view.

Instead of opening a terminal and launching a separate browser, you can create a browser canvas in the Copilot app with the /create-canvas slash command. After asking Copilot to update a UI component, you can type:

/create-canvas Open this app in a browser canvas

That opens your application in a canvas so you can preview the result. If an adjustment is needed, you can Enable Canvas Dev Mode and use Pick & Polish to select elements directly in the canvas and use them as context for the next request. Point at the specific part of the page, request the update, and keep refining from there.

Carry Work Through Review with Agent Merge

When your changes are ready, the next step is opening a pull request and running it through the usual CI and review cycle. Agent Merge extends that workflow past the initial code change by monitoring the pull request and assisting with tasks that come up during review.

To start an Agent Merge workflow, open the pull request options in the Copilot app and select Agent Merge. From there, choose the actions it can take—such as addressing review feedback, helping resolve CI failures, or handling merge conflicts. Once enabled, Agent Merge monitors the pull request as it advances through review and CI. If issues surface, it helps resolve requested changes and prepares the pull request for merge. Once the required checks pass, you can merge.

Putting It Together

The Copilot app brings the different parts of development into a single workspace. Start with a project, branch out into separate sessions for distinct tasks, use a canvas to preview and refine UI work, and keep changes moving through the pull request process with Agent Merge.

There is more to explore around customization and workflow extensions, but the best approach is to try it directly. If there is a backlog task you have been putting off, opening it in the GitHub Copilot app is a reasonable first step to see how the sessions, canvases, and agent workflows hold up in practice.