Stacked Sessions and Pull Requests: GitHub Copilot App Just Got a Major Upgrade

Imagine juggling three different coding tasks at once—fixing a bug, refactoring a module, and drafting a new feature—without losing context between them. That’s exactly what GitHub Copilot’s new stacked sessions feature promises. Combined with built-in pull request support inside the Copilot app, this update is reshaping how developers interact with AI-assisted coding.

Announced on July 30, 2026, the new capabilities are detailed in a GitHub blog post that highlights a shift from single-threaded AI conversations to a multi-lane development workflow. Let’s unpack what stacked sessions and pull request integration really mean for your daily coding routine.

What Are Stacked Sessions?

Stacked sessions allow you to run multiple, independent AI conversations simultaneously within the GitHub Copilot app. Instead of having one continuous chat that mixes ideas for different features or bug fixes, you can now create separate “sessions” for each task. Each session maintains its own context, conversation history, and generated code snippets.

Think of it like having multiple tabs in your browser—but for AI-assisted development. You can switch between sessions without losing state, making it easier to context-switch between urgent hotfixes and long-term feature work.

Key Benefits

• Parallel context management: No more “wait, I was working on the authentication refactor five minutes ago” moments.
• Focused problem solving: Each session stays laser-focused on one problem, reducing the chance of the AI mixing up unrelated code.
• Cleaner history: You can discard a session without affecting others, making experimentation less risky.

Pull Requests Inside the Copilot App

The second major addition is the ability to create, review, and manage pull requests directly from the Copilot interface. Previously, developers had to switch to GitHub’s web interface or use a separate tool to handle PRs. Now, the Copilot app doubles as a lightweight PR manager.

According to the announcement, you can:

• Create PRs from within a session, attaching relevant code changes generated or modified during that session.
• Review PRs with AI assistance: Copilot can summarize the changes, identify potential issues, and even suggest improvements.
• Manage PR comments and trigger CI checks without leaving the code editor or Copilot chat.

This integration closes the gap between writing code and shipping it. It reduces tool switching, which the developers behind the feature argue is a major source of context loss and friction.

Practical Workflow Example

Let’s walk through a realistic scenario. You’re working on a Python web app. You have a critical bug in the login module, a feature request for export-to-CSV, and a refactoring task for the database layer.

1. Start a session for the bug fix: Ask Copilot to help debug a 500 error in /auth/login. Copilot inspects the code, suggests adding exception handling, and generates a patch.
2. Stack a new session for CSV export: Without closing the first session, you open a second one. You ask Copilot to generate a function that queries recent orders and writes them to a CSV file. The AI builds the code, respecting existing project patterns.
3. Create a PR from the bug fix session: Once the patch is ready, you use the new PR feature inside that session. Copilot drafts a PR description, highlights the changed files, and even suggests reviewers based on git history.
4. Switch to the CSV session: You continue working on the export feature, then create another PR when done.
5. Review the bug fix PR: A colleague leaves comments. You open the PR view inside Copilot, see the comments, and ask Copilot to generate a fix. It proposes a modified approach, which you apply directly.

All of this happens without leaving the Copilot app. The sessions keep each task’s context isolated, preventing the AI from confusing the bug fix logic with the CSV export logic.

Code Sample: Switching Sessions in Practice

While the Copilot app hides session management behind a UI, the underlying API calls might look something like this (conceptual):

# Copilot API pseudocode for stacked sessions
session_bug = copilot.create_session()
session_bug.set_context(files=["auth/login.py"])
response = session_bug.ask("Why am I getting a 500 error on login?")
# response includes diagnosis and fix

session_csv = copilot.create_session()  # new stack
session_csv.set_context(files=["views/orders.py"])
response_csv = session_csv.ask("Generate CSV export function")

# Create PR from session_bug
session_bug.create_pr(title="Fix login 500 error", description="Fixed unhandled exception...")

This is a simplified illustration. The actual feature is implemented with a graphical interface, but the idea remains: sessions are first-class objects that can be created, switched, and linked to PRs.

Why This Matters: Shift from Copilot as Chatbot to Copilot as Development Platform

For years, AI coding assistants were seen as glorified autocomplete or chatbots. Stacked sessions and PR support elevate Copilot to a development environment in its own right. The GitHub blog post frames this as a move from “conversational AI” to “collaborative AI platform.”

Developers no longer need to copy-paste code between sessions or manually track what each conversation produced. The app now mirrors how real development works: messy, parallel, and iterative. This is especially valuable in team settings where multiple PRs are in flight simultaneously.

Potential Pitfalls and Considerations

No update is perfect. Some early adopters have raised concerns:

• Session explosion: With easy stacking, developers might create too many sessions and lose track. Good naming conventions and session management discipline are essential.
• Resource usage: Running multiple AI sessions might increase memory and API call consumption. GitHub hasn’t specified limits, but users should be mindful of rate limits.
• PR complexity: The built-in PR feature is powerful but doesn’t replace full GitHub UI for complex reviews involving many files or large diffs. It’s best for quick, focused PRs.

Looking Ahead

The stacked sessions and pull request integration signal GitHub’s long-term vision: make Copilot the centerpiece of the developer workflow, not just a sidekick. As AI models improve, these sessions could become persistent workspaces that remember your project’s entire history.

For now, the update is available to all Copilot users. The blog post encourages developers to try the new features and provide feedback. Based on the trajectory, expect deeper integration with GitHub Actions, code reviews, and project boards in future releases.

Source

Conclusion

Stacked sessions and pull request support are not just incremental features. They represent a fundamental rethinking of how developers interact with AI in their daily work. By allowing parallel, isolated conversations and bridging the gap between code generation and code shipping, GitHub Copilot is evolving from a helper into a platform. If you haven’t updated your Copilot app yet, July 2026 is the month to do it.