AI code attribution
also: AI-authored code attribution · AI code authorship tracking
AI code attribution is the practice of recording which AI coding agent produced which code, so that AI-generated lines can be distinguished from human-written ones. It links each change to the agent and model that authored it, providing the authorship record that AI-assisted development would otherwise erase.
The attribution gap in AI-assisted development
When an AI agent commits code autonomously, the authorship trail disappears. git blame shows the human or bot that committed it, not the agent that wrote it, the model behind it, or the context it was missing. As agents write a growing share of every codebase, that gap makes review, incident response, and audit harder.
Attribution restores the missing signal. By tagging each change with the agent and model that produced it, reviewers can apply more scrutiny where it is warranted — for example, requiring human sign-off when an agent touched authentication, payments, or infrastructure.
What good AI code attribution records
- Agent identity — Claude Code, Cursor, GitHub Copilot, Codex, Windsurf, OpenCode, or Gemini.
- Model identifier — the specific model version that generated the change.
- Files and line ranges — the precise lines the agent authored.
- Intent and context — an optional prompt excerpt and the files the agent had visibility into.
- Commit revision — so attribution maps back to the exact change in history.
Cross-agent attribution
Most teams use more than one AI tool. Single-vendor telemetry (for example, Copilot's own audit log) only sees its own activity and excludes local session data such as prompts. Durable attribution requires a vendor-neutral layer that captures every agent into one record. AgentDiff integrates with each major agent's native hooks and writes a single, consistent attribution record regardless of which tool produced the code.
“Signed line-level provenance reads like the right primitive. The hard part is making it auditor-legible and low-friction for devs — auditor-legible + low-friction is the whole game.”
Frequently asked questions
How do you attribute AI-generated code?+
You capture the agent and model at the moment of authorship through each agent's hooks, reconcile that against the committed diff by line range, and store the result as a durable record next to your git history. AgentDiff automates this across Claude Code, Cursor, Copilot, Codex, and more.
Why isn't git blame enough for AI code attribution?+
git blame attributes a line to the last commit's committer. When an AI agent generates code committed under a developer's name, blame names the human and silently drops the agent, model, and context — exactly the information attribution exists to preserve.
Can AI code attribution work across multiple AI tools?+
Yes, but only with a vendor-neutral layer. Each vendor's own telemetry sees only its tool. AgentDiff captures Claude Code, Cursor, Copilot, Codex, Windsurf, OpenCode, and Gemini into one cross-agent attribution record.
See line-level provenance on a real repo.
AgentDiff records which agent wrote which line, signs it, and keeps it in your git history. Open the live dashboard or book a walkthrough.