GitHub's Copilot app now supports stacked sessions and pull requests, allowing developers to break large refactoring tasks into sequential, chainable work units.
A developer demonstrated the feature by modernizing a personal project that uses React 15 (released in 2016) and outdated dependencies—work that would have been prohibitively time-consuming before AI assistance.
Instead of creating one massive pull request, she used the app to generate multiple stacked sessions where each session and its pull request automatically built on the previous one, making the entire refactor manageable and reviewable.
What happened
The GitHub Copilot app now enables developers to create stacked sessions—a series of tasks in the same repository where each session builds on the previous one—and automatically generates corresponding stacked pull requests. A developer used the feature to modernize a decade-old personal project, breaking a complex modernization task (updating React 15, removing Less CSS, replacing react-bootstrap) into multiple sequential sessions rather than one large pull request.
Why it matters
Modernizing legacy codebases without AI assistance would take weeks or months of manual work; the author notes she had previously given up on this exact project. Stacking sessions lets developers avoid scope creep by breaking large refactors into smaller, reviewable pull requests that chain together logically—each PR targets the branch of the PR below it, ultimately landing on main. This approach makes shipping changes simpler and reduces risk compared to one massive pull request.
What to watch
The feature is available now in the GitHub Copilot app and in pull request stacks anywhere you commit code on GitHub. Developers working on legacy codebases or large refactors can test the workflow by starting a session, creating a plan, and using the app to automatically create follow-on stacked sessions when scope grows.
The author, a senior director for developer advocacy at GitHub, decided to modernize a personal "life" dashboard app she built in late 2014. The codebase had not been significantly updated in years despite occasional maintenance. It used React 15 (released in 2016), Less for CSS pre-processing, and an old version of react-bootstrap—a combination the author describes as "embarrassingly old." Attempting this modernization without AI would have taken weeks; she had tried and given up before.
Using the GitHub Copilot app, she started by asking the tool to create a plan for modernization. She specified that she wanted to use either Tailwind or vanilla CSS (asking the tool to help decide), remove Less entirely, improve accessibility and responsiveness, and modernize dependencies—but wanted to focus on styles first, then gradually reorganize the React code. She emphasized that "nothing is sacred" and it was acceptable to completely restart parts of the code.
When she ran the app's first attempt based on the plan (using Claude Opus 4.8 and GPT-5.5 for review), the changes did not work as expected—a failure she attributes to her own mistake. She realized she had a partially-updated dev branch from a previous attempt that created compatibility issues. Rather than abandon the work, she asked the Copilot app to switch gears: keep her styling decisions but apply them to the dev branch instead. The app created a new session, closed the failed pull request, and ported her work appropriately—a flexibility that impressed her.
After testing the working branch, she noticed console warnings referencing deprecated React functions (findDOMNode and componentWillReceiveProps) that were coming from react-bootstrap, not her code. She used Plan mode again to decide whether to upgrade react-bootstrap or replace it entirely. The app recommended replacing the library. Rather than add this to the existing pull request (which she feared would become a massive, hard-to-review changeset), she used a new feature: stacked sessions. She asked the Copilot app to finalize the current work as one pull request, then create a new stacked session for the react-bootstrap replacement that would branch off the completed work and generate its own separate pull request to merge afterward.
The app then performed several steps automatically: it created a pull request for all her existing changes, created a "stacked session" for react-bootstrap removal (taking previous context, generating a plan, waiting for approval, and running), and created a stacked pull request that would target the completed first PR. This chaining of sessions and pull requests felt, in her words, magical. A "stack" is a series of pull requests in the same repository where each targets the branch of the PR below it, ultimately landing on main. In her case, not only did the sessions follow each other logically, but their code changes were ordered correctly too.
Looking back at her original screenshot of the sessions, she described each layer: the repo, the "Frontend modernization" session name, the first (failed) attempt at a pull request marked in red, the working pull request for the dev branch, and the in-progress stacked session for react-bootstrap changes. The author concludes that while software development has traditionally been messy and complex, tools like the GitHub Copilot app with stacked sessions and pull requests make the process substantially simpler, especially when modernizing legacy code. She recommends others try this approach if they are considering modernizing their own codebases.
The blog post documents a concrete workflow improvement in the GitHub Copilot app: the ability to chain multiple AI-guided development sessions together so that each session's changes build logically on the previous one. The author's use case illustrates why this matters in practice. She had a decade-old personal project (last major updates in 2014) that had become increasingly difficult to maintain—it used React 15, Less CSS preprocessing, and an old version of react-bootstrap. Attempting the modernization as a single large task would have taken weeks or required giving up entirely (which she had done before). By breaking the work into stacked sessions, she was able to handle compatibility issues separately, avoid scope creep (a constant temptation when AI is doing the coding), and ship multiple focused pull requests instead of one unwieldy mega-PR.
The feature appears to address a real pain point in developer workflows: the gap between "I want to refactor this large codebase" and "I want to review and merge changes safely." Stacking allows developers to accept AI's help on large tasks without sacrificing code review discipline or creating dangerously large changesets. The author's excitement about the feature suggests it resonates with developers who use AI coding tools regularly and want to maintain good engineering practices while benefiting from AI assistance.
AI-summarized, only the topics you pick — one digest a day via Email, Slack, or Discord.
Free · takes 30 seconds · unsubscribe anytime
ByteDance is reorganizing Doubao (its AI chatbot), Lark (workplace software), and Volcengine (cloud infrastruc…
Nvidia CEO Jensen Huang identified memory chips as AI's largest bottleneck, shifting focus from the earlier pr…
OpenAI cut GPT-5.6 Luna prices by 80% (now $0.20 per million input tokens and $1.20 per million output tokens)…
Anthropic disclosed that three Claude models—Opus 4.7, Mythos 5, and an internal research test model—gained un…
Hitachi announced the Agentic AI Integration Platform, which applies AI agents across the entire systems integ…
Amazon is positioning itself as the platform provider for AI rather than competing to build the best AI model
The AI news that matters, in one minute each morning.
Sign up free