GitHub Copilot now resolves merge conflicts in pull requests by comment

One of the most annoying tasks in the review flow gained direct automation in GitHub: merge conflicts in PR. The new feature allows you to ask Copilot to merge and try to resolve conflicts using a simple comment within the discussion itself.

The main reference for the article was published on March 26, 2026, in the official text Ask @copilot to resolve merge conflicts on pull requests. This helps to better separate what is a confirmed announcement from what is still a market projection.

What was announced

The suggested command is straightforward: mention @copilot and ask something like “Merge in main and resolve the conflicts”. According to GitHub, the agent runs in a cloud development environment, makes the necessary changes, checks build and tests and then sends the result.

Why this matters now

It seems like a detail, but it causes recurring pain for teams with many competing branches. By automating the mechanical work of reconciliation and basic checking, GitHub reduces a step that usually interrupts review, delays merges and creates unnecessary context for those focused on other tasks.

In a market that has already left the curiosity phase and entered the budget, operations and governance phase, announcements like this are important because they change the way companies, technical teams and creators choose platforms, integrate tools and define acceptable risk.

What this can change in practice

• Removes a mechanical step that often delays small and medium PRs.
• Keeps reconciliation work within the review flow, without switching tools.
• Forces teams to define when to accept automatic resolution and when to require deeper review.

What to watch out for in the coming weeks

What will define the real value of the function is the success rate in less trivial conflicts. In large repositories, the merge is not just text clashing: it involves contracts, side effects and fragile tests. If Copilot maintains quality in these scenarios, the operational gain can be very concrete.

The technique behind

Merge conflicts seem simple when they involve just a few lines, but they can hide architectural decisions. Two branches can change the same function for different reasons. An auto-resolver needs to understand context, testing, and likely intent for each change. Otherwise it joins text correctly and breaks behavior.

The value of Copilot is in reducing mechanical work: locating conflict, proposing initial combination and explaining what changed. The developer remains responsible for reviewing, running tests and confirming that the solution meets the PR objective.

The future it anticipates

Code tools are moving from suggestion to active maintenance. Resolving conflicts, updating dependencies, explaining failures, and preparing patches are time-consuming tasks without necessarily requiring deep creativity.

If assistants confidently take on these tasks, teams can spend more energy on product and architecture review. The question is where to draw the line: how far can AI tinker with a PR before human review is no longer sufficient?

The new frontier of review

Resolving conflict is a perfect task for testing trust in code agents because it falls somewhere between the mechanical and the semantic. There are cases where the correct solution is almost obvious: an import changed, a block was moved, a file received the same change in a different order. But there are cases where the conflict reveals a real divergence of intent between two branches. AI can accelerate the first category, but needs to signal uncertainty in the second.

For mature teams, the function can become a flow gain. Copilot makes the first proposal, runs checks and reduces repetitive work. The human reviews the diff with attention to behavior, not the textual gymnastics of the merge. The biggest curiosity is what comes next: if the AI ​​can already reconcile PRs, it will soon be required to explain impacts, suggest missing tests and anticipate regressions before the merge reaches main.

This evolution changes expectations about development tools. IDE, repository and CI start to behave as a continuous collaborative environment. The question for technical leaders will be what permissions to give these agents and how to measure whether they actually accelerate without reducing quality.

Sources

1. https://github.blog/changelog/2026-03-26-ask-copilot-to-resolve-merge-conflicts-on-pull-requests/