GitHub's Christopher Harrison has published a beginner-friendly guide to the GitHub Copilot app, framing its core design as upgrading AI coding tools from a "chat window" to a session workspace. As he puts it: "AI coding tools often begin with a chat window. While that works for quick questions or generating code, real software development rarely happens in a straight line."
This pinpoints a core pain point of current AI coding tools: developer work is inherently parallel and multi-threaded, but mainstream AI tools still operate as single-threaded serial conversations. Fixing a bug while reviewing a PR, exploring an unfamiliar module, and testing new ideas all cram into one chat window, where session contexts contaminate each other.
1. Project-Level Sessions: Pick a Project First, Then Start a Session
The app's first core abstraction: every Agent session is bound to a project.
From the app's home page, select a previously used project or add a new one from GitHub or a local machine. Once selected, the session immediately receives repository context, relevant files, and available tools.
Example: to add a breadcrumb navigation component to an existing app, there's no need to manually search files — just tell Copilot what change you want, and the session automatically inspects the project, locates relevant files, makes changes, and runs tests.
Benefit: time spent "preparing the environment" drops to zero; developers stay in "doing work" mode.
2. Parallel Sessions: Quick Chat Without Interrupting the Main Line
After selecting a project, you can create additional sessions for other issues, ideas, or tasks without interrupting ongoing work.
- Quick Chat: start new conversations from the Copilot app home page, each focused on a different area of work
- Run an Agent handling project updates in one session while using Quick Chat to ask things like "how do worktrees work?" or "would this approach work?"
- Return to the original session, pick up where you left off, review changes, and update tasks
- Open an app directly with the
/create-canvas Open this app in a browser canvascommand - Canvas is a shared, interactive space built around work artifacts (plans, kanban boards, checklists, running apps)
- No new terminal, no new browser — the entire flow stays inside the Copilot app
- Enter Canvas Dev Mode
- Use Pick & Polish to select UI elements directly on the canvas as context for the next request
- Point at a specific part of a page, request updates, and keep polishing
- Open the PR option in the Copilot app and choose Agent Merge
- Choose what Agent Merge can do: handle review feedback, resolve CI failures, manage merge conflicts
- Once started, Agent Merge automatically monitors the PR, addressing issues during review until it's ready to merge
- After required checks pass, merge with one click
- Cursor's multiple Composers
- Claude Code's subagents + Plan mode
- Codex's worktree mode
- Now GitHub Copilot app's Quick Chat + Canvas + Agent Merge
- GitHub Copilot app for Beginners: Getting started — Christopher Harrison
- GitHub Copilot app official page
Benefit: different work streams don't pollute each other's context — sessions are split by topic, not by time.
3. Canvas: Making Work Artifacts Visual
For UI changes, seeing the result matters as much as reading the code. The Copilot app includes a built-in browser canvas for in-workflow previews:
Canvas Dev Mode + Pick & Polish is the killer feature:
Benefit: the cognitive cost of switching between "reading code" and "viewing results" drops to zero.
4. Agent Merge: Taking Over the PR Flow Through the Moment of Merging
After code changes, the next step is opening a PR and going through standard CI and review. The Copilot app's Agent Merge takes over everything after that:
Benefit: no more switching back and forth between Copilot and GitHub — the PR lifecycle from code change to merge stays in one workflow.
5. What Making Multi-Agent Parallelism the Default Means
Harrison concludes: "The Copilot app brings together the different parts of your development workflow in one place."
This captures the core of the product design: developer workflows are fragmented, but AI tools have spent the past 18 months pretending they are single-threaded chats. By making multi-agent parallelism, Canvas previews, and Agent Merge the default, the underlying bet is clear —
The next dividing line for AI coding tools isn't the model itself, but workflow orchestration:
Everyone is racing to claim the high ground of "letting AI tools handle multiple streams of work in parallel, like a real developer."
Harrison's guide is deliberately approachable ("for Beginners"), but its design decisions — sessions = project + Quick Chat + Canvas + Agent Merge — represent one of the main battlegrounds for AI coding tools in H2 2026.
---
References