Git 2.56: Safer Conflicts, a Tidier Repo, and Much Faster History
Git 2.56 landed in late September 2026 with one theme: stop the small mistakes that cost teams hours. Here is what changed, from git add --resolved and branch cleanup to merge-base speedups that turn minutes into milliseconds.
Amir Ali Liaqat · Founder & CEO, DesignsToDeploy

Most developers do not think about Git until it gets in the way. A resolved merge conflict gets staged with a stray marker still in the file. A diff on a massive repository hangs long enough to grab coffee. A branch list grows so long nobody wants to clean it up. Git 2.56, released in late September 2026, goes after those small but persistent problems, with contributions from 104 developers, 39 of them first-time contributors, according to the GitHub release post by Elijah Newren. It is not a flashy release. It is the kind of release that quietly saves every team a little time, every day.
Safer conflicts: git add --resolved
Resolving a merge conflict usually ends with running git add on the files you fixed. The trouble is that plain git add is blunt: it can stage unrelated changes, or stage a file that still contains conflict markers. The new git add --resolved option narrows that step. It considers only paths that are currently unmerged in the index, and it scans those files for leftover conflict markers before staging anything. If markers remain, it aborts. Your unrelated local edits stay untouched while only the genuinely resolved paths get staged. It is a small guardrail, but for anyone who has pushed a marker line into a shared branch, it is a welcome one.
Cleanup: branches and history
The new git branch --delete-merged option cleans out branches that have already been merged upstream, with pattern matching and a dry-run flag so you can see what will go before it goes. The experimental git history command, which debuted in Git 2.54 and keeps growing, gains a drop operation: git history drop removes a selected commit and replays its descendants onto its parent, aborting if the replay would clobber your work. It stays scoped to histories without merge commits and to targets that are not the root or a merge, so treat it as experimental, but it points at a future where history editing is a normal command, not a rebase puzzle. Elsewhere in the release, git bisect run gains a reset option that finds the culprit commit and cleans up in one step, and Git now catches common command-line slips, such as typing git push origin/main when you meant git push origin main, and suggests the fix.
Speed: minutes become milliseconds
Performance gets a lot of attention in this release, and some of the numbers are striking. Git now finds merge bases, the common ancestor between two branches, more efficiently by ending its history traversal earlier once it has what it needs. On the Linux kernel, git merge-base --all v4.8 v4.9 dropped from 167,441 traversal steps and 0.29 seconds to 3,887 steps and 0.01 seconds, and a monorepo case fell from 0.68 seconds to 0.01 seconds. A fix to path-limited working-tree diffs removed quadratic scans: on a Chromium checkout with roughly 500,000 index entries, one affected git diff went from about eight minutes to 0.07 seconds. Storage improves too: path-walk repacking now works with reachability bitmaps and delta islands, and in the Fluent UI repository an ordinary bitmapped repack produced a 558.5 MB pack while repacking with --path-walk produced a 164.4 MB pack, about 71 percent smaller.
Why this release matters now
None of these changes will reshape how teams use Git. That is not the point. Git is infrastructure, and every CI run, code review, and pull request depends on it. The speed and safety gains matter more now because people are not the only ones using Git: AI coding agents run Git operations at machine speed, opening branches, resolving conflicts, and rebasing constantly, so a conflict marker staged into a shared branch becomes verification debt someone has to find. The practical takeaway for teams is simple. Check which Git version your build agents, developer workstations, and hosting platforms are running, and write the new safety options into team conventions now, before the next messy merge.
Our take
At DesignsToDeploy, we treat tooling upgrades like this as cheap insurance. A guardrail that stops one bad staging, a cleanup habit that keeps branches readable, and faster history operations across every pipeline add up to calmer releases. If your team still treats Git as something you only touch when it breaks, Git 2.56 is a good reason to update and adopt two new habits: stage resolved conflicts with git add --resolved, and preview branch deletions before they happen. Small habits, enforced by the tool itself, are how good teams stay fast.
1 / 5Keep reading

Node 26 Goes LTS: Patch First, Upgrade Smart
On October 28, 2026, Node.js 26 becomes the long-term support release your production apps should run on. Five days earlier, a security release patched Node 22, 24 and 26 together. Here is the timeline, the fixes, and the safe upgrade order.
Read article
VS Code 1.145: Coding Agents That Work While You Sleep
VS Code 1.145 shipped November 4, 2026, turning the editor into an agent host: remote agents you can preview in the Agents window, automations on a five-field cron schedule, and nested sessions that mix harnesses. What changed, what is still preview, and the four moves to set it up today.
Read article
GitHub Copilot Now Works in Xcode and JetBrains Air
On November 3 and 4, 2026, GitHub put Copilot inside Xcode's built-in coding assistant and JetBrains Air. One subscription now works across the IDEs developers already use, with cloud tasks in isolated sandboxes and no new JetBrains subscription required. What changed, what it costs, and the three moves to try it this week.
Read article