AI Code Insights

AI coding agents are writing code across your organization every day. AI Code Insights shows you what they produce, how they work, and where they get stuck — so you can measure AI’s real contribution and unblock agents that aren’t delivering.

AI Code Insights lets you:

  • See which commits and pull requests contain AI-generated code.
  • Understand how AI-heavy pull requests move through review and delivery.
  • Connect coding-agent adoption with velocity and quality signals.
  • Use session-level data to identify where agents need better context, steering, or task scope.
  • Trace coding sessions to the commits, pull requests, and deployments they produced.

How it works

  1. Install the AI Code Insights daemon.
  2. Work with a supported agent.
  3. Commit and push your changes.

Supported agents report file edits and session activity to the local daemon through native hooks or plugins. The daemon attributes code when you commit, and DX connects those metrics with source control, team, and delivery data after you push.

Supported coding agents

AI Code Insights attributes AI code and sessions through direct agent hooks for: Codex, Claude Code, Cursor, Devin CLI, Devin Desktop (Windsurf), GitHub Copilot, Gemini CLI, OpenCode, and Rovo Dev.

See Supported capabilities for the data available from each agent. Agents without a native integration are not attributed — code they produce is counted as human-authored.

Supported capabilities

Agent Code attribution Transcripts Token usage Tool/MCP/Skill usage
Codex Yes Yes Yes Yes
Claude Code Yes Yes Yes Yes
Cursor Yes Yes — Yes
Devin CLI Yes Yes Yes —
Devin Desktop (Windsurf) Yes Yes — —
GitHub Copilot Yes Yes — —
Gemini CLI Yes Yes Yes —
OpenCode Yes Yes Yes —
Rovo Dev Yes Yes Yes Yes
Capability Support Details
Edit, write, and patch tools Yes Native agent hooks or plugins report accepted edits to the daemon.
Files created or changed through Bash and shell tools Agent-dependent Supported when the agent integration exposes shell-command start and finish events.
Git worktrees Yes The daemon discovers linked worktrees and attributes commits to the parent monitored repository.
Background and cloud agents No Cloud-hosted agent activity is not currently captured.
Multiple agent sessions contributing to the same commit Yes A committed file can retain links to multiple contributing session IDs.
Human changes to AI-generated code Partial DX reports original, retained, modified, and deleted AI lines plus similarity; it does not provide a user-facing line-by-line override view.
Sessions that produce no committed code Yes Sessions can be captured independently of commits when Transcripts & Agent Experience is enabled.
Accepted rate per session No DX measures committed AI retention, not a per-session suggestion acceptance rate.
Added and deleted lines per session Partial Session drilldowns link to resulting commit and pull request additions and deletions, but lines are not exclusively allocated when multiple sessions contribute.
Tool usage capture Agent-dependent Captures tool calls within sessions for Codex, Claude Code, Cursor, and Rovo Dev.
MCP usage capture Agent-dependent Captures MCP tool invocations for Codex, Claude Code, Cursor, and Rovo Dev.
Skill usage capture Agent-dependent Captures skill usage for Codex, Claude Code, Cursor, and Rovo Dev when the integration identifies a skill invocation or skill-definition read.
Code attribution per tool call No Tool-usage collection does not attribute committed lines to individual tool calls.
Subagent tracking Agent-dependent Claude Code subagent sessions and their lineage are captured; other agents are not currently supported.
Tokens and cost per commit or pull request No Token usage is session-level when an agent exposes it; DX does not allocate session tokens or cost to individual commits or pull requests.
Formatters Partial Retained AI content keeps its attribution, while lines materially rewritten by a formatter can be reported as modified or human-authored.
Multi-repository agent roots Partial For agents that report a working directory, the session must start in a monitored repository. Attribution can span other monitored repositories, but cross-repository shell changes are best effort.
Very large monorepos Partial Repository size can affect daemon performance and attribution accuracy. Test machine performance and representative commits before a broad rollout.
Operation Support Details
git rebase Partial Clean replays preserve attribution. Commits whose patches change are re-analyzed, so results can differ.
git cherry-pick Yes Matching patches carry attribution to the new commit and branch.
git stash / git stash pop Yes Retained attribution is recovered when stashed content is reintroduced; conflict edits can change the result.
git merge --squash No The resulting commit is not guaranteed to inherit attribution from commits on the source branch.
git reset --soft Yes Attribution is retained when commits are combined and recommitted.
git reset --mixed Yes Working-tree attribution is retained for the subsequent commit.
git reset --hard Yes Attribution remains for commits that are still reachable or were already reported; discarded uncommitted work is not retained.
git merge Yes Source commits keep their attribution, and new merge-resolution changes are analyzed in the merge commit.
git commit --amend Yes The replacement commit is analyzed and the superseded local result is reconciled.
git checkout / git switch Yes Uncommitted attribution follows the working tree when switching branches.
git pull and git pull --rebase Yes Fast-forward and rebase workflows are reconciled.
git push / git fetch Yes Pushed attribution is sent after the daemon confirms the commit on a remote branch; fetching does not remove attribution.
git mv Yes Attribution follows a renamed file, including a rename with subsequent human edits.
git filter-branch / git filter-repo No Bulk history rewrites are not tracked.
git replace No Git object replacements are not tracked.
Detached HEAD No Commits created while HEAD is detached are not reported.
Custom stack and restack workflows Partial Results depend on the underlying Git operations; unsupported history rewrites can lose attribution.
Operation Support Details
Squash and merge Partial DX can report the original pull request commits when they were uploaded and matched by the source control connector, but the new server-created commit is not re-attributed by the local daemon.
Rebase and merge Partial DX can report the original pull request commits, but server-created replacement commits do not inherit local daemon attribution.

