How Graphite Handles Git Merge Conflicts: Complete Guide

Written by: Ali-Reza Adl-Tabatabai, Founder and CEO, Gitar

Key Takeaways

1. Graphite prevents about 90% of merge conflicts in stacked PRs using gt sync, gt restack, and merge queue automation.
2. Manual conflict resolution follows five steps: detect with gt status, edit files, stage with git add ., continue with gt continue, and requeue with gt submit.
3. Keeping PRs under 400 lines reduces complex “fake” conflicts from dependency chains in stacked workflows.
4. Graphite resolves conflicts but not the CI failures, lint errors, or review feedback that often follow, so manual work remains.
5. Pairing Graphite with Gitar’s AI Healing Engine adds automatic CI fixes and review implementation during the Team Plan trial.

The Problem: Merge Conflicts Dragging Down Graphite Stack Velocity

AI coding tools increased code output 3–5x, yet PR review time increased 91% as teams struggle to keep up. This review bottleneck persists even with Graphite’s stack-aware merging, because “fake” conflicts from dependency chains and queue ejections still stall progress for hours.

These conflicts are rarely true semantic issues. They usually appear as artifacts of stacked workflows where downstream PRs depend on upstream changes. When the merge queue encounters conflicts, it ejects entire stacks, which forces manual Git operations and context switching. As already reported, teams lose roughly 30% of development time to CI friction, even after investing heavily in automation.

Graphite reduces this pain through three layers: automated prevention with stack-aware rebasing, intelligent queue management that processes full PR stacks, and fallback manual resolution workflows. Developers still face CI failures, lint errors, and review feedback after conflicts, so a significant portion of the cleanup work remains manual.

Graphite’s Automated Conflict Prevention with gt sync, gt restack, and Merge Queue

Graphite’s first layer of defense against merge conflicts relies on three core CLI commands and queue automation that keep your stack aligned with main. See the Gitar documentation for full command reference and examples.

gt sync pulls the latest changes from the main branch and automatically rebases your entire stack. This command keeps your stack current with upstream changes and prevents many conflicts before they appear:

gt sync # Fetches latest main branch # Rebases entire stack automatically # Updates all dependent PRs

gt restack repairs parent–child dependencies when conflicts appear inside your stack. This command becomes essential when upstream PRs in your stack are merged or updated:

gt restack # Analyzes stack dependencies # Rebases dependent branches # Maintains proper parent-child relationships

Graphite’s merge queue provides the most advanced conflict prevention in this workflow. The queue automatically rebases downstream PRs when the head of the stack merges, which resolves most conflict scenarios without manual work. It also chooses a merge order for entire stacks instead of treating each PR in isolation, so changes land in a sequence that avoids many semantic conflicts.

The merge queue further reduces friction by batching CI runs and cutting redundant builds. Instead of running CI on every PR separately, it processes stacks in parallel and groups related changes, which shortens feedback cycles and reduces wasted compute.

Step-by-Step Manual Merge Conflict Resolution in Graphite

Graphite’s automation sometimes encounters conflicts it cannot resolve on its own, so you still need a clear manual process. Follow this five-step flow when that happens. See the Graphite documentation for detailed conflict resolution workflows.

1. Detect Conflicts

Run gt status to identify conflicted files. Git flags conflicts during merge, rebase, or cherry-pick operations when it cannot automatically reconcile differences between commits:

gt status # Shows conflicted files marked with “UU” # Displays current rebase/merge state

2. Edit Conflicted Files

Open each conflicted file in your editor and remove conflict markers such as <<<<<<< HEAD, =======, and >>>>>>> branch-name. Choose the correct changes from each side or merge them into a single coherent version.

3. Stage Resolved Files

After you finish editing and resolving conflicts, stage the files with git add .:

git add . # Stages all resolved files

4. Continue the Operation

Use gt continue or git rebase –continue to resume the rebase or merge after staging your fixes. This step completes the conflict resolution phase and lets Graphite process the rest of the stack:

gt continue # Continues the Graphite operation # Processes remaining stack dependencies

5. Submit and Requeue

After you complete the resolution and continuation steps, run gt submit to update your PRs and place them back into the merge queue.

Once gt continue finishes, you can let Gitar handle the resulting CI, lint, and test failures automatically instead of debugging each new issue by hand.

Stack-Specific Fixes and Best Practices for Graphite Users

Stacked PR workflows introduce conflict patterns that rarely appear in traditional Git flows. Many of these issues look like conflicts but actually reflect dependency ordering problems inside the stack.

