CHURNTwo-snapshot measurement
Quantifies added, deleted, changed, and unchanged lines between two versions of a project — per file and in aggregate.
Your diffs got enormous, your tools count lines, and machines now write half the code. CodeDelta measures what actually changed — every statement added, deleted, or repaired, from one pull request to forty-three million lines of Chromium.
↓ keep scrolling ↓New to the terms? The Management Brief — every term in 60 seconds, printable →
Built on 20 years of churn-measurement heritage. Its predecessor was used by
CodeDelta does two things from a single analysis: it measures exactly what changed between two versions — changed LLOC, SLOC and files — and it scans that same code for where it uses AI, flagging the risky patterns. Both run locally, both produce verifiable per-file reports.
Quantifies added, deleted, changed, and unchanged lines between two versions of a project — per file and in aggregate.
Counts both SLOC (physical) and LLOC (statement-level) with per-language tokenizers, so reformatting doesn't inflate the result.
Every classification is inspectable in a per-line report. The numbers can be audited, not just trusted.
Audits added and changed code for stylometric signals consistent with machine generation, and reports how much of a change is likely AI-written.
Flags individual files and reports the proportion of new code matching machine-generation signals — surfacing where to focus human review.
Reported as signals for review, with the method and its limits documented in an open technical paper — not presented as infallible proof.
C/C++, Java, C#, Python, JavaScript/TypeScript, Go and more, detected automatically by extension. See all 36 →
Runs entirely on your machine. No source code leaves your environment. Results accumulate in a local store for trend analysis.
Churn metrics and AI-audit findings appear together in a single per-file HTML report you can inspect and share internally.
CodeDelta is a command-line instrument first. It reads straight from git, runs headless in CI, gates merges on churn or new AI findings, and exposes itself to AI coding agents — so its deterministic numbers land in the tools your developers and reviewers already use, not in a separate dashboard nobody opens.
Compare any two refs — --git v1.7..v1.8 or HEAD~10..HEAD — with no working-copy juggling. Snapshot dates come from commit history, so a whole release timeline backfills in one pass.
The Code Browser’s side-by-side diff colours every statement by what happened to it — added, deleted, edited in place — so a review starts from the change map, not a wall of green and red.
A drop-in GitHub Action (code-delta-app/action@v1) wires CodeDelta into any repo in a dozen lines. Builds branch on its exit codes — fail on excess churn, on AI percentage, or only on findings newer than a committed baseline — and results post as SARIF plus a PR summary, inline on the diff and in the code-scanning tab.
TRUE_CHURN subtotals generated files — lockfiles, bundles, generator output — out of the headline number, rule by named rule, so the figure describes what your team wrote.
Export an inventory of every AI provider, endpoint and jurisdiction your code reaches — native or CycloneDX — and gate the build on policy: block egress to foreign-hosted models or unapproved providers. The artifact auditors and AI-governance programmes ask for.
Agent Scan inventories the agent infrastructure in your tree — workspaces, MCP configs, rogue-agent residue, committed credentials — each a named path in the report and AI-BOM. Produced from source, offline; gate the build on it only if your policy says so.
An MCP server lets Claude Code, Cursor and other assistants run CodeDelta directly — so "how much churn since v1.7?" returns the tool's reproducible numbers, not an improvised guess.
Every analysis exports CSV and JSON beside the HTML report — feed trend dashboards, spreadsheets, or your own scripts. Nothing is locked inside the report.
Runs accumulate in a local database; a one-page summary charts churn and AI% across releases for the people who approve the work, not only those who run the scan.
CodeDelta is a command-line engine first. Drop the GitHub Action into a repo and every pull request gets churn and AI findings posted back as a comment — with an optional gate that blocks the merge. Or run the same binary from cron for a nightly trend. Nothing is installed on a developer's machine, and the code never leaves your runner.
A single run generates a per-file HTML report covering churn, the AI code scan and the agent scan, plus the Code Browser (tree, classes, and a side-by-side diff) — all inspectable, all local. Every figure below is real output from the tool.
folly, across 51 files), its methods round it — red where this scan churned them — and the classes its code mentions as satellites; every link cites the file and line of the mention. A pointer for review, not a resolved call graph.
rogue_executor.py (AIS 100), with exec() on model output caught as the rogue-agent pattern.
dnn from a real 4.8 → 4.10 churn scan — 240 of its 770 methods drawn, ranked by churn then size, red and amber where this release changed them, the classes it mentions ringed around. Step the density up or down; every dot names itself on hover.Real output from CodeDelta — every figure above is produced by the tool from an actual scan, not a mock-up.
Churn: CodeDelta reports changed, added and deleted logical lines (LLOC), physical lines (SLOC) and files between two snapshots. It aligns each file pair with a longest-common-subsequence algorithm — once over physical lines, once over a logical-statement token stream — with a second pass disambiguating repeated tokens using scope-qualified anchors, so reformatting never inflates the count.
Agent Scan: the same code is scanned for where it calls AI — agent-SDK imports, model endpoints, exec-on-model-output and prompt-injection patterns — and rolled into an AI Bill of Materials covering every provider, endpoint and jurisdiction. Findings are flagged for security review, not asserted as malicious.
The churn algorithm and the AI detection methods — with their limits — are documented in open technical papers written to be independently verifiable.
Logical (LLOC) and physical (SLOC) lines modified in place between two snapshots — the core signal.
New logical and physical lines, and newly-added files, in the later snapshot.
Logical and physical lines, and whole files, removed from the earlier snapshot.
Changed + added + deleted — per file and across the whole project, in both LLOC and SLOC.
How much of the change was wholesale replacement rather than edits in place — (added + deleted) ÷ total churn, bounded 0–1. A high ratio can indicate AI-generated code, where whole blocks are regenerated rather than edited.
Finds where code calls AI — SDK imports, model endpoints, exec-on-model-output — and inventories it as an AI Bill of Materials.
Download a time-limited trial license and run CodeDelta locally. No source code is transmitted.
Try CodeDelta