How to Tell If Your Engineers Use Claude Code, Cursor or Copilot (Without Surveillance)

2026-11-12 · 8 min read · GitHub & Metrics

Your VP asks which AI tools the team is using. Finance asks whether the Copilot seats are worth renewing. Someone in a leadership offsite says "we should be AI-first by Q2".

You realise you don't actually know. You know who asked for a licence. You don't know who uses what, how often, or for which kind of work.

The tempting answers are the wrong ones: install a monitoring tool, ask the IT team for usage logs, or send a survey and hope people are honest. There's a better first step, and it uses something your team already produces every day: their Git history.

This guide covers what Git can tell you about AI coding agents, what it can't, and how to look at it in a way your engineers would be comfortable with if they saw exactly what you were doing — because they should be able to.

Start With the Right Question

"Is my team using AI?" is too vague to answer. The useful versions are narrower:

Notice what's missing: "who is using AI the most". That question turns a team insight into a ranking, and we'll come back to why that backfires.

Three Kinds of AI Use — Only One Is Visible

Engineers use AI in roughly three ways, and they leave very different footprints.

1. Inline autocomplete (Copilot, Cursor Tab and similar). The editor suggests the next lines; the engineer accepts them. Once accepted, the code is indistinguishable from typed code. No trace in Git.

2. Chat and paste. Asking a model in a browser tab or an IDE panel and pasting the answer. No trace in Git.

3. Agents. Tools that edit files, run commands and commit or open pull requests on the engineer's behalf — Claude Code, Cursor's agent, the GitHub Copilot coding agent, Devin, Codex, Jules, Aider and others. These usually sign their work.

So anything you learn from Git is about agent-assisted work, and it's a floor, not a total. It under-counts autocomplete and chat for everyone, by a different amount per person. Keep that sentence next to every number you show.

What Agents Leave in Git

There are three common signatures. Exact defaults vary by tool and version, so treat this as what to look for, not a guarantee.

A Co-Authored-By trailer on the commit. Git's standard way of crediting a second author is a trailer at the end of the commit message. Claude Code adds one by default:

Fix race in webhook retry queue

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

Other agents use the same convention with their own name or address. We go through the format in detail in Co-Authored-By trailers explained.

A footer on the pull request. Some agents sign the PR description instead of, or as well as, the commits. Claude Code's PRs end with a "Generated with Claude Code" line.

A bot as the author. Fully autonomous agents often open the PR under their own bot account rather than the engineer's — the GitHub Copilot coding agent, for example, opens PRs as Copilot, and Devin works through its own GitHub integration. The author login alone tells you an agent did the work.

None of this is hidden. Your engineers' tools put it there on purpose, in commits they have already pushed to repos you can already read.

A Five-Minute Look With git log

For a single repo, you can get a rough picture without any tooling:

# Which agent co-authors appear, and how often, in the last 6 weeks
git log --since="6 weeks ago" --format='%(trailers:key=Co-authored-by,valueonly)' \
  | grep -v '^
#39; | sort | uniq -c | sort -rn

That lists every co-author trailer and how many commits carry it. Human pair-programming partners will show up too — that's fine, and it's a reminder that a trailer is just a credit line, not proof of anything by itself.

To see which PRs were opened by a bot account, open one PR from each agent your team uses and note the author shown on it. Then filter your repo's pull requests by that author in GitHub's search. Account names differ by tool and change occasionally, so check rather than guess.

This is enough to answer "which tools, roughly how much" for one repo. It gets hard quickly after that:

That's where a tool earns its keep — see how to measure AI adoption across a team for the full approach.

What Not to Do

Don't install monitoring software to find out. Screen recorders, keystroke loggers and "productivity" trackers will tell you something, and cost you far more in trust than the answer is worth. Engineers notice, talk, and leave.

Don't ask IT for individual usage logs as a first move. Vendor admin consoles can show seat activity. Using them to check up on individuals — rather than to manage licences — feels like surveillance even when it's technically allowed.

Don't send a survey and treat it as data. Surveys are useful for how people feel about AI tools. They're poor at measuring usage: answers drift with enthusiasm and with what people think you want to hear.

Don't rank people. The moment "AI usage" becomes a leaderboard, people add trailers to look good, or hide them to avoid scrutiny. Either way the signal is gone.

The Test: Could You Show Your Team Exactly What You Looked At?

Here's a simple rule for keeping this on the right side of the line: only look at things you'd be comfortable showing the whole team, in the same form you saw them.

Git trailers and PR authors pass that test easily. They're in the repo. Anyone on the team can run the same git log. You can say, out loud, in a team meeting: "I looked at how many of our commits an agent co-signed over the last six weeks. It's about a third, and most of it is in the infra repos. Who wants to show how they're using it?"

If you'd be uncomfortable saying the equivalent sentence about a method, don't use the method.

A few practical habits help:

What to Do With What You Learn

The point of knowing isn't the number. It's what you do next.

How Emtricks Helps

Emtricks does the multi-repo, week-by-week version of this for you. It reads your linked engineers' commits and PRs across every repo they work in, recognises the signatures of Claude Code, Cursor, Copilot, Devin, Codex, Jules, Aider and a dozen more — plus any in-house agent you add — and shows the share of AI-assisted work for the team and each engineer. Team totals live in Pulse; each person's view sits on their 1:1 page, where the conversation belongs.

It only reads what's already in your Git history. Nothing is installed on anyone's machine.

Key Takeaways


See which coding agents your team uses, across every repo, without installing anything. Try Emtricks free for 30 days.