Velocity metrics were built for a world where humans wrote every line. This deck is what we built to replace them — each metric with its field name, its unit, and what it cannot tell you.

It turns every other metric into a conditional question: what happens to durability with an agent guide versus without one? Presence and metadata only — never file content.

Typed, bounded, tested code gives an agent the affordances it needs to work safely. This is a property of the code, never of the team — there is no author dimension in the computation.

A stabilization ratio near 1.0 means changes persist — real work. Near 0.0 means rework dressed up as delivery. This is signal vs noise in one number.

Churn is the tax your team pays on shaky first implementations. Unlike velocity, it goes up when things go wrong — and it's visible per file.

Aggregate numbers tell you something is wrong. Churn detail tells you which file, what pattern, and what else changes with it. Now you can fix the root cause, not the symptom.

Fresh code that gets re-touched within two weeks usually means the first try missed. A 2-week rate trending up is the earliest quality alarm you can wire to a dashboard.

Copy-paste is the fast lane to entropy: the same bug, in five places, forever. A rising duplicate rate is the leading indicator of debt you haven't paid yet.

Moved code dropped from 24% to 9.5% post-AI in industry data. When your refactoring ratio rises, the team is actually extracting and organizing — not just generating more.

GitClear found 79% of revised lines in 2024 were less than a month old. If most of your team's effort is re-churning fresh code, you're not improving the codebase — you're spinning.

A team dominated by `added` is growing fast; by `updated`, iterating; by `moved`, refactoring; by `duplicated`, accumulating debt. Shape of work, in one chart.

AI-generated commits tend to be wide & shallow (spread) — scaffolding, boilerplate. Human commits lean surgical or focused. This pattern is measurable, not anecdotal.

"The backend is a mess" is a feeling. Stability map turns it into `src/payments/` at 0.41 vs `src/shared/` at 0.92. That's something you can fix, staff, or document.

Reverts are rare but unambiguous. Segmented by origin and AI tool, they answer: which tool's code gets rolled back? That comparison is hard to argue with.

Buckets: fast < 72h (probably obvious bugs), medium 72–168h (caught in review/prod), slow > 168h (subtle). Compare AI vs human fast-rework rates side by side.

A 30% cascade rate means almost a third of your trigger commits break something. Segmented by AI tool, this tells you which tool's output carries the highest cleanup cost.

Our internal benchmark found AI-attributed lines survive at 79% vs human 64% — on primed repos. Durability is the counter-intuitive headline: AI code may last longer when attributed properly.

If AI wrote 30% of commits but attracts 50% of fixes, disproportionality = 1.67 — the clearest signal that AI-written code costs more to maintain than it first appears.

A raw number tells you nothing without a baseline; the comparison is the metric. It is withheld entirely below 30 commits per side, so a small sample can never read as a verdict.

Every single other metric in devXOS can be segmented by origin. This is the dimension that unlocks AI impact analysis — without surveys, without self-report.

Compliance officers, AI governance leads, and skeptical CTOs all ask the same thing: how much AI is in our code? This is the answer you can defend in a meeting.

If ai_detection_coverage says 40% and attribution gap flags another 30% of human commits as suspect, your real AI footprint is double what your governance dashboard shows.

"We're shipping fast" means nothing if 60% is FIX. Intent distribution turns a flat commit count into a picture of what the team is actually spending time on.

Two different AI tools can produce code that reviews very differently. Acceptance rate quantifies that — it's the missing link between "AI productivity" claims and peer-reviewed outcomes.

AI might crush commits and pass review — and still drop off at stabilization. The funnel reveals exactly where each origin wins and where it leaks. One chart, full story.

Before-and-after proof. Stabilization went from 0.71 to 0.84 since the Copilot rollout? That's a number you can put on a slide. Reversed? That's a number you need to look at fast.

Single-pass rate is the PR metric that correlates most with team satisfaction. Combined with time-to-merge, it tells you whether review is a gate or a bottleneck.

Without this, AI looks like a win on commits/week while lead time flatlines. With it, you see exactly which queue is absorbing the speedup — and whether the gain is reaching production.

Healthy throughput with rising WIP and flat author concurrency is congestion in disguise. This is the metric that explains why a team feels busier when the dashboards look fine.

Throughput metrics describe work that moved. This describes work that stopped. When AI generation outruns review capacity, this is the metric that catches it first — and the AI-vs-human gap shows up clearly.

When AI writes more of the code and review is the last human checkpoint, this is the coverage of that checkpoint. A rate falling while AI share rises is the pattern worth catching early.

When a metric jumped, you need to know why. The timeline + patterns layer gives you an annotated story — not just numbers, but the moments that made them.

Accelerating with durability steady = real progress. Accelerating while stabilization drops = you are shipping noise faster. Velocity alone lies. Velocity + durability tells the truth.

The closing answer to the question this deck opens with: does AI-assisted code survive in production? With Datadog connected, CFR and rollback rate by origin make the answer numerical — for the teams that choose to provide it.

If a code signal reliably leads a production failure, you get warning weeks earlier. The guardrails matter more than the finding: Šidák correction for the lag scan, tail censoring of look-ahead series, and per-week minimum denominators.

Cost per generated line is a vanity number; cost per feature that lasted is a decision. Models we cannot defensibly price are reported as null and listed — the total under-reports transparently rather than guessing.