Human or Agent: Reading Authorship in a Developer's Commits

When you read a developer's public GitHub to judge real skill, half the history may now be written by an AI coding agent. This reference tells an engineering manager, technical founder, or technical sourcer which commits and pull requests are the developer's own work, which are AI-assisted, and which an agent produced end to end. Jump to any row: it names the signal, says what it proves, and says how it lies.

The order matters. The fingerprinting research treats behavioral features as primary evidence. Practitioners do the opposite: trust verifiable identities and trailers first, and use fingerprints only as a fallback for the commits that carry no marker. This guide follows the practitioner order, because you are judging a stranger from the outside with no cooperation and no instrumentation.

The three labels and what each requires to prove

There are three authorship classes, and each demands a different quality of evidence. Human-authored means the developer wrote the code. AI-assisted means a model helped inside the developer's editor, but the human drove and committed. Agent-authored means a background agent produced the commit or the whole PR on its own.

The evidence quality falls off a cliff between them. Agent-authored is the easiest to prove because agents leave fixed identities. AI-assisted is the hardest, because in-editor assistance rarely leaves a durable trace unless the developer opted in. Human-authored is, in practice, a residual: what you assign after you have ruled out the other two and found no agent signal you trust.

Why this is now the default problem rather than an edge case: adoption is wide. In Refolk's index of professional profiles, 8,489 US profiles cite GitHub Copilot as a skill and 3,621 cite Claude Code. A 2026 study flagged 6,618 pull requests labeled "human" in a research dataset as possibly agent-contaminated. Most histories you read will contain agent code whether or not it is marked.

The committer identity map: who each agent claims to be

The single most reliable signal is the committer identity, because agents that run as background services commit under fixed, non-human accounts you can filter on. This is the row to read first.

The table below is the lookup. Each agent brands its output differently, and the difference is the whole game.

Three consequences you must internalise. First, the Copilot coding agent is the cleanest case: its commits are authored by Copilot with email <id>+copilot@users.noreply.github.com, committed by copilot-swe-agent[bot], and since March 2026 carry an Agent-Logs-Url trailer that links back to session logs. You can identify these deterministically.

Second, Claude Code hides the agent's share by design. The human stays the author, and Claude appears only as a co-author. Because noreply@anthropic.com is not a real account, GitHub mints a ghost contributor and Claude's avatar shows in the contributors graph. Recent versions embed the model, for example Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>. That tells you the tool, not the proportion.

Third, Cursor and Codex CLI leave nothing in the commit. Cursor cloud agents brand the branch instead (cursor/...), and Devin puts attribution in PR descriptions and branch names because it opens whole PRs autonomously. If you only read commit metadata, you will miss both.

The trailer taxonomy: what each string means and where it breaks

A trailer is a Key: Value line in a single group at the end of a commit message that Git and GitHub parse for attribution. Trailers are the most visible signal and, for exactly that reason, the weakest as proof. They are plain strings: defaulted on for Claude Code, off by default for Cursor and Codex, and configurable per project.

Notice what no trailer tells you: how much of the code the model wrote. There is active debate about replacing Co-authored-by with Assisted-by or Generated-by, and an academic proposal defines a faceted scale from G0, fully human-authored, through G1 AI-assisted completion, G2 simple-prompt generation, G3 detailed-prompt generation, G4 iterative conversation, to G5 a structured multi-step pipeline. But no published source maps a percentage of generated lines to a specific keyword. Treat any generation-share threshold you see as a local convention, not a standard.

Fingerprinting the unmarked: what carries the signal and what does not

For commits with no identity and no trailer, the fallback is behavioral fingerprinting, and the counterintuitive finding is that commit-message shape beats code style. In Ghaleb's study of 33,580 pull requests from five agents (OpenAI Codex, GitHub Copilot, Devin, Cursor, Claude Code) using 41 features, a classifier reached a 97.2% F1-score in multi-class agent identification.

The importance is lopsided. Codex's distinctive multiline commit pattern alone carried 67.5% of feature importance. Conventional-commit conformity carried 48.9%. Claude Code's code-structure tells, 27.2% for conditional statements and 19.8% for comments, sat well below the message-level features. Code content ranks low because message formatting is a stable tool artifact while code style converges as models improve.

Commit-message shape is a stable tool artifact; code style converges as models improve. Read the message, not the diff.

So when you fingerprint an unmarked commit, look at message structure and PR structure, not comment density. A wall of perfectly conventional multiline messages across a burst of commits is a stronger tell than any single elegant function.

The ceiling matters too. Post-hoc "does this look AI" detection, the heuristic and watermark approaches, tops out around 20-25% accuracy by the assessment of one detection vendor. Even free code-level AI detectors reach only 70-85%. None of that is governance-grade. Fingerprinting narrows a guess; it does not close a case.

When you need to find developers by the exact authorship pattern in their history rather than a self-reported skill line, Refolk searches the public GitHub graph and profile text together, so you can ask for the identity signal directly instead of eyeballing repos one by one.

Line-level provenance: the only ground truth, and why you rarely get it

Several tools now attribute code line by line to a human or an agent, but all of them capture provenance at generation time rather than detecting it afterward. This is the only class of signal that gives you ground truth, and it is almost never present in a stranger's history.

