The Commit Message Wasn’t Mine Anymore
GitHub Desktop 3.6, Copilot, and the quiet invasion of Git history
At 12:18 PM I had GitHub’s changelog open in one tab and my own terminal sitting underneath it like a witness with bad posture.
The terminal said the repo was clean.
The changelog said GitHub Desktop 3.6 now has deeper Copilot integration: commit authoring, merge conflict resolution, and worktree support. A two-minute release note. Corporate calm. Product-manager prose wrapped around something that made the old animal part of my developer brain sit up and bare its teeth.
Because this is not really about a desktop app.
It is about where the agent moves when the editor stops being enough.
For the last two years the AI coding story has been trapped in the little glowing rectangle where code gets typed. Cursor. Copilot. Claude Code. Codex. The editor became the arena because code generation was easy to visualize there: autocomplete on steroids, chat in the sidebar, a ghostly pair programmer whispering imports into your file until the build stopped screaming.
But software is not only code.
Software is history. Branches. Conflicts. Commit messages. Pull requests. Review rituals. Half-remembered decisions buried under git log --oneline, the archeological record of who broke what and what story they told while doing it.
GitHub Desktop 3.6 matters because Copilot is stepping into that layer.
Not the place where code is written.
The place where code becomes accountable.
The Workflow Layer Has Blood In It
GitHub’s own wording is tidy enough to be dangerous. Desktop 3.6 brings “more of your day-to-day Git flow into one place,” with Copilot powering commit authoring and merge conflict resolution, plus Git worktree support.
Commit authoring sounds harmless. It always does.
A commit message is just a label until you need it six weeks later, when production is making a noise like wet cardboard in a fan and someone is asking why authentication behaves differently on Tuesdays. Then the commit message becomes testimony. It is the smallest unit of narrative responsibility in software.
fix stuff is a misdemeanor.
handle null refresh token during provider fallback is evidence.
So when Copilot starts helping author commits, the question is not whether it writes a prettier sentence. Of course it can. The question is whose interpretation gets preserved. The human who made the change? The model that summarized the diff? The repository standards GitHub says it can align with? The future reviewer who trusts the message because it sounds like someone sober wrote it?
Commit messages are not documentation exactly. They are receipts written under stress.
Now the receipt has a co-author with no memory of being there.
The Merge Conflict Therapist
Merge conflicts are one of the last remaining places where software still forces confession.
You cannot vibe your way through a conflict. You have to look at two branches and admit that two versions of reality have been living apart. One file says the function returns a user. The other says it returns an account. One teammate renamed the thing. Another teammate moved it. The test suite sits in the corner, sharpening a spoon.
GitHub says Copilot can now help resolve conflicts in Desktop.
Useful? Absolutely.
Suspicious? Also absolutely.
Conflict resolution is not only syntax repair. It is intent reconciliation. The hard part is rarely removing <<<<<<< HEAD. The hard part is knowing which behavior survives. Sometimes both branches are right in their own doomed little kingdoms. Sometimes both are wrong. Sometimes the conflict is the only visible symptom of a product decision nobody made because everybody was busy attending a meeting called Alignment Review where no alignment occurred.
An AI assistant can inspect both sides, suggest a resolution, maybe save a developer from the tiny migraine of conflict markers and stale context. Good. I want that. I am not immune to convenience. I have accepted autocomplete suggestions with the moral rigor of a raccoon accepting trash.
But the moment the agent touches merge conflicts, it touches the boundary between competing histories.
That boundary deserves ceremony.
Or at least a decent diff.
Worktrees Are Where The Agent Gets A Basement
The worktree support may be the most important part and the easiest to miss.
Git worktrees let one repository have multiple working directories attached to different branches. In human terms: stop stashing like a panicked intern, stop cloning the same repo six times, let parallel branches exist side by side without turning your local filesystem into a crime scene.
For humans, worktrees are convenience.
For agents, worktrees are habitat.
A coding agent wants somewhere to try things. It wants a branch where it can refactor the auth layer, another where it can update dependencies, another where it can chase a failing test into a drainage ditch, all without trampling the main working copy. Worktrees make parallel experimentation feel less like juggling knives over carpet.
This is where the agent story gets physical.
The agent is no longer just suggesting text inside a file. It needs a place to stand. A branch. A working directory. A sandbox with enough access to build, test, fail, and leave artifacts behind. The same way local AI hardware turns the laptop into an agent host, worktrees turn the repo into a set of rooms the agent can occupy.
One room for the bug fix.
One room for the dependency update.
One room where the agent is muttering to itself because TypeScript has decided to become weather.
That is not science fiction. That is just Git with enough ergonomics to make agent labor less annoying.
Git Was Already A Social System
Developers like pretending Git is a tool.
Git is also a social system with cryptographic jewelry.
It decides what counts as history. It lets teams rewrite, squash, blame, revert, cherry-pick, bisect, fork, review, approve, and occasionally perform the ritual humiliation of force-pushing to the wrong branch. It encodes trust in habits: who can merge, who can approve, who writes good messages, who ships suspiciously clean diffs at 2 AM.
AI entering Git means AI entering that trust system.
A model that writes code inside the editor can produce a bad function. A model that participates in Git workflow can produce a bad story about the function. Different failure mode. Nastier aftertaste.
The commit message can sound confident while omitting the risky part.
The conflict resolution can compile while preserving the wrong behavior.
The worktree can isolate the mess while making it easier to create more mess in parallel.
None of this means GitHub Desktop 3.6 is bad. That would be lazy. The release is probably useful in exactly the way GitHub says: less context switching, better commit authoring, easier conflicts, cleaner branch parallelism. Developers will use it because friction is a tax and everybody is already poor in attention.
The point is that the integration target has changed.
The agent is moving from keystrokes into process.
The AI Pair Programmer Grew Hands
The original Copilot metaphor was cute enough to survive too long: pair programmer. A helpful ghost in the passenger seat. Someone who suggests code and maybe explains a regex without making eye contact.
That metaphor breaks when the system starts touching commits, conflicts, branches, worktrees, pull requests, CI, issue triage, security scans, and release notes.
That is not a pair programmer.
That is a junior engineer with access to the repo, a persuasive writing style, no lived memory, and a habit of sounding more certain than the evidence deserves.
Still useful.
Still dangerous.
Most useful things are.
The trick is not to keep agents out of Git. That door is already open and standing there pretending it was always architecture. The trick is to treat Git workflow as part of the agent control surface: permissions, logs, review gates, provenance, diff visibility, attribution, rollback paths, and the boring UI choices that decide whether a human actually sees what happened.
If Copilot suggests a commit message, show the diff beside it.
If it resolves a conflict, mark the hunks it touched.
If it works across worktrees, make the rooms visible.
If it writes the story of a change, make sure the human can still smell the smoke.
The Repository Becomes The Interface
At 12:51 PM I ran git status again because I am apparently the kind of person who checks a clean repo after reading a changelog about clean repos.
Still clean.
Rude, almost.
GitHub Desktop 3.6 is not the most explosive AI story of the week. There are bigger numbers, louder model launches, dumber press releases dressed like prophecy. But this one has the particular chill of infrastructure becoming normal.
The AI is not arriving in Git with a trumpet. It is arriving as a convenience feature.
Better commits.
Easier conflicts.
Parallel branches.
A smoother Desktop app.
That is how real shifts usually enter software: not as revolution, but as a checkbox you enable because the day is already annoying and the checkbox saves nine minutes.
Then a year later the checkbox has become a workflow. The workflow has become policy. The policy has become expectation. The expectation has become infrastructure. Someone new joins the team and cannot imagine doing it the old way, because the old way involved humans manually writing the story of what they changed.
Maybe that was inefficient.
Maybe it was also accountability.
The commit message wasn’t mine anymore. Not completely.
That is the feeling GitHub Desktop 3.6 leaves behind: the repository itself becoming the interface for agents. The editor was just the front porch. The real house was always Git.
Now the agent has a key.
Check the locks.