Available reports

  • AI code percentage — See how much committed code is attributed to supported coding agents.
  • AI pull request overview — Compare delivery and review signals across pull requests with different levels of AI-attributed code.
  • AI effectiveness — Connect adoption, delivery, quality proxies, and coding-session patterns.
  • Agent Experience — Find friction in requirements, steering, and task scope from the agent’s perspective.
  • AI Dollar Impact — Estimate the value of AI agent usage.
  • AI Cost Management — Track AI token usage and budgets across your organization.

Privacy

AI Code Insights is designed to measure code authorship, not monitor developers.

  • Source snapshots and raw Git diffs stay on the developer’s machine.
  • Transcript retention and analysis are optional and off by default.
  • The daemon scrubs common secret and personal-data patterns before sending eligible session messages to DX.
  • Admins control transcript access and whether sensitive transcript data can be queried in Data Studio.

See Security and privacy for the complete data flow, controls, and considerations.

Get started

  1. Plan a pilot.
  2. Install on one machine or prepare an enterprise deployment.
  3. Verify deployment.

FAQs

Supported agents report file edits through native hooks or plugins. The daemon compares those edit signals with the final committed files on the developer’s machine. It does not use an LLM or a heuristic to guess whether code looks AI-generated.

No. The developer can commit through their normal Git client, IDE, or command line. Attribution comes from the supported agent’s edit signals, not from who runs the commit command.

No. The daemon can only attribute edits it observes after it is installed and running. Older commits can appear as 0% AI even when AI was used to produce them.

AI Code Insights needs an observed signal from a supported agent integration. Code from an unsupported agent, a cloud agent, or a browser-based AI tool that is pasted into an editor has no attribution signal and can appear as 0% AI. A missing or unhealthy daemon integration, a session started outside a monitored repository, or an unsupported Git history rewrite can have the same effect. Treat 0% as “no AI attribution was retained for this commit,” not proof that every line was written manually.

No. Code attribution, AI code percentage, and AI pull request reporting work without transcript retention. Transcripts are required for Agent Experience and the transcript-powered sections of AI effectiveness.

Source snapshots and raw Git diffs used for commit attribution stay on the developer’s machine. DX receives commit metadata and attribution metrics. If transcript collection is enabled, eligible session messages are scrubbed before transmission but can still contain code or sensitive text that the scrubber does not detect. See Security and privacy for details.

Yes. Linked Git worktrees are supported. Commits created while HEAD is detached are not reported. For remote SSH, development containers, and other remote environments, install the daemon where the repository and coding agent run. Ephemeral environments must include or reinstall the daemon when they are created.

Confirm that representative machines, repositories, and agents are reporting data, then validate a known commit. Follow Verify deployment before using the reports to compare teams or guide a broader rollout.

Yes. There is a list of common cache locations and lock files that is combined with your configured auto-generated file patterns list to make a list of file patterns to exclude.