Git AI stores line-level attribution in git notes and ships git ai blame, a drop-in replacement for git blame that shows AI attribution per line, viewable with git log --show-notes="ai". Mesa's Agent Blame is explicit that it is not a detector: it captures provenance at the moment an agent edits a file and attaches it to what lands in git. Cursor ships Cursor Blame. Entire, founded by ex-GitHub CEO Thomas Dohmke on a $60M seed, stores checkpoints on an entire/checkpoints/v1 branch.

The hard prerequisite is the whole story: agent hooks must be installed before the code is written. Cursor, Claude Code, and OpenCode expose hooks that fire when an agent edits a file. No hook, no data. This means historical public commits cannot be retroactively line-attributed.

How this goes wrong: the false positives that will burn you

This is the section to reread before you commit to a verdict. Every signal above has a failure mode, and most of them produce a confident, wrong "human" label.

Squash merge collapses per-commit truth. When a PR is squash-merged, trailers from individual commits concatenate into the final merge commit. The mainline then shows a human author over pooled agent work. GitHub does credit every PR author as a co-author on the squash commit, but Copilot's squash keeps the last commit's author, which is Copilot. Fix: open the PR and read the pre-squash commit list, never judge from the merge commit alone.

Trailer trusted as proof. A hand-inserted trailer on human code, or a stripped trailer on agent code, both defeat you. Trailers are forgeable metadata. Corroborate with identity or provenance.

Errant newline hides real trailers. Git expects trailers in a single group at the end of the message. A single stray blank line caused GitHub to read a correctly attributed commit as carrying no Co-authored-by lines. Verify with git interpret-trailers --parse before you conclude a commit is unmarked.

Project config suppression. A repo with includeCoAuthoredBy: false in .claude/settings.json emits zero trailers despite heavy agent use, overriding every individual user's setting. Zero trailers can mean policy, not humans.

Fingerprinting on code content. Judging by comment and conditional style is weak because those features rank low and models drift. Message and PR-structure features carry the signal.

Post-hoc detectors oversold. Treating a 70-85% detector as governance-grade produces confident wrong labels at scale. A 2026 study of roughly 302,600 AI-authored commits across about 6,299 repos found over 15% introduced a code-quality issue and about 24% of those persisted, so the stakes on a wrong label are real. Demand false-positive rates before you trust any detector.

Line-level tools only work forward. Covered above, and worth repeating because it is the most common misread: no hook data means no data.

Shared identity. An agent pushing as the developer defeats every identity signal. Check whether the agent had its own bot account or borrowed the human's.

The audit procedure

Run these seven steps in order on a developer's public history. Steps one, two, five, and seven are fast sourcer work; three, four, and six need an engineer's read. The whole pass takes roughly an hour.

Here is a template for the greps that do the heavy lifting in steps one and two.

# Step 1: agent identities
git log --all --author="Copilot"
git log --all --committer="copilot-swe-agent\[bot\]"
git log --all --grep="cursor/" --all-match

# Step 2: attribution trailers in commit bodies
git log --all --format="%H %b" | grep -Ei "Co-authored-by: (Claude|Copilot)|Generated with|Agent-Logs-Url"

# Verify a suspected-unmarked commit really has no trailer
git show -s --format="%B" <sha> | git interpret-trailers --parse

# Step 5: line-level provenance, if the repo was forward-instrumented
git log --show-notes="ai" -1 <sha>
git branch -a | grep -E "entire/checkpoints|cursor"

The output of step seven is a per-commit table with three columns: the classification, the signal you used, and its reliability. A row that says "agent, copilot-swe-agent[bot] committer, high" is defensible. A row that says "human, no trailer found, low" is honest about being a residual.

What each authorship class lets you conclude about skill

The reason you are doing this: to read a developer's GitHub for real skill. Authorship changes what a repo proves.

Agent-authored commits tell you the developer can drive an agent and merge its output, which is a real and increasingly valued skill, but they do not evidence hand-authored problem-solving. AI-assisted commits sit in between: the human shaped and committed the work. Human-authored commits are the only ones that evidence unaided craft, and after this audit you can point to the specific commits that carry that weight.

Do not overcorrect into penalising agent use. Adoption is the norm, not a red flag. The Refolk index numbers, 8,489 US Copilot profiles and 3,621 Claude Code profiles, describe a population where fluent agent operation is a hiring signal in its own right. The audit exists to attribute correctly, not to disqualify.

Keeping this reference current

Every signal here is versioned, and the vendors move. Re-check three things on a schedule rather than trusting a value you cached. First, agent trailer defaults: Claude Code moved from an includeCoAuthoredBy boolean to a new setting in v2.0.62, and Copilot added the Agent-Logs-Url trailer only in March 2026, so older commits from the same agent look different. Confirm the current default before you read absence as meaningful.

Second, the emerging keyword split. If Assisted-by or Generated-by trailers gain adoption, your grep in step two needs new terms, and the taxonomy table above gains rows. Track the Apache and VS Code threads where that debate is live.

Third, line-level tooling reach. As Git AI, Agent Blame, Entire, and Cursor Blame spread, more repos will carry git notes or checkpoint branches, which raises how often step five yields ground truth. The mechanism will not change: provenance is captured at edit time via hooks, so it is only ever present when someone instrumented the repo before writing the code. What changes is how often that is true. Re-run the audit, not your memory, on each new developer.