How to Get Quick AI Code Insights on Any GitHub Repo
Written by: Mark Hull, Co-Founder and CEO, Exceeds AI | Last updated: July 1, 2026
Key Takeaways for Fast, Trustworthy AI Code Analytics
Engineering leaders need line-level AI authorship data, not just metadata, to prove ROI to the board and coach teams effectively.
Exceeds AI connects to any GitHub repo via OAuth and delivers first AI attribution insights within 60 minutes using Exceeds Ink for provenance capture.
Per-tool adapters for Cursor, Claude Code, Codex, GitHub Copilot, and Windsurf provide accurate attribution across the multi-tool reality most teams face in 2026.
Longitudinal outcome tracking over 30-plus days shows AI impact on cycle time, rework, incidents, and technical debt beyond initial commit metrics.
This process requires three things: GitHub repository access with sufficient permissions to authorize an OAuth integration, active use of at least one AI coding tool (Cursor, Claude Code, Codex, GitHub Copilot, or Windsurf), and willingness to grant scoped read-only repository permissions to Exceeds AI.
A few expectations help avoid surprises. Exceeds Ink installs per-repo, not globally, so it does not interfere with other repositories or tools on the same machine. Because it uses standard Git hooks rather than replacing system binaries, it does not mutate global git configuration, does not shim the git binary on PATH, and does not run a long-lived daemon on developer machines. This hook-based approach means capture happens only when you commit to an enrolled repository, not as continuous background monitoring. The entire onboarding cycle of OAuth authorization, repository scoping, and Ink installation on developer machines completes in under an hour for most teams. First insights appear within the hour mentioned above, and a complete historical analysis of up to 12 months of commit history completes within 4 hours.
This process fits engineering teams of 50 to 500 engineers that use one or more AI coding tools and need to prove ROI, manage technical debt, or scale adoption across teams.
Step 1: Connect Your GitHub Repository for Read-Only Analysis
This step authorizes Exceeds AI to read repository history and commit metadata via GitHub OAuth. Navigate to exceeds.ai, complete the GitHub OAuth flow, and select the repositories to analyze. Scoped read-only permissions are all that is required. Exceeds AI fetches code via API only when needed for analysis, repositories are never cloned after onboarding, and source code does not persist on Exceeds servers after analysis completes.
Success at this step looks like the repository appearing in the Exceeds AI dashboard with commit history visible, which confirms that OAuth authorization succeeded. Once visible, the platform automatically begins background ingestion of historical data, giving you the first signal that analysis is underway.
Workflow note: For teams with multiple repositories, start with one high-activity repo where AI tool adoption is already known to be active. This approach produces the fastest first-insight cycle and gives the team a concrete baseline before scaling to the full repository set.
With repository access authorized, the next step is to enable real-time AI attribution capture on developer machines. Exceeds Ink is a single lightweight Rust binary that captures AI authorship at the moment of commit, writing a structured attestation as a Git Note at refs/notes/exceeds-ink. It installs per-repo via standard Git hooks (prepare-commit-msg, post-commit, post-rewrite) and exits after each hook fires, which means there is no always-on process consuming resources, no PATH modification that could conflict with other tools, and no global git configuration change that affects repositories outside the enrolled set.
Installation involves running the Ink installer on each developer machine that uses an AI coding tool, then enabling the hook for the target repository. The installer is available for macOS, Linux, and Windows. On Windows, Ink does not replace git.exe, which matters for security teams running EDR or AppLocker policies.
Success at this step looks like the Machine Integration Health dashboard in Exceeds AI showing hooks as installed and adapters as wired up for each enrolled machine.
This installation model matters because it avoids the accuracy problems that plague heuristic-only tools and sets up the client-level capture described below.
Common mistake: false-positive heuristics. Tools that rely on code-pattern analysis or watermark scanning to detect AI authorship top out at roughly 20–25% accuracy by Exceeds’ own assessment. They cannot distinguish a thoughtful multi-turn Claude Code session from a single autocomplete suggestion. Ink replaces that guesswork with client-level capture, observing what actually happens on the developer’s machine at commit time and recording the tool, model, session, interaction mode, and token cost. Lines that cannot be confidently attributed are recorded as unknown_lines, not silently assigned to “human” or “AI.”
Step 3: Enable Per-Tool Adapters for Your AI Coding Stack
Exceeds Ink ships five first-class adapters with dedicated checkpoint materializers for Claude Code, Cursor, and Codex. These materializers resolve edit evidence against the actual working tree at commit finalization, so multi-edit Cursor sessions correctly retain human-typed lines and Claude Code rewrites are attributed to Claude. GitHub Copilot and Windsurf adapters use native hooks and code-pattern signals. Lighter-weight detection covers up to approximately 50 additional AI tools.
Enabling adapters is a per-tool configuration step in the Ink installer. For each AI coding tool active on a developer’s machine, select the corresponding adapter. No changes to the AI tool itself are required.
Success at this step looks like the Exceeds AI dashboard showing per-tool attribution in the AI Adoption Map, with distinct signals for each active tool.
Actionable insights to improve AI impact in a team.
This per-tool visibility addresses a reality most engineering leaders face but few analytics platforms acknowledge.
Pro tip: multi-tool reality. Most engineering teams in 2026 do not use a single AI coding tool. Engineers reach for Cursor for feature development, Claude Code for large-scale refactoring, Codex for batch transforms and headless workflows, GitHub Copilot for inline autocomplete, and Windsurf for specialized tasks. A platform that only reads telemetry from one vendor goes dark the moment an engineer switches tools. Ink’s per-tool adapters produce an aggregate view across the entire toolchain, so the ROI number the board sees reflects actual usage, not one vendor’s slice of it.
Step 4: Run Initial Historical Analysis on Existing Commits
With repository access authorized and Ink hooks installed, Exceeds AI automatically begins a historical analysis of existing commit history. This process runs in the background and does not require developer action. For most repositories, a 12-month historical analysis completes within about 4 hours.
The historical analysis applies Ink’s attribution model retroactively to existing commits using available signals such as commit message analysis, code pattern signals, and any Git Notes already present in the repository. Commits made before Ink was installed have lower attribution confidence than commits made after installation, and the dashboard surfaces confidence levels per commit so you can see that distinction clearly.
Success at this step looks like the AI Usage Diff Mapping view showing historical AI-touched commits highlighted at the line level, with per-tool attribution where signals are sufficient.
Exceeds AI Impact Report with PR and commit-level insights
Security review questions often surface during this phase because repository access and code handling move from theory to practice.
Troubleshooting: security-review blockers. The most common blocker at this step is an IT security review requirement before granting repository access. Exceeds AI is designed to pass enterprise security review. Source code exists on Exceeds servers for seconds during analysis and is permanently deleted afterward, and only commit metadata and snippet information persists. Data is encrypted at rest and in transit, SSO and SAML are supported, and an in-SCM deployment option is available for teams that cannot transfer code outside their own infrastructure. Exceeds AI founder Mark Hull used Claude Code to develop three workflow tools totaling around 300,000 lines of code at a token cost of approximately $2,000, which illustrates the kind of token-spend governance question that security and finance teams now ask and that Ink is built to answer. Detailed security whitepapers are available as part of any evaluation.
Step 5: Review Line-Level AI Authorship and Outcomes
The AI Usage Diff Mapping view shows exactly which lines in each commit and PR are AI-generated, which tool produced them, and in which interaction mode (plan, ask, agent, edit, or headless). The AI vs. Non-AI Outcome Analytics view connects those attributions to outcomes such as cycle time, review iterations, rework rates, test coverage, and, for commits older than 30 days, incident rates and follow-on edit patterns.
At this step, engineering managers can see which teams use AI effectively, combining stable quality with productivity gains, and which teams show elevated rework rates or spiky commit patterns that indicate context-switching disruption. Ink’s interaction-mode classification turns these patterns into specific coaching opportunities. A high proportion of agent-mode commits without a preceding plan phase becomes a concrete coaching pattern, not just a metric.
Success at this step looks like the dashboard showing per-team, per-tool AI adoption rates with outcome correlations, and the Exceeds Assistant surfacing root-cause explanations for anomalies.
Exceeds AI Repo Leaderboard shows top contributing engineers with trends for AI lift and quality
This is also the point where short-term metrics can mislead leaders if they do not account for longer-term effects.
Watchout: misinterpreting short-term metrics. AI-generated code that looks clean and passes initial review can contain subtle bugs or architectural misalignments that only surface 30, 60, or 90 days later. A team showing fast cycle times and high AI adoption in week one may be accumulating technical debt that appears in incident rates two sprints later. Longitudinal Outcome Tracking in Exceeds AI monitors AI-touched code over 30-plus days for incident rates, rework patterns, and maintainability signals. Leaders should avoid drawing conclusions about AI ROI from the first week of data alone.
Step 6: Generate Board-Ready ROI Reports and Coaching Surfaces
With line-level attribution and outcome data in place, Exceeds AI generates two categories of output: board-ready ROI reports for engineering leaders and Coaching Surfaces for engineering managers.
ROI reports quantify AI impact at the commit and PR level. They can show, for example, that GitHub Copilot contributed to 58% of all commits with an 18% correlated lift in team productivity, or that Cursor-assisted PRs in a specific subsystem show three times lower rework rates than the team average. These examples illustrate how the reports connect AI adoption directly to business metrics in a format suitable for executive and board presentation.
Exceeds AI Impact Report shows AI code contributions, productivity lift, and AI code quality
Coaching Surfaces translate the same data into prescriptive guidance for managers. The ink-prompting-coach skill installs directly into the developer’s own Claude Code or Cursor agent as a SKILL.md and slash command, which delivers coaching where the work happens rather than in a separate dashboard. Best Practices Insights distill the team’s actual AI-coding patterns into the top skills worth scaling across the organization. When a pattern that works on one team is identified, Skill Transfer distributes it as a versioned skill org-wide, with rollback available if it does not land.
Success at this step looks like at least one board-ready ROI report generated, at least one Coaching Surface distributed to a manager or team, and ink-prompting-coach installed in at least one developer’s AI agent.
Validation and Success Criteria Across the Rollout
The indicators below confirm that the end-to-end process has completed successfully and continues to function.
Within 60 minutes of completing Step 1, the Exceeds AI dashboard shows first AI attribution data for the connected repository, with per-tool breakdown visible in the AI Adoption Map.
Within 4 hours of completing Step 4, the historical analysis is complete, AI vs. Non-AI Outcome Analytics shows baseline outcome comparisons, and the Exceeds Assistant can answer questions about historical patterns.
On an ongoing basis, new commits receive real-time attribution within about 5 minutes of push, interaction-mode classification is visible per session, and token cost per agent and model is reported in the dashboard.
The commit-level AI versus human distinction, stored as an auditable Git Note in the repository rather than as an estimate or heuristic, is the artifact that makes every downstream claim provable. That attestation lives in the repository, travels across forks and mirrors, and is readable by any Git client. It survives outside the Exceeds platform entirely.
Advanced Considerations and Next Steps for Scaling
Once the process is validated on a single repository, scaling follows a straightforward path. Add additional repositories through the Exceeds AI dashboard using the same OAuth authorization. Extend Ink installation to additional developer machines and use the Machine Integration Health view to track rollout completeness. For organizations using Azure DevOps or GitLab in addition to GitHub, Exceeds AI supports all three source-code hosts with the same per-repo opt-in model.
Teams that want to pipe Ink’s provenance data into their own data warehouse or BI tools can run Ink standalone and export Git Notes attestations directly. The structured JSON schema at refs/notes/exceeds-ink fits naturally into policy engines and internal developer platform scorecards.
Board reporting cadence typically stabilizes within two to four weeks of initial setup, once longitudinal outcome data begins accumulating. The combination of commit-level attribution and 30-plus-day outcome tracking turns a one-time ROI snapshot into an ongoing governance capability that can answer questions about AI technical debt, token spend efficiency, and adoption patterns as they evolve.
Adjacent topics worth exploring after completing this process include scaling Best Practices Insights across multiple teams, connecting Ink’s token-cost data to engineering budget reporting, and using interaction-mode classification to refine coaching playbooks for specific AI tools.
Frequently Asked Questions About Running Ink in Production
What happens if a developer uninstalls Ink after it has been running for a month?
Historical attribution data remains intact. Ink writes attribution data as Git Notes at refs/notes/exceeds-ink, which live in the repository itself. Even if a developer uninstalls the Ink binary, the Git Notes remain in the repository and can be read by any Git client or re-ingested by Exceeds AI. The attribution record is portable and survives outside the Exceeds platform entirely.
Can Exceeds AI attribute code written in a pair-programming session where one engineer uses an AI tool and the other types manually?
Yes, within the limits of the signals available on the machine where Ink runs. Ink captures AI interactions and resulting edits on the enrolled machine. If one engineer drives the session on a machine with Ink and an active adapter, AI-generated edits from that tool are attributed to the tool and interaction mode, while manually typed lines remain human-authored. If both engineers commit from separate machines, each machine’s Ink installation captures its own AI usage, and the combined Git history reflects both contributors.
How does Ink handle rebases, squash merges, or other git operations that rewrite commit history?
Ink stores attestations as Git Notes keyed to commit hashes, so history rewrites require careful handling. During operations such as rebases or squash merges, the post-rewrite hook allows Ink to remap notes from old commits to new ones where possible. When commits are squashed into a single commit, Ink aggregates the underlying attestations into a combined note for the new commit. This behavior preserves as much attribution fidelity as Git’s rewritten history allows.
How does Exceeds AI handle false positives in AI detection, and what happens to lines it cannot confidently attribute?
As described in Step 2, Ink uses client-level capture via per-tool hooks rather than heuristics. The key distinction lies in how ambiguous signals are handled. Lines that cannot be confidently attributed, either because the tool lacks a first-class adapter or because the signal is ambiguous, are recorded as unknown_lines instead of being forced into “human” or “AI” buckets. This conservative default keeps reported attribution trustworthy rather than inflated.
How is Exceeds AI different from GitHub Copilot’s built-in analytics or other metadata-only tools?
GitHub Copilot Analytics reports acceptance rates and lines suggested, which are usage statistics from one vendor’s telemetry. It cannot show whether Copilot-touched code has higher defect rates 60 days later, which engineers use Copilot effectively versus struggling, or what happens in the large share of commits produced by Cursor, Claude Code, or other tools. LinearB and Jellyfish show PR cycle times and commit volumes but remain blind to which lines are AI-generated versus human-authored, which makes it impossible to connect AI adoption to business outcomes. Exceeds AI analyzes code diffs at the commit and PR level, attributes every line to a specific tool, model, session, and interaction mode via Exceeds Ink’s Git Notes attestation, and tracks those lines longitudinally for outcome signals that only emerge 30 or more days after merge. The result is a provable, auditable record of AI ROI rather than an estimate derived from metadata.
Conclusion: Turn AI Spend into Proven ROI
The process above delivers authoritative AI code insights on any GitHub repository in under an hour. The foundation is Exceeds Ink’s Git Notes attestation, a portable, machine-readable, line-level record of which AI tool wrote which code, in which mode, at what token cost, and what happened to that code over the following 30-plus days.
For engineering managers at 50-to-500-engineer companies, this approach closes the gap between knowing AI tools are being used and being able to prove they are working. It replaces heuristic guesswork with client-level capture, replaces metadata dashboards with commit-level outcome analytics, and replaces generic coaching with interaction-mode-calibrated guidance delivered directly into the developer’s own AI agent.
The board question, “Is our AI investment paying off?” gains a provable answer, and setup takes hours, not months.
