Developer Install

Coding agent telemetry — prompts, session traces, AI authorship data — exists on developer machines. Installing Git AI on every developer laptop enables collection of this telemetry from every agent session automatically.

There are two ways to distribute Git AI to developers:

• Share an install link — best for PoCs and small teams
• Distribute via MDM — best for enterprise-wide rollouts

For a proof-of-concept evaluation, start with an install link for the first 10–20 engineers. Switch to MDM distribution when rolling out to the full organization.

Share an Install Link

Best for PoCs and small teams.

Log in to the Git AI dashboard and click Invite Developers on the Contributors page. This generates a permanent invite URL that can be shared in a document, email, Slack message, or any other channel.

When a developer opens the link:

1. The developer authenticates with GitHub, GitLab, or Bitbucket
2. Git AI verifies the developer is a member of the connected SCM organization
3. A unique, one-time install command is generated for that developer

The install command configures Git AI and sets up agent hooks on the developer's machine. Once complete, telemetry from every supported coding agent begins flowing to the dashboard.

Distribute via MDM

Best for enterprise rollouts.

For large-scale deployments, use an MDM (Mobile Device Management) solution to install Git AI across the organization without requiring each developer to run a manual install.

How the Extension Works

Git AI is a git extension that maintains accurate AI authorship tracking with Git Notes. Key properties of the extension:

• Single binary — no per-repository configuration required
• Transparent interception — developers use git commands as normal
• No repository modification — does not change .git/hooks in any repository
• Easy updates — replace the binary to update all installations

When Git AI is installed, calls to git are intercepted by the git-ai binary and routed to the original git. The stdio and exit code are piped back to the caller, making the interception transparent. Git AI updates AI authorship depending on the command being executed:

• git commit — attaches an AI authorship Git Note to the commit
• git stash — stashes the working AI authorship log so it can be restored when the stash is applied
• git rebase — updates AI authorship of the resulting commits to accurately reflect the authorship of code in the rebased history

Requirements

Installation Steps

Reference install scripts are available:

• Unix/Linux/macOS: install.sh
• Windows: install.ps1

There are two placement strategies for the binary.

Option A: User-Scoped Directory

Unix/Linux/macOS

• Install the git-ai binary to $HOME/.git-ai/bin/git-ai
• Create symlinks in that directory:
  • git → git-ai
  • git-og → /path/to/original/git
• Ensure executability: chmod +x $HOME/.git-ai/bin/git-ai
• macOS only: remove the quarantine attribute (xattr -d com.apple.quarantine $HOME/.git-ai/bin/git-ai)

Windows

• Install the binary to %USERPROFILE%\.git-ai\bin\git-ai.exe
• Create a copy %USERPROFILE%\.git-ai\bin\git.exe (copy of git-ai.exe)
• Create a batch file %USERPROFILE%\.git-ai\bin\git-og.cmd that calls the original git executable
• Unblock the downloaded files (PowerShell: Unblock-File)

Option B: Overwrite an Existing Git Symlink

Use this when the fleet already exposes git from a shared directory locked into PATH (for example /usr/local/bin/git). Pick a writable directory — macOS SIP prevents modifying /usr/bin.

Unix/Linux/macOS

1. Locate the distributed git entry and its directory:

   git_path="$(command -v git)"
   git_dir="$(dirname "$git_path")"

2. Preserve the original git binary:
   • If git_path is a symlink: sudo ln -sf "$(readlink "$git_path")" "$git_dir/git-og"
   • If it is a regular file: sudo mv "$git_path" "$git_dir/git-og"
3. Install the extension alongside it: sudo install -m 0755 /path/to/git-ai "$git_dir/git-ai"
4. Point git at the extension: sudo ln -sf "$git_dir/git-ai" "$git_path"
5. Confirm that "$git_dir/git-og" remains executable — Git AI delegates to it.

Windows

1. Resolve the shim exposed on PATH (Git for Windows usually surfaces C:\Program Files\Git\cmd\git.exe):

   $gitPath = (Get-Command git).Source
   $gitDir = Split-Path $gitPath

2. Preserve the original git executable:

   if ((Get-Item $gitPath).Attributes -band [IO.FileAttributes]::ReparsePoint) {
       $target = (Get-Item $gitPath).Target
       New-Item -ItemType SymbolicLink -Path (Join-Path $gitDir 'git-og.exe') -Target $target | Out-Null
       Remove-Item $gitPath
   } else {
       Rename-Item -Path $gitPath -NewName 'git-og.exe'
   }

3. Copy the extension into the same directory:

   Copy-Item -Path 'C:\path\to\git-ai.exe' -Destination (Join-Path $gitDir 'git-ai.exe')

4. Replace git.exe with a link to the extension (requires Developer Mode or elevated privileges). If symlinks are disabled, copy git-ai.exe to git.exe instead.

   New-Item -ItemType SymbolicLink -Path (Join-Path $gitDir 'git.exe') -Target (Join-Path $gitDir 'git-ai.exe')

   # Fallback when symlinks are unavailable
   Copy-Item -Path (Join-Path $gitDir 'git-ai.exe') -Destination (Join-Path $gitDir 'git.exe')

5. Verify that git-og.exe is still runnable: & (Join-Path $gitDir 'git-og.exe') --version

This method keeps the rest of PATH untouched and ensures existing automation continues to call git while Git AI intercepts the command.

PATH Configuration

Unix/Linux/macOS:

• Option A: add $HOME/.git-ai/bin to the beginning of PATH
• Option B: confirm the directory containing git already precedes other Git installations so the new symlink wins
• Update the appropriate shell config file (.zshrc, .bashrc, etc.) when PATH changes are required

Windows:

• Add %USERPROFILE%\.git-ai\bin to the System PATH
• Position the directory before any existing Git installation directories so the git-ai extension takes precedence

Configuration File

Create $HOME/.git-ai/config.json (or %USERPROFILE%\.git-ai\config.json on Windows) with organization settings. Always set git_path to the location of the preserved original binary (git-og). See Enterprise Configuration for the full option reference.

{
    "git_path": "/path/to/git-og",
    "ignore_prompts": false,
    "allow_repositories": [
        "https://github.com/yourorg/*"
    ]
}

For Option A, git_path typically points to $HOME/.git-ai/bin/git-og. For Option B, use the absolute path of the preserved binary (for example /usr/local/bin/git-og on macOS/Linux or C:\\Program Files\\Git\\cmd\\git-og.exe on Windows).

Hook Installation

After installing the binary and configuring PATH, run:

git-ai install-hooks

This sets up integration with supported IDEs and AI coding agents (Cursor, VS Code with GitHub Copilot, etc.).

Custom Install Scripts

The official install scripts serve as a reference for building organization-specific installers:

• Unix/Linux/macOS: install.sh
• Windows: install.ps1

These scripts handle edge cases including original git path detection, recursive installation prevention, error handling, and permission setup.

Verification

After installation, verify the setup:

# Should show git-ai extension
which git

# Should show git-ai version
git --version

# Should show original git
git-og --version

Tracking Installation

The Contributors tab in the Git AI dashboard shows the status of every developer across the organization:

• Sign-up status — whether each developer has installed Git AI, filtered by "Signed Up", "Not Signed Up", or "All Contributors"
• Agent integrations — which coding agents are installed and collecting telemetry (e.g. Cursor, Claude Code, GitHub Copilot)
• Installation errors — any failures encountered during setup appear here with diagnostic details

If a developer encounters an installation error, the Git AI team helps debug the issue and carries learnings forward to the MDM installer configuration so the same problem does not affect other engineers.