Written by: Mark Hull, Co-Founder and CEO, Exceeds AI | Last updated: August 3, 2026
Key Takeaways
- DORA metrics track system-level delivery speed and stability, while SPACE and DevEx frameworks measure human experience and workflow friction, yet none of these approaches attributes outcomes to specific AI tools.
- AI-generated code now accounts for roughly 30% of merged commits, but traditional metrics cannot track 30-day rework patterns or prove ROI across Cursor, Claude Code, Codex, GitHub Copilot, and Windsurf.
- Flat DORA scores mask underlying shifts: 98% more merged PRs, 242.7% higher incidents per PR, and two-week code churn rising from 3.1% to 5.7%, all of which signal hidden technical debt.
- Metadata-only tools like Jellyfish, LinearB, and Swarmia lack line-level AI provenance, so they cannot distinguish AI-generated lines from human-authored lines or quantify whether AI-assisted code increases risk.
- Exceeds AI adds the missing commit-level provenance layer that turns DORA and SPACE data into actionable AI ROI proof, so you can connect your repo and start your free pilot today.
DORA, SPACE, and DevEx: What Each Framework Actually Measures
DORA metrics originated in 2014–2015 research by Nicole Forsgren, Jez Humble, and Gene Kim and were later popularized in the 2018 book Accelerate. The creators designed DORA for a world where humans wrote all code. DORA answers one core question: how fast and reliably a team ships software. Modern frameworks such as SPACE (Satisfaction, Performance, Activity, Communication, Efficiency) and DevEx answer a different question: what the human experience of doing that work looks like. DORA focuses on downstream pipeline outputs, while SPACE and DevEx focus on upstream conditions that shape those outputs. Both frameworks were built before recent industry reports showed AI-generated code accounts for roughly 30% of merged code or commits, with company-specific shares ranging from 25–75%, and neither framework was designed to answer the question engineering leaders now face: which lines came from which AI tool, and what happened to those lines afterward.
The AI-Era Critique: Where DORA and Modern Frameworks Break Down
Eighty-four percent of developers are now using or planning to use AI tools, and 51% of professional developers use them daily (2025 Stack Overflow Developer Survey), yet the four core DORA metrics have remained flat. The 2025 DORA report shows that 24% of respondents still deploy less than monthly. A surface read suggests AI is not helping. A closer read shows DORA is not measuring the right signals for AI-heavy environments.
The data underneath the flat DORA numbers tells a different story. Developer PRs merged per person rose 98 percent while incidents per PR rose 242.7 percent, according to the 2025 DORA State of AI-Assisted Software Development report, which suggests higher output volume is arriving with lower quality. GitClear data shows two-week code churn rose from 3.1% in 2021 to 5.7% in 2024 (and rising) across 211 million changed lines, meaning more code is rewritten or discarded shortly after merge. DORA 2025 and related telemetry reported AI-linked increases such as 98% more merged PRs, 441% longer review times, and 54–243% higher bug and incident rates, with flat organizational delivery metrics, which confirms system-level degradation despite individual productivity gains.
The METR randomized controlled trial illustrates this perception gap clearly. Experienced open-source developers completing 246 real tasks were 19 percent slower with AI tools in mature codebases, despite estimating afterward that AI had made them 20 percent faster, creating a 39-percentage-point perception gap. DORA dashboards cannot surface this gap because they record merge events, not the cognitive overhead that precedes them. This perception-versus-reality gap is exactly what modern frameworks like SPACE and DevEx attempt to address by measuring developer experience directly, yet even these frameworks do not close the loop.
Modern frameworks do not close this gap because they stop at experience signals. SPACE captures developer satisfaction and cognitive load through surveys. DevEx measures friction through experience indicators. Both provide valuable leading indicators of team health. Neither can tell a VP of Engineering whether the AI-generated code that passed review last sprint will cause an incident in 30 days. A 2026 study titled “Debt Behind the AI Boom” analyzing explicitly identified AI-authored commits found many static-analysis issues that persisted in later repository revisions, which highlights the risk that AI-generated code introduces when it lacks code-level attribution.
The fundamental problem is provenance blindness. A team can improve deployment frequency because AI generates more code faster, while change failure rate worsens because that code is harder to review or maintain. DORA records output volume without identifying the source. SPACE records how developers feel about the work without identifying which lines produced the outcomes. Neither framework was built to answer a concrete question: which AI tool wrote this code, in which mode, and what happened to that code over the following 90 days.
Longitudinal Evidence: What Metadata-Only Tools Miss in AI-Heavy Repos
The gap between DORA signals and actual code quality becomes visible only when outcomes are tracked longitudinally at the commit level. Several independent data sources now document this pattern across large codebases.
GitClear’s longitudinal study of 211 million changed lines across Google, Microsoft, Meta, and enterprise repositories found two-week churn rose from 3.1 percent to 5.7 percent, refactoring fell from 25 percent to under 10 percent, and cloned code rose from 8.3 percent to 12.3 percent, which shows that higher deployment frequency can mask rising technical debt and in-repo rework that DORA does not capture.
A CodeRabbit analysis of 470 open-source PRs found AI-co-authored PRs generated 1.7 times more issues overall, with 75 percent more logic errors and 3 times more readability problems. These issues rarely appear in DORA change failure rate because they pass CI gates at merge time and surface later as incidents, rework, or customer-reported defects.
Amazon stated that only one recent service incident involved AI tools in any way and that the root cause was an engineering team’s user error rather than AI-generated code. A DORA dashboard would have recorded those incidents as a spike in change failure rate with no attribution to AI authorship.
The 2026 iBuidl Research report aggregated telemetry from 4,000 engineers and did not report 23 percent fewer post-deployment bugs for teams using AI coding tools under adapted code review. Teams that adapted review practices saw that improvement. Teams that did not adapt saw no quality gain, and metadata-only tools could not distinguish between the two groups because both groups showed similar PR cycle times.
The pattern across these data sources remains consistent. AI-touched code passes review, enters production, and fails later. Metadata-only tools, including traditional DORA dashboards and SPACE survey platforms, record the failure but cannot trace it back to its origin. Only commit-level AI provenance closes that loop.
Why Repo Access and Line-Level Provenance Now Matter
The measurement gap described above reflects a category gap, not a missing feature in existing tools. Platforms such as Jellyfish, LinearB, and Swarmia were built for the pre-AI era. They track metadata such as PR cycle times, commit volumes, and review latency, yet they remain blind to AI’s code-level impact. They cannot tell a VP of Engineering which lines are AI-generated versus human-authored, whether AI-authored diffs are higher quality or riskier, or which engineers are using AI effectively versus struggling.
With daily AI usage now the norm for most professional developers, engineering teams in 2026 typically use multiple tools simultaneously, such as Cursor for feature development, Claude Code for large-scale refactoring, Codex for batch transforms, GitHub Copilot for autocomplete, and Windsurf for specialized workflows. A metadata-only tool that tracks aggregate PR cycle time cannot distinguish whether a 20 percent improvement came from Cursor agent mode on greenfield work or from Copilot autocomplete on boilerplate, and it cannot show whether either pattern remains sustainable.
Heuristic and watermark-based AI detection, the approach used by most tools that attempt AI attribution, tops out around 20 to 25 percent accuracy. The only way to get an authoritative answer is to observe what happens on the engineer’s machine at the moment the work occurs. That requirement creates the need for a client-level provenance layer.
Exceeds Ink provides that layer. It captures AI authorship across Claude Code, Cursor, Codex, GitHub Copilot, and Windsurf with line-level fidelity and writes a portable attestation as a Git Note at refs/notes/exceeds-ink alongside every commit. Every line carries its tool, model, session, interaction mode, and timestamp. Lines that cannot be confidently attributed are recorded as unknown_lines, not silently rolled into “human” or “AI.” The attestation uses machine-readable JSON that lives in the repository, travels across forks and mirrors, and survives outside any analytics platform.
With that provenance layer in place, DORA and SPACE data shift from descriptive dashboards to actionable intelligence. Change failure rate can be segmented by AI authorship. Rework rate can be tracked by tool and interaction mode. The 30-day incident rate for Cursor agent-mode code can be compared directly with the 30-day incident rate for human-authored code in the same repository. That capability represents the missing layer that neither DORA nor SPACE was designed to provide.
Four-Week Rollout: Turning DORA and SPACE into AI ROI Proof
This four-week rollout converts existing DORA and SPACE instrumentation into commit-level AI ROI proof using Exceeds Ink for provenance capture and Exceeds AI for Coaching Surfaces and ROI reporting.
Week 1: Baseline and Provenance Setup. Begin by authorizing Exceeds AI via GitHub, GitLab, or Azure DevOps OAuth to establish repository access. After authorization, install Exceeds Ink on engineer machines using per-repo opt-in hooks so the platform can capture line-level provenance. First insights appear within 60 minutes, and a complete 12-month historical analysis finishes within four hours, which gives immediate visibility into current patterns while the historical scan builds your baseline. Use this initial data to establish pre-AI baselines for deployment frequency, lead time, change failure rate, and 30-day rework rate segmented by repository and team. Connect my repo and start my free pilot.
Week 2: Attribution and Segmentation. Exceeds Ink starts writing line-level attestations to every new commit, which enables precise attribution. The AI Adoption Map surfaces tool-by-tool usage rates across teams. AI Usage Diff Mapping identifies which specific PRs and commits are AI-touched, down to the line. Existing DORA metrics can then be segmented by AI-touched versus human-authored code to establish an attribution baseline.
Week 3: Outcome Correlation. AI vs. Non-AI Outcome Analytics connects adoption patterns to cycle time, review iterations, defect density, and early rework signals. Best Practices Insights surfaces the top three AI-coding patterns worth scaling, sorted by confidence. Coaching Surfaces and the ink-prompting-coach skill distribute guidance directly into engineers’ Claude Code or Cursor agents, so coaching appears where the work happens instead of in a separate dashboard.
Week 4: Board-Ready Reporting. Longitudinal Outcome Tracking begins monitoring AI-touched code for 30-day and 90-day incident rates and rework patterns. The Exceeds Assistant generates board-ready ROI reports that connect AI tool spend to shipped outcomes. Engineering leaders can answer the board question about whether AI investment is paying off with commit-level evidence rather than adoption statistics.
This playbook augments DORA and SPACE instead of replacing them. It supplies the provenance layer that makes both frameworks interpretable in an era where AI writes nearly half of all committed code.
Frequently Asked Questions
Does adding AI provenance change DORA scores?
Provenance tracking does not alter DORA scores, it contextualizes them. A team’s deployment frequency, lead time, change failure rate, and mean time to recovery remain exactly what they already are. The change appears in the ability to segment those scores by AI authorship. A change failure rate of 5.1 percent looks very different when segmented data shows AI-assisted code running at 8.7 percent and human-authored code at 3.2 percent, a pattern documented in real engineering organizations. Without commit-level provenance, both failure modes are averaged together and the actionable signal disappears. Exceeds Ink writes that segmentation data alongside every commit so DORA dashboards can finally distinguish between AI-driven instability and human-driven instability.
Why do DORA metrics look stable even when AI code quality is degrading?
DORA’s change failure rate reflects test-gate sophistication rather than underlying code quality in AI-heavy environments. Elite teams’ CI gates absorb many AI-generated defects before production, which keeps change failure rate flat while incidents per PR rise substantially, matching the incident-per-PR spike mentioned earlier. The rework rate metric added in DORA 2024 and 2025 captures some of this signal, yet it still misses pre-production in-repo churn, the code that is quietly rewritten or replaced within 14 to 30 days without ever triggering a production incident. Only longitudinal commit-level tracking anchored to AI provenance captures that pattern before it becomes a production crisis.
What do SPACE and DevEx add beyond DORA, and where do they still fall short?
SPACE and DevEx frameworks add the human dimension that DORA omits, including developer satisfaction, cognitive load, flow state, review burden, and friction in the development environment. These signals act as genuine leading indicators, as teams with high Developer Experience Index scores show 4 to 5 times higher performance across speed, quality, and engagement metrics, and each one-point DXI improvement saves approximately 13 minutes per developer per week. The DX Core 4 framework, tested with over 300 organizations, has produced up to 12 percent improvements in engineering efficiency. Both DORA and SPACE still fall short on attribution because neither framework can connect a developer’s satisfaction score or a team’s deployment frequency to the specific AI tool, interaction mode, or session that produced the code in question. That attribution gap means neither framework can confirm whether AI caused an improvement or a degradation, and they can only record that a change occurred.
How does Exceeds AI handle teams using multiple AI coding tools simultaneously?
Exceeds Ink uses per-tool checkpoint materializers for Claude Code, Cursor, and Codex, with dedicated adapters for GitHub Copilot and Windsurf, plus lighter-weight detection across up to approximately 50 AI tools. Each materializer resolves edit evidence against the actual working tree at commit finalization, so a multi-edit Cursor session correctly retains human-typed lines and a Claude Code rewrite is attributed to Claude, not averaged together or guessed from heuristics. The result is a cross-tool outcome comparison where leaders can see whether Cursor agent-mode code has a different 30-day rework rate than Copilot autocomplete code in the same repository, and whether one team’s Claude Code usage pattern produces better outcomes than another team’s pattern. That comparison is not possible with single-vendor telemetry or metadata-only platforms, and it forms the foundation for the multi-tool AI ROI proof that boards and CFOs are requesting in 2026.
Is commit-level AI provenance a surveillance tool?
Exceeds AI is built for coaching and enablement, not surveillance. The distinction appears in how the data is used and who benefits from it. Exceeds Ink’s attestation data powers Coaching Surfaces that give engineers prescriptive guidance inside their own Claude Code or Cursor agents, so engineers receive personal insights and AI-powered coaching that improves their work rather than simply monitoring it. The ink-prompting-coach skill installs directly into the developer’s own agent as a SKILL.md and slash command, which means coaching appears where the work happens. Privacy is configurable along four rungs, from local-only, where nothing leaves the machine, to full identified replay with verbatim data by explicit approval, and different teams in the same organization can run at different privacy levels. The goal is to identify what works and scale it across the organization, not to police individual engineers.
Conclusion: Commit-Level Provenance as the 2026 Leadership Layer
DORA metrics remain the most rigorous framework available for measuring system-level delivery performance. SPACE and DevEx remain the most rigorous frameworks available for measuring developer experience and workflow friction. Both frameworks are necessary. Both remain incomplete in an era where AI writes nearly half of all committed code, code churn has more than doubled from its pre-AI baseline, and incidents per PR have risen nearly 250 percent while change failure rate stays flat.
Commit-level AI provenance fills that gap. Without it, DORA dashboards show deployment frequency and lead time without revealing whether those numbers reflect genuine value delivery or AI-generated boilerplate. SPACE surveys show cognitive load and satisfaction without revealing whether a team’s frustration stems from reviewing AI-generated code that does not fit project conventions. Neither framework can tell a VP of Engineering which AI tool produced the code that caused last week’s incident or which interaction mode produces the highest-quality output across the organization.
Exceeds Ink supplies that provenance layer. Exceeds AI turns it into board-ready ROI proof and prescriptive coaching surfaces. Together they form a platform that connects what an engineer typed locally in Cursor, Claude Code, Codex, GitHub Copilot, or Windsurf to the outcomes that appear in DORA and SPACE dashboards within the four-week rollout and in the 30-day and 90-day windows that follow. Connect my repo and start my free pilot.