Performance FAQs

The Git AI extension is designed to have minimal impact on the speed of git operations. The system is built in Rust for low overhead, fast execution, and minimal memory usage.

Testing Performance Yourself

You can measure Git AI's overhead on any command using the debug performance flag:

GIT_AI_DEBUG_PERFORMANCE=1 git-ai <command>

This will show you the exact overhead Git AI adds to each operation.

Overhead

Git AI adds approximately 10-20ms of overhead per git command. This overhead primarily comes from:

• Starting the Git AI process
• Parsing and routing git arguments to the underlying git binary
• Running pre/post-command hooks (when applicable)

Because Git AI is written in Rust, the overhead is minimal:

• Low memory footprint - Small binary size and efficient memory usage
• Fast startup - Quick process initialization
• No background processes - No daemons or long-running services

Scalability

How does Git AI scale with repository size?

Git AI operations scale with the size of changes (diffs), not the size of the repository. This means performance remains consistent whether you're working in a small project or a massive monorepo.

Checkpoint operations (tracking AI vs human changes):

• Scale with the number of files changed
• Independent of total repository size
• Typically complete in milliseconds

Commit operations (generating authorship logs):

• Scale with the size of the commit diff
• The slowest operation is generating the authorship log on post-commit
• Typical range: 20-300ms depending on commit size
• Most commits complete in under 100ms

Example Timing Breakdown

For a typical commit with moderate changes:

• Forwarding to git overhead: 10-20ms
• Pre-commit checkpoint: 5-15ms
• Git commit execution: (varies by repo)
• Post-commit authorship log generation: 20-100ms
• Total Git AI overhead: ~35-135ms

Git Notes Performance

Git AI stores authorship information using git notes, which sync alongside your commits. Notes have excellent performance characteristics even in large repositories.

Sync Performance

Git note merges are fast and scale linearly with the number of new notes, not total notes in the repository:

As shown in the benchmarks above, sync time remains under 15ms even with 100,000 existing notes.

Storage Considerations

Repository size impact:

• Notes are stored in git's object database
• Compressed and deduplicated like other git objects

Ref limits:

• Notes are stored in a commit tree structure, not as individual refs
• No practical limit on the number of notes
• Won't hit git's ref limits even in very large repositories

FAQs

Does Git AI slow down git operations noticeably?

For most operations, no. The 10-20ms extension overhead is imperceptible. The largest impact is during commits (20-300ms for authorship log generation), which is still fast enough to feel instant for typical workflows.

Will Git AI impact CI/CD pipelines?

Git AI adds minimal overhead to git operations in CI/CD. The extension automatically detects when it's running in non-interactive environments and optimizes accordingly. Notes sync with your normal push/fetch operations.

How much disk space do authorship logs use?

Authorship logs are very compact. For a typical repository with thousands of commits, authorship notes add less than 1% to the total repository size. Git's compression and deduplication keeps the overhead minimal.

Can Git AI handle large monorepos?

Yes. Because Git AI scales with diff size rather than repository size, it works well even in massive monorepos. Operations remain fast regardless of how many files exist in the repository.

Getting Help

If you experience performance issues with Git AI:

1. Use GIT_AI_PROFILE=1 to measure actual overhead
2. Check the reference documentation for optimization options
3. Schedule a call with the maintainers for enterprise support