Wasn't evidtrail called AIDA Metrics?

Yes, until version 1.1. evidtrail is the same tool under a name that survives a search: AIDA collided with the marketing funnel and an opera, and its expansion, AI Development Accounting, promised a cost-and-value reading the tool refuses to make. The @aida-dev packages, .aida.json, AIDA_MODE and the aida command keep working for one release and point at their new names.

Does evidtrail measure developer productivity or the ROI of AI coding tools?

No. evidtrail records provenance (who or what wrote a commit, and how that is known) and, as an appendix, change signals (how often files are touched again within a fixed horizon). It does not infer productivity, defects, deployment, causality, capitalization, or developer performance, because git history cannot establish those.

How does evidtrail know a commit was written by an AI agent without developers labelling commits?

A prepare-commit-msg hook, installed once per clone (or automatically via a package.json prepare script), detects agent sessions such as Claude Code or Cursor from their environment and stamps an AI-Mode trailer, plus an Assisted-by trailer naming the tool. Assisted-by trailers written by people, the convention of the Linux kernel, Fedora and LLVM, and tool co-author trailers are read as well. A commit with no signal stays unknown — it is never assumed to be human.

Can a pull request be required to declare AI use?

Yes. evidtrail verify, or the GitHub Action input require-provenance, fails a pull request whose commits do not state how they were produced, the way a DCO check requires Signed-off-by. AI-Mode: none passes; a repository-wide default does not.

Does evidtrail measure whether AI-written code is good?

No. Mistakes an agent makes and fixes inside its session never reach git, so git history cannot answer that. evidtrail reports retouches, reverts and hotfixes as change signals in an appendix, and says that they are churn, not quality.

Why doesn't evidtrail compare AI-written code with human-written code?

It did until 1.3, and 2.0 removed the comparison. In most repositories one side is empty, and where both exist the gap between them reflects the work each group did more than the quality of the code. A configured defaultMode is stamped on new commits by the hook and is never applied to old ones.

Why is the most recent month excluded from the trend?

A period that ended yesterday has had one day to be reworked; a period from last year has had a year. Compared raw, every report would find retouch rising. evidtrail judges every period on the same fixed horizon and compares only periods that have been over for that horizon.

Does evidtrail send my code or commit data anywhere?

Collection, analysis, and reporting are local and offline. Only two commands use the network, both opt-in: fetch-prs reads pull request outcomes from the forge API, and comment posts the report to a PR. Author identities can be redacted with --redact-authors.

Every commit says
how it was produced

A git hook declares AI use at commit time, a CI check fails pull requests that stay silent, and an AI commit can point to the agent session that produced it.

npm install -g @evidtrail/cli

View on GitHub

Terminal

$ evidtrail init

+ .evidtrail.json created

+ commit hook installed

+ package.json prepare created — evidtrail install-hooks --if-git

+ .github/workflows/evidtrail.yml created — PR comment, minimal permissions

$ evidtrail doctor

✓ clone depth full history

✓ commit hook (this clone) AI-Mode and Assisted-by will be stamped

Ready: every check passed.

$ evidtrail --since 90d

Collected 77 commits · coverage 100.0% (agent 52, automated 25, unknown 0)

Trend: fewer than two mature periods (30d window) — no comparison yet

Reports written to ./evidtrail-output/

Real output from this project's own repository. A young window says "no comparison yet" instead of inventing one.

What it does

✍️

Declared at commit time

The commit hook writes AI-Mode and Assisted-by, the trailer the Linux kernel, Fedora and LLVM ask for. When evidtrail cannot know the mode, it writes nothing, and unknown stays honest.

✅

Checked in CI

evidtrail verify fails a pull request whose commits do not state how they were produced, like a DCO check for Signed-off-by. AI-Mode: none passes; a repository-wide default does not.

🧵

Traceable to the session

Opt in, and AI commits carry AI-Session, the id of the agent session that produced them. evidtrail trail <commit> finds the transcript on your machine without opening it.

⚖️

Autonomy, not the binary

Two axes: what level of AI participated (autocomplete / assisted / agent) and how we know (declared / inferred / none). The report opens with them. An assumption never becomes evidence.

