How to Stack PRs on GitHub (Without Installing a CLI)

The Day I Discovered PR Stacking

Last Tuesday at 3 PM, I was stuck. My authentication feature was ready for review, but I couldn't start on the dashboard that depended on it. My reviewer was in Sydney, sound asleep, and wouldn't see my PR for another 8 hours.

Sound familiar? If you've ever found yourself blocked by code review, unable to continue work that depends on your pending changes, you're not alone. But here's the secret: you don't need to wait. You can stack your PRs and keep shipping.

Why Traditional Code Review Slows You Down

The average pull request takes 24 hours to review. For distributed teams, that can balloon to 48-72 hours. But the real cost isn't time—it's momentum.

When you're blocked on code review, you lose:

• Context - Switching to unrelated work means rebuilding mental models later
• Progress - Features that depend on pending changes can't move forward
• Flow - That precious state where code seems to write itself? Gone.

The worst part? To minimize review cycles, we create massive PRs that are even harder to review. It's a vicious cycle.

Enter PR Stacking: Keep Building While You Wait

PR stacking is beautifully simple: instead of waiting for one PR to merge before starting the next, you create a chain of dependent pull requests that can be reviewed in parallel.

Traditional Workflow (Sequential)

Day 1: Create auth feature → Submit PR → Wait...
Day 2: Still waiting...
Day 3: PR merged → Start dashboard feature
Day 4: Submit dashboard PR → Wait...
Total time: 4-6 days

Stacking Workflow (Parallel)

Day 1 AM: Create auth feature → Submit PR #41
Day 1 PM: Create dashboard feature on top → Submit PR #42
Day 2: Both PRs reviewed in parallel
Day 3: Merge both → Ship
Total time: 2-3 days

The magic? You never stop building. While PR #41 is under review, you're already working on PR #42.

How to Stack PRs Using Just Git and GitHub

Here's the beautiful truth: you don't need any special tools to stack PRs. Just Git and GitHub. Let me walk you through it.

Step 1: Create Your First Feature Branch

# Start from main
git checkout main
git pull origin main

# Create your first feature
git checkout -b feature/add-auth
# ... make your changes ...
git add .
git commit -m "Add authentication system"
git push origin feature/add-auth

Now go to GitHub and create PR #41: feature/add-auth → main

Step 2: Stack Your Second Feature (Without Waiting!)

# DON'T go back to main. Stay on your feature branch
git checkout -b feature/add-dashboard

# Build on top of your auth changes
# ... make your dashboard changes ...
git add .
git commit -m "Add user dashboard"
git push origin feature/add-dashboard

Create PR #42 on GitHub, but here's the key: Set the base branch to feature/add-auth, not main.

Your stack now looks like this:

