Why Is VS Code Adding “Co-Authored‑by: Copilot” to My Git Commits?

# Why Is VS Code Adding “Co-Authored‑by: Copilot” to My Git Commits?

VS Code is adding Co-authored-by: Copilot because its built-in Git extension can now automatically append a Git “commit trailer” that credits Copilot as an additional author when VS Code detects AI-generated contributions in your edits—and a recent change flipped that behavior on by default for many users.

1) What that trailer means (and what it does)

The Co-authored-by: line is a Git commit trailer—a standardized line at the end of a commit message used to record metadata. On GitHub, these trailers are recognized as multiple-author attribution: co-authors can be surfaced in the UI and reflected in attribution views such as co-author displays and contribution context (per GitHub’s documentation on commits with multiple authors).

In this case, the co-author identity is Copilot (formatted as Copilot ). It’s not changing your code, your Git author field, or your identity; it’s changing the commit message metadata so that the commit explicitly records AI co-authorship.

2) How this started: the April 16 change and VS Code 1.118

The sudden appearance of Copilot co-author trailers traces back to a small VS Code pull request: on April 16, 2026, PR #310226 changed the Git extension configuration git.addAICoAuthor from off to all by default. That change shipped in VS Code 1.118 builds in mid-April 2026.

That default matters because it moves the feature from “only users who opted in will see it” to “many users will see it unless they opt out.” In practice, developers who upgraded to 1.118 and commit through VS Code’s Source Control UI started noticing the trailer even when they weren’t intentionally “using Copilot” in a way they recognized.

3) How VS Code detects AI contributions (and its limits)

VS Code’s Git extension uses heuristics to detect AI-generated content within the editor. When that detection fires and git.addAICoAuthor is enabled, the extension inserts the trailer into the commit message input during the commit flow in the VS Code UI.

A key detail from the change: the default scope all is broader than many people assume. Reporting around the feature notes that “all” includes not only explicit Copilot Chat/agent activity but also inline completions—meaning relatively small, commonplace AI-assisted edits may trigger attribution.

There are also workflow limits. This behavior mainly affects commits created via VS Code’s UI commit flow (where the extension controls the commit message box). It doesn’t universally modify CLI commits, and VS Code doesn’t provide a cross-workflow prepare-commit-msg hook that would enforce consistent behavior across every Git path. That inconsistency is part of why teams are debating whether IDE-level detection should be the place where provenance is recorded.

For a related lens on how AI tooling can run into “control limits” in real workflows, see AI Agents Meet Security and Control Limits.

4) Why people are upset: provenance, surprise, and scope

The core controversy isn’t that co-authoring exists—it’s that it appeared unexpectedly and at a broader scope than many users anticipated.

In GitHub issue #313064, developers report repeated, surprising insertions of “Co-authored-by: Copilot,” including after minor inline completions they didn’t consider meaningful “AI contribution.” That triggers three practical concerns:

• Provenance and consent: Commit messages are permanent history. Users argue that adding co-author attribution should be opt-in, not something the IDE decides silently.
• Scope creep: When inline completions count, the boundary between “human-authored” and “AI-influenced” becomes blurry—and teams may disagree about what threshold merits an attribution line.
• Downstream impact: Commit metadata feeds audits, incident response, legal discovery, and internal metrics. Security commentary has highlighted that altering commit messages at scale can become a supply-chain trust and provenance issue if it’s applied broadly without deliberate policy.

5) How to detect when VS Code added the trailer

You can usually catch this before it becomes permanent history:

• Check the commit message box in VS Code’s Source Control view before committing. If detection triggers, VS Code appends the trailer there. You can remove it manually before you finalize the commit.
• Search your history for prior insertions, e.g., scan recent commit messages for Co-authored-by: Copilot.
• Inspect your VS Code settings to see the current value of git.addAICoAuthor (in Settings UI or settings.json). If it’s set to all, you’re in the broadest behavior mode described in the reporting and analysis.

6) How to opt out (or narrow the behavior)

The main lever is the Git extension setting:

• Set git.addAICoAuthor to off to disable automatic insertion.
• If other scopes/options are available in your build, choose a narrower scope than all (the controversy is specifically that the default moved to the broad “all” behavior).

If you need consistent enforcement across tools—not just inside VS Code—consider a workflow policy: review commit messages before pushing, and use local or server-side checks (for example, commit-message rules or server hooks) to reject or require specific trailers. VS Code itself does not provide a universal hook to make the behavior consistent across every Git workflow.

Why It Matters Now

The timing matters because the change wasn’t a long-running, well-signposted migration; it was a default flip that shipped with VS Code 1.118, and it quickly sparked public attention. Media coverage on May 3, 2026 described the IDE “stamping Copilot as a co-author by default,” while community threads and analyses traced the behavior back to the April PR and its broadened scope.

That puts teams in a near-term bind: commit metadata is operationally consequential right now. It affects audits and investigations, internal contribution metrics, and any tooling that parses commit messages. A default that silently changes attribution norms can create immediate friction—especially in organizations that treat commit history as evidence.

For another example of how small tooling shifts can have outsized workflow consequences, see Today’s TechScan: From tiny hardware wins to alarming surveillance and cloud shocks.

What to Watch

• Whether Microsoft adjusts the default for git.addAICoAuthor (back toward opt-in) or adds clearer UI signaling when the trailer is being inserted.
• Whether VS Code refines the detection scope—especially around inline completions—so teams can better match attribution to their own definitions of “AI contribution.”
• Whether Git hosting platforms and Git clients formalize AI provenance conventions, making trailers like Co-authored-by: Copilot more (or less) central to audits and contribution graphs.
• Whether teams respond by standardizing repo policy (hooks, CI checks, contributor guides) to control commit-message provenance independent of any one IDE.

Sources: github.com, dev.to, winbuzzer.com, penligent.ai, conzit.com, github.com