Co-Authored-By Trailers Explained: What AI Coding Agents Leave in Your Git History

2026-11-13 · 7 min read · GitHub & Metrics

Open the history of almost any repo where people use coding agents and you'll find lines like this at the bottom of commit messages:

Co-Authored-By: Claude <noreply@anthropic.com>

That line is a Git trailer. It's a small, old convention that has quietly become the most dependable record of AI-assisted work in your codebase. If you want to understand how your team uses agents — or measure it — it's worth knowing exactly what a trailer is and what it isn't.

What a Trailer Is

A trailer is a Key: value line in the last paragraph of a commit message, separated from the body by a blank line. Git has used them for years for things like Signed-off-by: and Reviewed-by:.

Add idempotency keys to payment retries

Retries could double-charge when the provider timed out after
accepting the request. Store a key per attempt and reuse it.

Co-Authored-By: Priya Sharma <priya@example.com>
Co-Authored-By: Claude <noreply@anthropic.com>

A few rules make trailers machine-readable:

How GitHub Uses It

GitHub reads Co-Authored-By trailers and shows every co-author on the commit, with their avatar if the email matches a GitHub account.

That's why the convention spread to AI tools. It's the standard, already-supported way to say "someone else helped write this", and it works in every Git host and every client without any special integration.

Which Agents Add One

Tools differ, and defaults change between versions, so check what your team's tools actually do. As a general picture:

The safest assumption: if an agent commits on someone's behalf, it probably leaves something — but not always the same thing, and engineers can turn it off.

How to Search for Trailers

Git can read trailers directly, so you don't need to grep raw messages.

List every co-author in a time window, with counts:

git log --since="6 weeks ago" \
  --format='%(trailers:key=Co-authored-by,valueonly)' \
  | grep -v '^
#39; | sort | uniq -c | sort -rn

Count commits with any agent co-author:

git log --since="6 weeks ago" -i -E \
  --grep="co-authored-by:.*(anthropic|claude|cursor|copilot|devin|codex|gemini|aider)" \
  --oneline | wc -l

See them per author:

git log --since="6 weeks ago" -i -E \
  --grep="co-authored-by:.*(anthropic|claude|cursor|copilot|devin|codex)" \
  --format='%an' | sort | uniq -c | sort -rn

Two cautions when you build patterns like these:

What a Trailer Proves — and What It Doesn't

A trailer is good evidence that an agent was involved in a commit. It is not a precise measurement.

It applies to the whole commit. A trailer can't tell you whether the agent wrote one line or all of them. That's why counting commits and PRs is fairer than weighting by lines changed — lines-weighting mostly measures who makes big commits.

Absence isn't proof of anything. No trailer can mean no agent. It can equally mean autocomplete, a pasted chat answer, a squash merge that dropped trailers, or an engineer who turned the setting off.

Squash merges can lose them. When a PR is squash-merged, GitHub builds the new commit message from the PR's commits. Depending on settings, co-author trailers may be carried over or dropped. That's one reason to look at PRs as well as commits.

People can add or remove them. A trailer is just text. That's fine for understanding how a team works. It's a good reason never to tie trailers to targets or performance — the moment you do, the text stops meaning anything.

Why Trailers Are Still the Best Signal You Have

Every alternative is worse in some important way:

Trailers come from the work itself, in the repo, visible to everyone. They're cross-tool, they're already there, and reading them is something any engineer on the team could do too. That's exactly the kind of signal an Engineering Manager can use without anyone feeling watched — as long as it's used to understand the team rather than to rank it. (See how to tell which agents your team uses for that side of it.)

From Trailers to a Team View

One repo and one git log is a snapshot. To turn trailers into something you can act on, you need to:

  1. Read commits and PRs across every repo your engineers work in.
  2. Recognise each tool's signatures — trailers, footers and bot authors — while skipping humans and plain automation.
  3. Track it weekly, per person and for the team.

That's what measuring AI adoption means in practice.

How Emtricks Uses Trailers

Emtricks reads your linked engineers' commits and PRs across all their repos and applies exactly these rules: vendor addresses rather than bare names, bot authors for autonomous agents, automation bots excluded, and any other [bot] co-author flagged as "Other agent" so new tools aren't missed. If your company runs its own agent, you add its name or address in Integrations and it's counted too.

The result shows up as an AI adoption score for the team in Pulse and for each engineer on their 1:1 page.

Key Takeaways


Turn your team's trailers into a weekly AI adoption view — across every repo, with nothing to install. Try Emtricks free for 30 days.