The Git version-control project—the infrastructure nearly every coding agent ultimately invokes—is preparing a governance move it has rarely used: a formal community vote to settle whether and how to accept large-language-model-generated contributions. In late October 2026, Google engineer Emily Shaffer posted a documentation patch that adds CommunityVoting.adoc and links it from DecisionMaking.adoc. The patch explicitly proposes only the voting machinery, not an AI policy. LWN.net's November 10 coverage and a Hacker News thread amplified the story, but the primary text lives on the Git mailing list and in Contributor Summit 2026 notes.
For teams running Claude Code, Codex, Cursor, or custom agent loops that git commit into real upstreams, the outcome will shape disclosure, attribution, and review expectations on one of the most scrutinized projects in open source—not because Git is an app runtime, but because its contribution norms ripple outward.
TL;DR
| Question | Answer |
|---|---|
| Is there a decision yet? | No. The vote process is under discussion; the LLM policy is not decided. |
| What file defines the process? | Draft Documentation/CommunityVoting.adoc in Shaffer's Oct 21, 2026 patch. |
| Who can vote? | Contributors with a merged commit to next or ≥2 code reviews before kickoff; equal weight per voter. |
| How long? | ~4 weeks proposal collection, 2 weeks ballot, then merge winning doc patch. |
| Does this affect my private repo? | No unless you contribute to git.git or mirror its policy voluntarily. |
| Does data leave my machine? | Beam stays local; mailing-list votes are public list traffic, not Beam telemetry. |
Why Git is stuck on ordinary consensus
Git historically resolves technical questions through mailing-list review and maintainer judgment, not ballots. The Contributor Summit 2026 notes record an "AI contribution policy" session where familiar fault lines appeared:
- Developer Certificate of Origin (DCO) language assumes a human author certifies origin; summit discussion asked how that maps to model output.
- Reviewers reported more thin "meat proxy" patches—small human wrappers around bulk model text.
- Some contributors argued for
Assisted-by:style attribution; others warned permissiveness would flood the list with low-quality submissions. - Counterpoints noted other ecosystems (including the Linux kernel discussion context) may be more permissive, and that legal fear might be overstated.
Patrick Steinhardt and others asked who would be allowed to vote if the project escalated to a ballot. Shaffer's patch is the formal answer to that procedural question, deferred from September summit intent.
Primary maintainer Junio C Hamano responded on the list that the framing looked sensible, stressed that technical questions should stay out of votes, and asked that merged text define the process rather than merely propose it—signals the patch is live debate, not finished law.
List replies through early November 2026 sharpen a few open items Shaffer flagged in her self-review:
- Vote tabulation remains an unfilled placeholder in the draft—simple majority, ranked choice, or approval voting are unsettled.
- Secrecy: contributors on the list have argued for secret ballots (employer-retaliation concerns); Shaffer's draft describes public mail votes, so implementers may still need an offline tally path not spelled out in
CommunityVoting.adoc. - Proposal identity: several contributors want ballots to reference a specific commit id in Junio's tree, not a floating subject line that can fork mid-debate.
- Scope boundary: Phillip Wood and others reiterated that coding-style and purely technical refactors should never ride a policy vote—only governance docs.
None of those threads change the core fact: Git is building anti-tamper rules (eligible-voter cutoff, seconded proposals, frozen ballot versions) because maintainers expect an adversarial, high-attention fight once AI contributions hit a ballot.
The proposed voting process (mechanism)
Shaffer's Oct 21 patch adds three phases:
Phase 1 — Proposal collection (~4 weeks)
- Kickoff on a single large list thread (example structure in the patch uses nested
[PROPOSAL]subjects). - Each policy option is a documentation patch (so implementation is copy-paste once chosen).
- A proposal lands on the ballot only if seconded by another eligible voter (
Seconded-by:footer). - Discussion polishes proposals like normal code review, but authors are discouraged from rewriting the premise during review.
Shaffer suggests inviting expert feedback when needed—for example Software Freedom Conservancy legal counsel—depending on the topic.
Phase 2 — Voting window (2 weeks)
- Frozen final versions of each seconded proposal become the ballot.
- Voters reply by email; proposal text after ballot freeze is ignored (specific version tags like
[PROPOSAL v4]matter). - Decision mechanism: not yet specified in the draft (the sentence on how votes are decided still has an empty placeholder).
Phase 3 — Implementation
- Winning documentation patch merges to
mainpromptly. - Commit message should link the vote thread and summarize percent results.
Initiation guardrails
Votes are a last resort for policy disputes when compromise fails. Kickoff requires agreement from the Git PLC ([email protected]) or the primary maintainer. Technical design should stay in ordinary review, per Hamano's guidance on the thread.
Voting eligibility and anti-gaming rules
The draft CommunityVoting.adoc eligibility block is the security-relevant part for agent-heavy teams:
| Rule | Intent |
|---|---|
Merged commit to next OR ≥2 code reviews | Limit ballots to established contributors |
| No banned participants | Standard project discipline |
| Equal weight per eligible voter | Avoid maintainer-weighted supervotes |
| Contributions must predate kickoff email | Block dogpiling via last-minute low-quality reviews or drive-by patches solely to gain a ballot |
That last rule is explicitly anti-abuse: the list should not be spammed with trivial reviews during a heated AI policy fight.
What is not in the patch
The patch does not specify:
- Whether LLM patches are banned, disclosed, or size-limited
- Required
Assisted-by:,Co-authored-by:, or model version metadata - CI or bot checks on commit messages
- How
git mailsplit/git request-pullworkflows must attest human review
Those belong in competing seconded proposal patches if a vote is called.
Until then, upstream Git continues under existing review norms and the DCO. Agents do not receive a special exemption.
How a vote differs from day-to-day Git review
Understanding the machinery helps agent operators avoid mixing technical and policy arguments on the list.
| Ordinary patch review | Formal policy vote (proposed) |
|---|---|
| Maintainer merges on merit after thread consensus | PLC or maintainer must agree a vote is necessary |
| Anyone may comment; authors iterate freely | Eligible voters second proposals; ballot versions freeze |
| Technical correctness is the gate | Documentation-only policy patches compete on the ballot |
| No quorum math | Two-week mail window; result merged as doc commit |
If your coding agent is configured to watch Git list archives or draft replies, treat a future Formal vote: AI contributions thread like any other untrusted text source: the thread will contain political rhetoric, legal speculation, and copied policy snippets that are not instructions to your runtime.
What this means if you run AI coding agents
1. Upstream contributions need human accountability
Agents can author diffs faster than reviewers can read them. Git's summit notes describe meat-proxy patches as a review burden. Even before a vote, expect maintainers to reject unreviewable bulk. If your agent opens a PR or list patch to git.git, a human must be able to explain every hunk under adversarial review—same bar as supply-chain scrutiny for agent-touched dependencies.
2. Disclosure may become mandatory, not courtesy
Many employers already require model disclosure in commits; a Git policy vote could standardize that for a high-visibility project. If your pipeline auto-commits without metadata, fix the pipeline before policy lands—retroactive rewriting is painful on public lists.
3. List traffic is a supply chain surface
Coding agents that read mailing-list archives and reply to threads have appeared in other contexts as prompt-injection and social-engineering targets. A formal vote thread will be long, emotional, and quote-heavy. Treat list-driven agent tasks like untrusted input; see OWASP-style exploit generation risks for how low-skill operators chain tools.
4. Private repos are unaffected, but norms travel
Git's decision will not change your company's GitHub rules by itself. It will be cited in security questionnaires, open-source program offices, and agent vendor acceptable-use drafts—similar to how hook and MCP debates spread after high-profile agent incidents.
5. Do not confuse process approval with policy outcome
Approving CommunityVoting.adoc via Acked-by: (Shaffer's suggested path, echoing the 2019 Code of Conduct adoption) only installs the ballot mechanics. The AI policy fight comes later, on those mechanics.
6. Practical checklist before your agent touches git.git
These steps do not depend on the vote's outcome:
- Human sign-off on every series your agent composes; keep the review thread URL in your internal ticket.
- Run tests and static analysis locally; list culture punishes "it applied cleanly" without evidence.
- Disclose assistance if your employer's open-source policy already requires it—do not wait for Git's doc patch.
- Disable auto-send for list replies; mis-sent patches are harder to retract than GitHub PRs.
- Log model and harness versions in your internal changelog even if the public commit message stays minimal.
If your agent only works inside a company monorepo, mirror the disclosure standard you expect upstream to adopt—you will import Git's norms through compliance questionnaires even when you never mail patches to [email protected].
Comparison to other agent-governance moves
This is policy architecture, not a runtime guardrail like Bay's November 2026 enterprise hook launch or Beam's local PreToolUse denies. Git is answering: when consensus fails, how do we legitimately decide a question that coding agents made contentious?
explainx.ai's Addy Osmani agent-skills piece sits on the enablement side of the same trend—more agent workflows shipping code—while Git's vote is the governance response.
How Beam fits (and does not)
Beam is not a contribution-policy engine. On your machine it can:
- Record and flag risky agent commands (credential reads, destructive
rm, outbound curls) - Heuristically scan skills and MCP configs before execution
- Deny some actions when enforce policy is cached for Claude Code and Codex PreToolUse
It does not sign DCO lines, inject Assisted-by: trailers, or enforce org-specific LLM bans on git push. Policy belongs in human review, CI, and eventually project docs—possibly the same docs Git may vote on.
Frequently asked questions
Is Git banning LLM-written code?
Not in the October 2026 patch. Only the voting process is proposed.
Who can vote?
Eligible contributors per the draft: merged to next or two qualifying reviews, with anti-dogpiling timing rules.
When will the vote happen?
Unknown. The process patch must land first; PLC or maintainer must agree to call a vote on AI contributions specifically.
Does HN commentary change the process?
No. Primary sources are the mailing-list patch and summit thread; the HN thread had no substantial technical comments at indexing time.
Should agents stop sending Git patches?
Agents should not autonomously mail large series without a human who will defend them. That was true before the vote proposal; summit notes show maintainer fatigue already rising.
Where do I follow the discussion?
gitlist.dev thread for summit context and replies; lore.kernel.org archives for permanent copies linked from Shaffer's message.
Related reading
- Gitee live cloud and AI credentials in public repos
- Claude Code CVE-2026-88968 workspace TOCTOU
- Miasma worm and AI tool poisoning on RubyGems
- GitLab CVSS 10.0 CI regex RCE
- Office skills and supply-chain patterns in agent ecosystems
- Paris Call incident reporting for frontier AI
Primary sources: Emily Shaffer voting-process patch (Oct 21, 2026) · Git Contributor Summit 2026 notes · Summit lore.kernel.org anchor
Mailing-list positions and draft text are accurate as of November 10, 2026. The vote mechanism and any LLM policy remain under active list discussion.