main
  └── feature/add-auth (PR #41)
        └── feature/add-dashboard (PR #42)

Step 3: Continue Stacking as Needed

# Keep building!
git checkout -b feature/add-notifications
# ... make changes ...
git push origin feature/add-notifications

Create PR #43 with base branch feature/add-dashboard. You can stack as deep as makes sense for your feature.

Managing Your Stack During Review

When Changes Are Requested on PR #41

# Go back to your first branch
git checkout feature/add-auth
# ... make requested changes ...
git add .
git commit -m "Address review feedback"
git push origin feature/add-auth

# Now update your dependent branches
git checkout feature/add-dashboard
git rebase feature/add-auth
git push --force-with-lease origin feature/add-dashboard

When PR #41 Gets Merged

# Update your local main
git checkout main
git pull origin main

# Rebase PR #42 onto main
git checkout feature/add-dashboard
git rebase main

# Update PR #42's base branch on GitHub to 'main'
git push --force-with-lease origin feature/add-dashboard

Now PR #42 is ready to merge directly to main!

The Hidden Challenge: Keeping Track of Your Stack

Stacking PRs with Git works great, but there's one challenge: visibility.

When you have 5 PRs in a stack:

• Which PR depends on which?
• What order should reviewers look at them?
• Which PRs need rebasing after a merge?
• Has the parent PR been merged yet?

You end up maintaining a mental map or a spreadsheet just to track dependencies. Your reviewers are even more confused—they see 5 PRs and don't know where to start.

Enter Stacklane: Your Stack, Visible at Last

This is where Stacklane comes in. It's a free GitHub App that automatically detects your stacked PRs and adds a single comment to each one showing the complete dependency chain.

What Stacklane Does

When you install Stacklane and create stacked PRs, each PR automatically gets a comment like:

🧱 Stack PR 2 of 3
├── Depends on: #41 (feature/add-auth) ✅ merged
└── Parent of: #43 (feature/add-notifications)

That's it. No CLI to install. No commands to learn. Just instant visibility for you and your reviewers.

How It Works

1. Install the GitHub App - One click, works for your whole team
2. Keep using Git normally - No new commands or workflows
3. Get automatic updates - When you rebase or merge, comments update in real-time

Your reviewers instantly know to review PR #41 first. When it merges, the comment updates to show ✅ merged. No more confusion, no more spreadsheets.

The Complete Stacking Workflow

Here's how I now ship features 3x faster using Git stacking with Stacklane:

1. Install Stacklane (Once)

Go to github.com/apps/stacklane-pr-stack-visualizer and install it on your repositories. Takes 30 seconds.

2. Create Your Stack

# Feature 1: Authentication
git checkout -b feature/auth
# ... code ...
git push origin feature/auth
# Create PR #41: feature/auth → main

# Feature 2: Dashboard (depends on auth)
git checkout -b feature/dashboard
# ... code ...
git push origin feature/dashboard
# Create PR #42: feature/dashboard → feature/auth

# Feature 3: Notifications (depends on dashboard)
git checkout -b feature/notifications
# ... code ...
git push origin feature/notifications
# Create PR #43: feature/notifications → feature/dashboard

3. Watch the Magic

Each PR automatically gets a Stacklane comment:

• PR #41: 🧱 Base of stack · Parent of #42
• PR #42: 🧱 Stack PR 2 of 3 · Depends on #41 · Parent of #43
• PR #43: 🧱 Stack PR 3 of 3 · Depends on #42

4. Review and Merge with Confidence

Reviewers see the order instantly. As PRs merge, comments update automatically. No manual tracking needed.

Why This Changes Everything

For You

• Ship 3x faster - No more waiting for reviews to continue working
• Maintain flow state - Keep building instead of context switching
• Smaller, focused PRs - Each change is atomic and easy to review

For Your Team

• Clear review order - No more "which PR should I review first?"
• No learning curve - Everyone already knows Git and GitHub
• Works with any workflow - Rebase, merge, squash—Stacklane handles it all

For Your Velocity

• Parallel reviews - Multiple PRs reviewed simultaneously
• Faster feedback loops - Catch issues early in smaller changes
• Reduced merge conflicts - Smaller changes = fewer conflicts

Start Stacking Today

You don't need to wait for your team to adopt a new tool. You don't need to learn a CLI. You can start stacking PRs right now with the Git commands you already know.

And when you add Stacklane, your stacks become visible to everyone—turning confusion into clarity with zero effort.

Here's your action plan:

1. Install Stacklane - Get the free GitHub App (30 seconds)
2. Create your first stack - Branch from a branch instead of from main
3. Open stacked PRs - Set the base branch correctly on GitHub
4. Ship faster - Watch as Stacklane keeps everyone in sync

The best part? It's completely free. No paid tiers, no limits. Because we believe every developer deserves to ship without waiting.

Stop Waiting. Start Stacking.

A year ago, I was that developer refreshing GitHub at 3 PM, waiting for reviews. Today, I ship features continuously, my PRs are smaller and cleaner, and my reviewers actually thank me for the clarity.

The workflow is simple. The tooling is free. The results are immediate.

Your next feature doesn't have to wait for review. Stack it, ship it, and let Stacklane handle the visibility.

Ready to ship 3x faster?