Rob's intro to the new GitHub Copilot app

Rob gives a first look at the new GitHub Copilot desktop app, showing how it shifts Copilot work into a project-based, chat-first workflow. He demonstrates starting sessions from issues and PRs, running multiple concurrent worktrees, and letting Copilot plan, implement, and open pull requests with checks and merge handling.

Full summary based on transcript

What the new GitHub Copilot app is

• A desktop GitHub application (shown on Windows, described as platform-agnostic) that provides a new way to work with GitHub Copilot outside of:
  • the Copilot CLI
  • editor integrations
• The UI is chat-first (no traditional code editor view), focused on helping an engineer complete tasks.

Navigation: inbox, projects, and sessions

• The left navigation includes:
  • Home
  • Inbox (work that needs attention)
  • Other options aimed at automating work
• The app introduces a project concept:
  • Projects can represent a group of repositories (demo uses a single repo).
  • Work is framed as sessions against a project rather than “opening a repo in an editor.”
• Ways to start work include:
  • choosing a local folder
  • selecting a repository from GitHub
  • cloning from a URL and then chatting against that codebase

Working from PRs and issues inside the app

• From the inbox, Rob opens items in context:
  • PRs (including a PR created by Dependabot)
  • Issues
• PR workflow shown in-app:
  • view PR status and checks
  • inspect changed files
  • do review work without switching to the web UI

Starting an agentic session from an issue

• Rob selects an issue about upgrading to a newer Node.js version (Node.js 24).
• He starts a session from the issue context.
• The session:
  • ensures the repository exists on disk
  • creates a working context for the task
  • uses both issue context and repository context
• Rob describes this as an agentic workflow where the session tries to determine what needs to be done.

Multiple concurrent sessions using Git worktrees

• The app uses a worktree-based approach so multiple sessions can run concurrently against the same repository.
• Rationale given:
  • avoids the limitation of “one branch per working copy” when trying to do multiple tasks at once
  • enables parallel work without manually juggling branches

Planning vs autopilot execution

• The session defaults to creating a plan when started from an issue.
• The app offers execution modes:
  • Autopilot (run everything automatically)
  • Interactive (step-by-step collaboration)
• Rob notes you can:
  • choose among supported Copilot models
  • set a “thinking effort” level for the selected model

Custom instructions and agent.md

• Rob mentions he has custom instructions configured so the agent will always implement an agent.md file.
• The session picks up these extra user-side instructions as part of its workflow.

Implementing changes and creating a PR

• After approving the plan, the agent proceeds to implement changes.
• The agent has an explicit notion of completing work by creating a PR.
• Rob demonstrates switching to another project while the first session continues in the background.

Starting a session from a repository URL

• Rob starts a new session by pasting a GitHub repository reference (noting it needs to be in owner/repository form).
• He asks the agent to review the repo and suggest three improvements.

Commit signing interaction

• Rob has commit signing enabled.
• The agent’s workflow requires user input to complete signed commits (entering the passphrase).
• He notes he has an instruction to retry if commit signing fails.

Reviewing session artifacts: plan, context, terminal

• In the sidebar, Rob can see:
  • the original plan derived from the issue
  • additional context gathered during execution
• The app provides a terminal scoped to the worktree context so commands can be run as needed.

PR checks, automerge, and “agent merge”

• The agent creates the PR with a summary and triggers normal GitHub PR checks.
• Rob describes standard automerge behavior:
  • merge when ready
  • blocked by failing checks or merge conflicts
• The app adds agent merge, which Rob describes as:
  • validating the PR
  • waiting for required checks
  • if checks fail, downloading logs and attempting remediation
  • if merge conflicts occur, resolving them by creating and pushing additional commits
  • notifying the user when complete

Splitting work into sub-agents and parallel PRs

• Rob asks the agent to make changes for multiple improvement items and:
  • create a branch and PR for each item
  • run sessions in sub-agents
• The app splits the work into multiple sub-sessions (agent one, two, three) and shows progress for each.
• When complete, it provides a summary and leaves Rob to review the created PRs (stopping at review by default).

What this changes in day-to-day workflow

• Moves Copilot work into a dedicated desktop app with:
  • project/session context
  • issue/PR-driven entry points
  • background execution across multiple concurrent worktrees
  • PR creation and merge assistance (including remediation and conflict handling)
  • parallelization via sub-agents for multi-item maintenance work