Written by: Mark Hull, Co-Founder and CEO, Exceeds AI | Last updated: July 10, 2026
Key Takeaways
- DX, LinearB, and Swarmia rely on metadata like PR cycle times and commit volumes, so leaders lack line-level proof of AI ROI.
- None of the three platforms can attribute individual lines of code to AI tools versus human developers, which blocks clear answers to board-level AI investment questions.
- Metadata dashboards cannot track long-term AI technical debt or connect AI usage to quality outcomes at the commit and PR level.
- Proving AI ROI requires code-level provenance that ties AI authorship to longitudinal business outcomes, and current metadata solutions do not provide that data.
- Exceeds AI delivers line-level AI attribution and board-ready ROI reports; see how it closes the attribution gap.
How This Evaluation Compares DX, LinearB, Swarmia, and Exceeds AI
This comparison evaluates DX, LinearB, and Swarmia across five criteria: data sources, AI-specific visibility, actionability, setup time, and pricing model. A sixth dimension, longitudinal technical debt tracking, receives dedicated treatment because it represents the most consequential blind spot in the current generation of developer analytics platforms.
The 2025 Stack Overflow Developer Survey found that 84% of developers use or plan to use AI coding tools, with 51% using them daily. Engineering leaders operating in that multi-tool reality need analytics that match it. Metadata dashboards built before the AI era do not.
Which Platform Tracks AI Code vs. Human Code?
DX (GetDX) is now an Atlassian company and offers broad engineering intelligence coverage alongside its AI Code Insights and Agent Experience modules. Its data sources combine developer surveys, workflow metadata, and a closed-source CLI that captures AI usage signals on developer machines. All attribution data routes to DX Data Cloud, and nothing is written into your own repository. The capture model uses a three-tier approach whose weakest tier is filesystem-change heuristics, which top out at roughly 20–25% accuracy for distinguishing AI-generated from human-written lines. DX’s AI Code Insights measures developer experience with AI tools rather than the business impact of AI-generated code. Setup typically takes four to six weeks and is enterprise sales-gated, with a median ARR around $51,520 according to Vendr data.
- Data sources: Developer surveys, workflow metadata, closed-source CLI daemon
- AI-specific visibility: Usage sentiment and adoption rates, no line-level code attribution in your repo
- Actionability: Survey-based frameworks, no in-agent coaching distribution
- Setup time: Four to six weeks, consulting-heavy
- Pricing: Bespoke enterprise license, SaaS-only deployment
LinearB focuses on workflow automation and SDLC metrics such as cycle time, deployment frequency, and review latency. Its data sources are PR and CI/CD event metadata. LinearB cannot distinguish AI-generated lines from human-written lines, which means it cannot connect AI usage to code quality outcomes. Jellyfish analysis of millions of PRs from July 2024 to June 2025 found that PRs tagged with high AI use had cycle times 16% faster than tasks without AI, but that tagging required manual developer annotation, not automated attribution. LinearB faces the same dependency on voluntary tagging. Users have reported significant onboarding friction, and some have raised concerns that the data collection model feels like surveillance rather than coaching.
- Data sources: PR metadata, CI/CD events, Git commit data
- AI-specific visibility: None, cannot attribute code authorship to AI tools
- Actionability: Workflow automations, descriptive dashboards without prescriptive guidance
- Setup time: Two to four weeks with reported onboarding friction
- Pricing: Per-contributor seat model
Swarmia targets DORA metrics and developer engagement, integrating with Slack to surface notifications and nudges. Its data sources are Git metadata and work-tracking integrations. Swarmia’s own analysis found that median PR batch size grew substantially, driven by AI-generated code producing larger, less familiar diffs. Swarmia has no mechanism to attribute those diffs to specific AI tools or measure their long-term quality outcomes.
- Data sources: Git metadata, Jira, Slack
- AI-specific visibility: Limited, no AI code attribution capability
- Actionability: Slack notifications and dashboards, no prescriptive coaching
- Setup time: Fast initial setup, limited analytical depth
- Pricing: Per-seat model
See how line-level attribution answers the questions metadata dashboards cannot, and book a demo
Can These Tools Measure Long-Term AI Technical Debt?
The metadata limitation becomes a business risk when you consider long-term AI technical debt. A 2026 empirical study of 302,600 verified AI-authored commits across 6,299 GitHub repositories found that 24.2% of issues introduced by AI coding assistants survived to the latest repository revision. GitClear’s analysis of 211 million lines of code found duplicated code blocks rose eightfold in 2024 while refactoring activity dropped from 25% to under 10% of all code changes. DX, LinearB, and Swarmia cannot detect these patterns because they do not analyze code diffs.
DX measures developer sentiment about AI tools at a point in time, which means it cannot track whether AI-generated code that passed review in January caused incidents in March. LinearB faces a similar blind spot. It tracks PR cycle time and merge rate, metrics that improve when AI generates more code faster regardless of whether that code is maintainable. Multiple teams have reported an 18-month pattern: velocity gains in months one through three, integration challenges in months four through nine, and stalled delivery cycles by months sixteen through eighteen. That trajectory stays invisible to metadata-only platforms because early velocity gains hide the accumulating debt.
Swarmia’s DORA-oriented approach surfaces deployment frequency and change failure rate, but those metrics reflect outcomes after debt has already accumulated. A 2026 analysis of 8.1 million pull requests found that technical debt increases 30–41% in the year following AI tool adoption, and a peer-reviewed study found systematic remediation yields median returns of 437% over 24 months. Those returns only appear when teams detect the debt early enough to act.
How Engineering Leaders Prove AI ROI to the Board
Board-level AI ROI proof requires connecting AI tool usage to business outcomes at the commit and PR level. Metadata dashboards cannot make that connection. If an organization rolls out an AI assistant and PR velocity improves, that remains a hypothesis, not proof, because correlation is not causation when teams, priorities, and ownership change simultaneously.
DX’s pricing model requires an enterprise sales commitment before any data is visible, which makes it difficult to build a business case before the purchase. LinearB’s per-contributor pricing penalizes team growth and does not align costs to outcomes. Swarmia’s per-seat model similarly charges for headcount rather than for the insights that justify AI investment.
94% of engineering leaders report that the metrics that matter most are missing from their current measurement frameworks. The specific metric missing from DX, LinearB, and Swarmia is line-level AI authorship tied to longitudinal quality outcomes. That metric is the only data that can answer a board’s question about whether AI investments are generating returns or accumulating hidden risk.
Synthesis: Metadata Dashboards versus Code-Level Provenance
The platform descriptions above reveal a common gap: none can attribute code to AI tools at the line level. That limitation becomes critical when you compare metadata dashboards with code-level provenance in a multi-tool AI environment. DX, LinearB, and Swarmia were built for the pre-AI era. They measure what happened in the development workflow, but they cannot measure what AI contributed to it. In a May 2026 snapshot, GitHub Copilot held 29% workplace adoption share among AI coding tools while Cursor and Claude Code each held 18%. That mix creates a multi-tool environment where single-vendor telemetry or metadata aggregation produces an incomplete picture by design.
Exceeds AI addresses this gap directly through Exceeds Ink, the on-machine provenance layer that captures AI authorship across Cursor, Claude Code, Codex, GitHub Copilot, and Windsurf with line-level fidelity. Ink writes a structured attestation as a Git Note at refs/notes/exceeds-ink. The attestation is portable, auditable, and stored in your own repository rather than a proprietary cloud. Every line carries its tool, model, session, interaction mode, and timestamp. Lines that cannot be confidently attributed are recorded as unknown_lines, not silently assigned to either category.
The practical difference for teams is significant. Where DX’s proprietary cloud model, described above, creates vendor lock-in, Exceeds Ink’s Git Notes attestation travels with the repository across forks and mirrors and is readable by any Git client. Where LinearB and Swarmia show that a PR merged in four hours, Exceeds AI shows which 623 of the 847 changed lines were AI-generated by Cursor, whether those lines required additional review iterations, and whether they caused incidents 30 days later.
Exceeds AI also goes beyond measurement. Coaching Surfaces and the ink-prompting-coach skill, installed directly into Claude Code or Cursor, distribute guidance into the developer’s own workflow. When one team finds an AI usage pattern that works, Skill Transfer replicates it across the organization with version control and rollback. Best Practices Insights, backed by a LangGraph analysis pipeline, surfaces the top patterns worth scaling rather than leaving managers to interpret dashboards alone.
Pricing reflects this difference in approach. Exceeds AI charges for manager seats, not per-contributor data access, so there is no per-contributor data tax as teams grow. The Pro plan starts at $49 per manager per month under Early Partner Pricing. First insights are available within 60 minutes of GitHub authorization, and complete historical analysis completes within four hours.
Get your first AI ROI insights in 60 minutes, and book a demo
Choosing a Platform by Company Stage
The right platform depends on organizational scale and the specific questions engineering leadership needs to answer.
50–250 engineers: At this stage, AI adoption is patchy and the cost of not knowing what works is high. The priority is establishing baseline AI attribution before patterns calcify, so leaders can see which tools and workflows deserve expansion.
- Need: Multi-tool AI attribution across Cursor, Claude Code, Copilot, and Codex
- Need: Fast setup without enterprise sales cycles, measured in hours, not months
- Need: Outcome-based pricing that does not penalize team growth
- DX, LinearB, and Swarmia deliver metadata dashboards that cannot answer whether AI is working
- Exceeds AI delivers commit-level attribution and board-ready ROI reports within weeks
250–999 engineers: Once baseline attribution exists, the challenge shifts to scaling best practices without adding management headcount. At this scale, manager-to-IC ratios often stretch toward 1:8 or higher, which leaves insufficient bandwidth for code inspection. Microsoft’s ICSE 2008 research found organizational-complexity metrics including management span to be among the strongest predictors of defect-proneness. The priority becomes prescriptive guidance that scales without expanding the management layer.
- Need: Coaching Surfaces that distribute best practices without requiring manager review of every PR
- Need: Longitudinal outcome tracking to detect AI technical debt before it reaches production
- Need: Multi-tool aggregate visibility across the full AI toolchain
- LinearB’s workflow automations and Swarmia’s DORA metrics do not address AI-specific coaching or debt tracking
- Exceeds AI’s ink-prompting-coach and 30-day outcome monitoring address both
1,000+ engineers: At this scale, governance, compliance, and audit requirements become primary. The question shifts from whether AI is working to whether the organization can prove it to regulators, auditors, and legal counsel.
- Need: Auditable, machine-readable AI authorship records that survive outside the analytics vendor’s platform
- Need: Policy enforcement at the commit level, including the ability to block deploys when AI authorship exceeds a threshold in sensitive paths
- Need: Self-host deployment option for data residency requirements
- DX’s proprietary DX Data Cloud model creates vendor lock-in, and nothing lives in your repository
- Exceeds Ink’s Git Notes attestation is portable, auditable, and self-hostable
Frequently Asked Questions
Does Exceeds AI require full repository access, and how is that data handled?
Exceeds AI requires read-only repository access to perform code-level AI attribution. For cloud customers, repositories exist on servers for seconds and are permanently deleted after analysis, and only commit metadata and snippet information persists. No permanent source code storage occurs. Code is fetched via API only when needed and is never cloned after onboarding. Data is encrypted at rest and in transit, SSO/SAML is supported, and a self-hosted deployment option is available for organizations requiring analysis within their own infrastructure. Exceeds AI has passed enterprise security reviews including a formal two-month evaluation at a Fortune 500 retailer.
How does Exceeds AI handle false positives in AI detection?
Exceeds Ink uses a multi-signal approach anchored in client-level capture rather than post-hoc heuristics. Per-tool checkpoint materializers for Claude Code, Cursor, and Codex resolve edit evidence against the actual working tree at commit finalization, which protects human-typed lines from being misattributed to AI. Lines that cannot be confidently attributed are recorded as unknown_lines rather than assigned to either category. This conservative approach means the attribution data that reaches the platform is reliable enough to base board-level ROI reporting on, not an estimate subject to 20–25% heuristic error rates.
Can Exceeds AI work alongside existing platforms like LinearB or Swarmia?
Exceeds AI is designed to complement existing developer analytics platforms rather than replace them. LinearB and Swarmia continue to provide traditional SDLC metrics such as cycle time, deployment frequency, and review latency. Exceeds AI adds the AI-specific intelligence layer those platforms cannot deliver: which lines are AI-generated, by which tool, in which interaction mode, and what the long-term quality outcomes are. Most customers run Exceeds AI alongside their existing stack, integrating with GitHub, GitLab, Azure DevOps, Jira, and Linear.
How long does it take to see meaningful data after connecting a repository?
As noted in the platform comparison, first insights appear within 60 minutes of GitHub or GitLab authorization, with complete historical analysis, covering up to 12 months of commit history, finishing within four hours. Real-time updates appear within five minutes of new commits. This timing contrasts with DX’s four-to-six-week enterprise onboarding and Jellyfish’s commonly reported nine-month time-to-ROI. The Pilot plan is free for seven days and covers up to 10 contributors and five repositories, which allows engineering leaders to validate the platform against their own codebase before any purchase commitment.
What happens when engineers use multiple AI tools on the same codebase?
Exceeds Ink is tool-agnostic by design. Five first-class adapters with deep per-tool fidelity cover Claude Code, Cursor, Codex, GitHub Copilot, and Windsurf, with lighter-weight detection across up to approximately 50 AI tools. When an engineer uses Cursor for feature development and Claude Code for refactoring within the same sprint, Ink attributes each contribution to the correct tool and session. The Exceeds AI platform then surfaces aggregate AI impact across the full toolchain alongside tool-by-tool outcome comparisons, so leaders see not just whether AI is working but which tools drive the best results for specific types of work.
Conclusion
DX, LinearB, and Swarmia each serve legitimate purposes within the pre-AI developer analytics stack. DX measures developer experience and sentiment. LinearB improves SDLC workflow metrics. Swarmia tracks DORA indicators and team engagement. None of them can answer the question that engineering leaders face in 2026: which lines of code AI wrote, whether those lines improve or degrade quality over time, and what the measurable return on AI investment is.
DX’s own longitudinal study across more than 400 engineering organizations found that a 65% average increase in AI tool usage produced a median 8% increase in PR throughput, which falls well below the productivity gains most organizations expect. Closing the gap between expectation and reality requires code-level attribution, not metadata aggregation.
Exceeds AI, powered by Exceeds Ink, is the only platform that delivers line-level AI provenance across the full multi-tool AI coding environment, connects that provenance to longitudinal quality outcomes, and translates both into board-ready ROI proof and prescriptive manager guidance. Setup takes hours. First insights arrive within 60 minutes. Board-ready reports are available within weeks.