💬

PR Comments

One line on the pull request when every commit carries provenance, the gap in the open when it does not. GitHub Actions and GitLab CI are supported.

📉

Change signals, as an appendix

How often files are touched again, reverts and hotfixes, and their trend. Churn, not a quality score: mistakes an agent fixes inside its session never reach git.

Get Started

Install globally

npm install -g @evidtrail/cli

Navigate to your Git repo

cd /path/to/your/repo

Set up and run

evidtrail init && evidtrail --since 90d

Supported AI Tools

Known tool and trailer signals can establish AI involvement. They do not, by themselves, prove an autonomy mode; absent evidence remains visible as unknown.

Claude Code

GitHub Copilot

ChatGPT

Cursor

Windsurf

Gemini

Codeium

+ Custom tools via .evidtrail.json

CI/CD Integration

One step in your workflow. The action runs evidtrail doctor first, so a shallow checkout is refused before it can produce a confidently wrong report.

.github/workflows/evidtrail.yml

name: evidtrail Analysis

on: [pull_request]

permissions:

contents: read

pull-requests: write

jobs:

evidtrail:

runs-on: ubuntu-latest

steps:

- uses: actions/checkout@v5

with:

fetch-depth: 0

- uses: ceccode/evidtrail@v2

with:

comment: true

require-provenance: declared

evidtrail PR comment on GitHub: one verdict line, every commit in this change set carries provenance, with a collapsed Details fold — What lands on the pull request when every commit carries provenance: one line, details folded. When commits lack provenance the line turns to ⚠️ and names them, with the one-line repair.

What evidtrail is — and is not

evidtrail does not infer productivity, defects, deployment, causality, capitalization, or developer performance from git history. It records what git can actually establish, with the limits kept visible.

Does evidtrail measure developer productivity or the ROI of AI coding tools?: No. It records provenance — who or what wrote a commit, and how that is known — and, as an appendix, change signals — how often files are touched again within a fixed horizon. Nothing in git history can establish productivity or value, so evidtrail does not claim it.
Does it tell me whether AI-written code is good?: No. Mistakes an agent makes and fixes inside its session never reach git, so git history cannot answer that. The change signals are churn, and the report says so before showing them.
Can a pull request be required to declare AI use?: Yes. evidtrail verify, or the Action input require-provenance, fails a pull request whose commits do not state how they were produced, the way a DCO check requires Signed-off-by.
How does it know a commit came from an AI agent, without anyone labelling commits?: A prepare-commit-msg hook, installed once per clone or automatically through a package.json prepare script, detects agent sessions (Claude Code, Cursor) from their environment and stamps AI-Mode and Assisted-by trailers. Assisted-by written by people and tool co-author trailers are read as well. A commit with no signal stays unknown — it is never assumed to be human.
Why doesn't it compare AI-written code with human-written code?: It did until 1.3, and 2.0 removed the comparison. In most repositories one side is empty, and where both exist the gap reflects the work each group did more than the quality of the code. A configured defaultMode is stamped on new commits by the hook and never applied to old ones.
Why is the most recent month left out of the trend?: A period that ended yesterday has had one day to be reworked; one from last year has had a year. Compared raw, every report would find retouch rising. Every period is judged on the same fixed horizon, and only periods that have been over for that horizon are compared.
Does it send code or commit data anywhere?: Collection, analysis and reporting are local and offline. Two commands use the network, both opt-in: fetch-prs reads pull request outcomes from the forge API, comment posts the report to a PR. Author identities can be redacted.
Wasn't this called AIDA Metrics?: Yes, until 1.1. The name collided with the marketing funnel and an opera, and its expansion — "AI Development Accounting" — promised the cost-and-value reading the tool refuses to make. Same tool, same numbers: @aida-dev/*, .aida.json, AIDA_MODE and the aida command keep working for one release and point at their new names.

Who will need to prove what AI produced?

A year from now, who will need to prove what AI produced in their repository, and to whom? If you have an answer, or think nobody will, tell us.

Get Started Answer in Discussions

Every commit says how it was produced