Modernizing the Legacy: How Stacked Sessions and Pull Requests are Redefining Developer Workflows

In the rapidly evolving landscape of software engineering, technical debt is often the silent killer of productivity. For many developers, the prospect of updating a codebase that has sat stagnant for over a decade is daunting, bordering on prohibitive. However, a new paradigm in AI-assisted development—centered around the GitHub Copilot app’s "stacked sessions" and "stacked pull requests"—is turning these overwhelming projects into manageable, iterative successes.

This transformation is not merely about writing code faster; it is about fundamentally changing how we architect, branch, and ship software. By leveraging agentic AI to handle the heavy lifting of refactoring, developers are finding that they can finally tackle the "too painful to touch" projects that have been collecting digital dust for years.

The Weight of Technical Debt: A Decade in the Making

For many, a personal side project is a labor of love that eventually becomes a source of anxiety. Consider the case of a personal "life dashboard"—a repository that tracks home smart devices, calendars, and task management. First conceptualized in 2014, the codebase was functional but relied on an architectural stack that had become archaic.

By mid-2026, the project was running on React 15, a version released in 2016, and was heavily dependent on react-bootstrap and the Less CSS pre-processor. These dependencies were not just "old"—they were incompatible with modern development standards, security best practices, and accessibility requirements. The developer, in this instance, had attempted to modernize the app multiple times, only to be defeated by the complexity of unraveling interconnected, legacy components. The "juice was simply not worth the squeeze."

The arrival of advanced AI agents, however, changed the calculus. By utilizing the GitHub Copilot app to interact with the repository, developers can now offload the mental burden of dependency management and structural refactoring.

Chronology of a Modernization Effort

The modernization process was not a simple "one-shot" migration. It required a nuanced, step-by-step approach that highlighted the limitations—and the ultimate power—of current AI tooling.

Phase 1: The Initial Strategy

The first attempt involved an ambitious, all-encompassing plan to modernize the frontend, replace Less with Tailwind CSS, and clean up accessibility. The developer utilized "Plan mode" in the Copilot app, creating a comprehensive list of requirements:

Complete overhaul of styling, prioritizing responsiveness and accessibility.
Removal of legacy CSS pre-processors.
Gradual consolidation of React components.
Modernization of dependencies.

When the AI attempted to execute this plan, it initially failed. This failure was not a flaw in the model but a lesson in project context: the developer had forgotten that a dormant dev branch contained previous, half-finished modernization attempts that were partially integrated into the production deployment.

Phase 2: Correcting the Course

Recognizing the conflict between the main branch and the dev branch, the developer was able to pivot seamlessly. Instead of manually reconciling the differences—a process that would typically involve hours of tedious "git merges" and conflict resolution—the AI agent suggested a strategy: close the current pull request (PR) and restart the session, branching directly off the dev environment. This ability to switch contexts, maintain history, and re-apply styling logic to a new branch represents a significant leap in how developers manage their workstreams.

Phase 3: The "Stacking" Innovation

The core of the project’s success lay in the introduction of "stacked sessions." As the modernization progressed, the developer identified a new problem: the legacy react-bootstrap library was riddled with deprecated references like findDOMNode and componentWillReceiveProps.

Stacked sessions and pull requests in the GitHub Copilot app

Rather than succumbing to "scope creep"—the tendency to combine too many changes into a single, massive PR—the developer utilized the stacked sessions feature. By creating a separate session for the library replacement that depended on the previous styling work, the developer could logically separate the concerns:

Session 1: Modernize frontend styles and apply accessibility improvements.
Session 2: Remove react-bootstrap and implement a modern UI library.

The Mechanics of Stacked Pull Requests

Stacked pull requests represent a shift from the traditional "monolithic PR" model. In this workflow, a series of PRs are created in the same repository, where each PR targets the branch of the one below it. This creates an ordered, logical chain of changes that eventually lands on the main branch.

Why Stacking Matters

Granularity: Reviewers (or the developer themselves) can review bite-sized, logical changes rather than thousands of lines of code.
Safety: If a specific part of the modernization fails, only that segment of the stack is affected, rather than the entire project.
Continuous Progress: It allows for the incremental integration of complex changes without destabilizing the application’s core functionality.

For the developer, this meant that the styling changes were shipped and verified in the first PR, providing a stable foundation before the more dangerous, high-impact removal of core library dependencies.

Implications for Modern Development

The integration of these features into the GitHub Copilot app is part of a broader trend: the rise of "agentic engineering." In this model, the developer acts more as an architect and project manager than a traditional coder.

The Shift in Productivity

Traditional development often involves a "stop-start" rhythm: code, test, fix, commit, merge, repeat. The agentic approach allows for a "fluid" workflow. Because the AI maintains state across sessions, the developer can pause, change directions, or add new requirements without losing the context of the previous work. This effectively eliminates the "cognitive tax" of context switching.

Reducing "Procrastination by Complexity"

One of the most profound revelations from this project is the psychological component of coding. Developers often avoid massive refactoring projects because the perceived difficulty makes the task feel insurmountable. When AI tools can handle the implementation details, the "fear of the massive PR" dissipates. The developer is no longer staring at a 10,000-line diff; they are managing a sequence of clean, focused PRs.

Official Industry Perspectives

While these tools are currently in public preview, the industry reaction has been largely optimistic. GitHub’s integration of these features into the Copilot app is a clear signal that the company is moving toward an "AI-first" developer experience. By enabling features like stacked sessions, GitHub is addressing the primary pain point of AI coding assistants: the loss of context when moving between tasks or branches.

Industry analysts suggest that this will likely lead to a "great modernization" of enterprise software. Companies with massive, aging codebases that have been deemed "too risky to update" may now have a viable path forward, using AI agents to navigate the complexities of legacy architecture.

Conclusion: A New Era for Old Code

The modernization of a 2014-era life dashboard is a microcosm of the challenges facing the broader software industry. We are currently sitting on a mountain of technical debt, much of which is maintained by developers who lack the time or the tools to properly address it.

Stacked sessions and stacked pull requests do not just make the process easier—they make it sustainable. By turning a massive, daunting refactor into a series of small, manageable, and highly logical steps, these tools empower developers to breathe new life into their projects. As we move forward, the question for many will no longer be "is it worth the effort to modernize?" but rather, "how quickly can we leverage these agents to get it done?"

For those looking to modernize their own codebases, the message is clear: the technology to bridge the gap between yesterday’s code and tomorrow’s standards is finally here. The only thing left to do is start the first session.