Re-targeting Branches

When upstream PRs in your stack merge, downstream branches sometimes need new targets. Graphite usually manages this automatically, yet tricky semantic conflicts can still require manual re-targeting and restacking.

Preventing Cascade Failures

Large PRs exceeding 2,000 lines across 30+ files degrade code quality and review effectiveness, with review effectiveness dropping sharply after 200–400 lines. This degradation becomes especially painful in stacked workflows, where a single oversized PR can trigger conflicts that ripple through every dependent branch. Keep individual PRs in your stack focused and under 400 lines to prevent these complex cascades.

To understand how Graphite’s stack-aware model reduces these problems compared with plain Git, review this side-by-side summary:

These stack-aware capabilities make Graphite powerful for conflict prevention, but they still leave a gap around the cleanup work that follows merges.

Beyond Graphite: Gitar’s AI Healing Engine for Post-Conflict Cleanup

Graphite significantly reduces conflicts yet cannot remove the manual work that follows conflict resolution. CI failures, lint errors, test breaks, and review feedback still demand developer attention, which slows teams that already face heavy review backlogs.

Gitar addresses this second half of the problem with an AI Healing Engine that analyzes failures, generates validated fixes, and commits them directly to your PRs. When you finish Graphite’s manual conflict process, Gitar can take over the remaining toil, including CI failures and review feedback. The key difference lies in where each tool’s automation stops and where manual work would normally begin:

Teams report that Gitar’s summaries stay concise and focus on signal instead of noise, using a single updating comment to keep the thread readable.

See how Gitar removes the remaining manual steps from your Graphite workflow and experience AI-powered automation during the trial period.

5 Ways Gitar Complements Graphite Workflows

1. CI Failure Auto-Fix

Gitar analyzes and fixes CI failures, lint errors, and test breaks that appear after Graphite resolves merge conflicts, so developers avoid repetitive debugging.

2. Review Feedback Implementation

Beyond CI failures, Gitar also handles the human feedback loop. When reviewers leave comments, Gitar implements the requested changes directly in your PRs.

3. Validate Fixes Against CI

Gitar validates every proposed fix against your actual CI environment before committing, which keeps builds green and reduces noisy back-and-forth.

4. Single Comment Interface

Gitar consolidates findings, fixes, and status updates into one dashboard-style comment that updates in place, so reviewers track progress without scrolling through long threads.

5. Natural Language Automation

You can define repository rules in plain English that trigger automatic actions on PR events, then observe how those rules behave during your trial.

Frequently Asked Questions

How do you resolve merge conflicts in Graphite?

Follow the five-step flow: detect conflicts with gt status, edit conflicted files to remove markers, stage changes with git add ., continue with gt continue, and requeue with gt submit. For automated handling of the CI failures and review feedback that follow, Gitar’s trial adds AI-powered fixes on top of your existing Graphite process.

What does gt restack do for conflicts?

The gt restack command repairs parent–child relationships inside your stack when conflicts appear. It analyzes stack structure and rebases dependent branches to maintain a clean hierarchy. Gitar then takes care of the CI failures and review changes that often surface after restacking.

Does Graphite auto-fix CI after conflicts?

No. Graphite focuses on preventing and resolving merge conflicts, not on fixing CI failures, lint errors, or test breaks that come afterward. Gitar fills this gap by automatically analyzing and repairing CI failures during the trial period, which keeps builds healthy without extra manual effort.

How should you troubleshoot Graphite merge queue conflicts?

When the merge queue ejects stacks because of conflicts, resolve them using the standard Git conflict process, then requeue the stack. Typical causes include semantic conflicts from out-of-order merges and dependency chain problems. Gitar then handles the CI fallout by analyzing patterns and generating validated fixes during your trial.

Conclusion: Restore Velocity with Graphite Plus Gitar

Graphite’s stack-aware automation prevents most merge conflicts through intelligent rebasing and queue management. The gt sync, gt restack, and merge queue features handle stacked workflow complexity and keep branches aligned.

Conflict resolution still marks only the halfway point. CI failures, lint errors, test breaks, and review feedback continue to slow teams when handled manually. Gitar’s AI Healing Engine removes this remaining toil by fixing issues automatically and validating changes against your real CI environment.

The combined workflow delivers near-zero-toil merges: Graphite prevents and structures your changes, and Gitar heals the downstream problems that follow. Install Gitar to automatically repair broken builds and ship higher quality software faster.