A lot of AI product backlash is noisy but fuzzy. This one was plain.

Microsoft changed a VS Code Git setting so commits could be tagged Co-Authored-By: Copilot by default. Developers noticed, got angry, and made the point quickly: if a tool did not help write a commit, it should not quietly add its own name to the history.

The interesting part is not that people dislike AI branding. Developers tolerate plenty of branding when it stays in the right place. The problem here was trust. Commit metadata sits close to authorship, audit trails, internal policy, and in some cases legal review. Changing that default without clear user intent landed as a boundary violation, not a mere product tweak.

And the backlash was strong enough that the change was reverted fast.

What actually changed

The primary artifact is a merged VS Code pull request, #310226, titled "Enabling ai co author by default."

Two implementation details matter.

First, the Git extension's configuration schema changed the git.addAICoAuthor default from off to all.

Second, the code fallback in extensions/git/src/repository.ts also changed from off to all.

That matters because it shows this was not a wording bug or a documentation mismatch. The default behavior was changed in code.

The reaction later produced a second pull request, #313931, titled "Change default for git.addAICoAuthor to off." GitHub shows that revert PR was merged on May 3. The current main branch now shows the setting back at off both in the configuration schema and in the repository fallback code.

So the short version is straightforward:

1. Microsoft merged a default change that enabled Copilot co-author attribution. 2. Developers objected loudly. 3. Microsoft merged a revert and restored the default to off.

Why people reacted so hard

On paper this can look minor. It is only a Git trailer. It does not change the code itself.

That reading misses the point.

A commit message is not decorative. It becomes part of the repo's history, review trail, blame context, compliance workflow, and sometimes external record. If a vendor starts writing itself into that history by default, even when users say they did not use the tool for that commit, the fight stops being about convenience.

It becomes a fight about whether the tool is claiming authorship too early.

That is why many of the public reactions were not about syntax or editor preference. They were about ownership, consent, and product overreach.

A popular Hacker News thread linked to the original PR under the blunt title "VS Code inserting 'Co-Authored-by Copilot' into commits regardless of usage". At the time of writing, it had passed 1,100 points and hundreds of comments. The representative comments were not subtle: comparisons to "Sent from my iPhone," complaints about growth hacking, and arguments that commit authorship is the wrong place for automatic product promotion.

GitHub comments on the original PR showed the same tone. One commenter wrote, "Why in the world would you default this! 😡" That comment alone accumulated well over a hundred positive reactions. Another said they had "chat.disableAIFeatures": true and still saw Copilot attribution inserted into commits, which made the change feel worse because it looked broader than a simple "AI features on means attribution on" story.

Reddit picked it up quickly as well. In /r/programming, one early comment compared the move to trying to recreate the old "Sent from my iPhone" signature trick. In /r/devops, a commenter cut closer to the real issue: a tool should never assume co-authorship if it played no part in creating the code.

That is the whole dispute in one sentence.

The headline is not the real story

The easy headline is that developers got mad at Copilot branding.

The better story is that AI tooling keeps drifting toward authorship claims, workflow claims, and ambient credit capture.

Vendors want proof that their tools are being used. They want visible attribution, cleaner metrics, stronger lock-in, and maybe some cultural normalization around AI-assisted output. None of that is surprising.

What is surprising is how often product teams still misread where developers will tolerate that push.

People will accept AI features in code completion, chat panes, inline edits, and even agent loops if those features are explicit. They get much less forgiving when a tool starts modifying durable project records by default. Git history is one of those records. It is not a marketing surface.

That distinction matters beyond VS Code.

As AI coding products spread through editors, CLIs, pull requests, and CI systems, more of the workflow becomes a contest over who gets to annotate the work. A trailer in a commit message may look small, but it points at a larger question: when does "helpful attribution" turn into a vendor writing itself into the record without enough user intent?

What is verified, and what is not

The verified part is strong.

  • PR #310226 changed the default from off to all.
  • The same PR changed the code fallback to all.
  • PR #313931 was merged and changed both defaults back to off.
  • The current main branch reflects off again.
  • Public reaction was large across GitHub, Hacker News, and Reddit.

A few narrower claims need more caution.

It is clear from user reports that some people believed the attribution appeared even when they were not using Copilot for a given commit. The PR title and code diff support why people would interpret the change that way. Still, any claim about exactly which UI paths or commit flows inserted the trailer for every user needs to be treated as user-reported unless reproduced step by step.

There is also a difference between "Copilot was used somewhere in the workspace" and "Copilot materially helped author this specific commit." The setting debate exists because that line is blurry, and developers do not want the tool deciding it on their behalf.

Why the revert matters

The revert does not just show that the original change was unpopular. It shows that the boundary still exists.

For all the talk about AI-native development, developers still expect authorship metadata to be conservative. If a company wants attribution, it has to earn that choice from the user. It cannot just sneak it into the default path and hope people get used to it.

That is a useful signal for every AI coding vendor.

The market argument for AI tools has been built on speed and output. The trust argument will be built somewhere else: respecting the user's repo, commit history, local settings, and declared intent. Once a tool starts taking liberties with those, the backlash comes fast.

VS Code found that out with a two-word setting change.

Sources