Git + AI Workflows

Why Git Matters More With AI

When you code with an AI assistant, the speed-to-commit ratio changes fundamentally. A single prompt to Cursor, Copilot, or Claude can generate hundreds of lines across multiple files. Without git discipline, that code enters your project as an unauditable blob. You cannot tell what the AI changed, why it changed it, or how to undo it without losing your own work.

The developers who skip git discipline with AI end up in one of three failure modes:

• The unrevertable mess: a bulk AI generation introduced a bug somewhere in 400 lines, and there is no way to isolate the specific change without reading every line.
• The lost history: git blame shows your name on every line, but you cannot explain what half of them do because the AI wrote them in a session you barely remember.
• The merge conflict spiral: two AI sessions edited the same files on the same branch, and the conflict resolution is harder than rewriting from scratch.

Every practice in this masterclass exists to prevent those failure modes. Git is the safety net. AI is the accelerator. Without the net, the accelerator drives you into a wall.

The Core Git + AI Workflow

The Seven-Step Loop

1. Branch: create a fresh branch for the specific task you are about to ask the AI to do. Name it descriptively: feat/add-user-auth, fix/cart-total-rounding.
2. Prompt: describe the task to your AI coding assistant (Cursor, Copilot, Claude, aider). Be specific about the scope.
3. Review the diff: before touching git, read what the AI generated. If you cannot explain a block of code, do not commit it.
4. Stage atomically: stage only the files for one logical change. If the AI generated a model, a service, and a handler, make three separate commits.
5. Commit with AI: use an AI commit message tool (aicommits, OpenCommit, or your IDE) to generate a Conventional Commits message from the staged diff.
6. Push and PR: push the branch. Open a pull request. Let an AI reviewer (CodeRabbit, Copilot) perform the first pass.
7. Human review: review the AI reviewer's comments. Approve, request changes, or iterate. Merge only when both automated and human gates pass.

The Rule of Atomic Commits

Every commit represents exactly one logical change. This rule exists because of git bisect: if a regression appears, bisect can only isolate the breaking commit if each commit contains a single concern. A commit that mixes a database migration, a UI change, and a config update cannot be bisected effectively. AI tools generate bulk code by default. Your job is to split it into atomic units before committing.

AI-Generated Commit Messages

The Conventional Commits Standard

Conventional Commits (conventionalcommits.org, spec v1.0.0) defines a structured format for commit messages that makes history readable by both humans and machines (Source: conventionalcommits.org):

<type>[optional scope]: <description>

[optional body]

[optional footer(s)]

The two mandatory types are feat (new feature, triggers a MINOR version bump) and fix (bug patch, triggers a PATCH bump). Common additional types: refactor, docs, test, ci, build, perf, style, chore. Breaking changes use a ! suffix: feat!: drop Node 18 support.

Tool Comparison

Best Practices for AI Commit Messages

• Stage small: AI commit tools produce better messages from small, focused diffs. A 1,000-line diff overwhelms the model and produces vague summaries.
• Enforce the standard: configure your tool to output Conventional Commits format. Most tools support this via a flag or config file.
• Review the draft: never push an AI-generated message without reading it. Verify the type is correct (feat vs fix vs refactor), the description is accurate, and no sensitive information leaked into the message.
• Add the "why": AI tools describe what changed (they read the diff). The why is your job. Add a body line if the motivation is not obvious from the description.

Hands-On Build

Exercise 1: Generate an AI Commit Message

# Install aicommits globally
npm install -g aicommits

# Configure with your OpenAI key
aicommits config set OPENAI_KEY=sk-your-key-here

# Configure to use Conventional Commits
aicommits config set type=conventional

# Stage a change and generate the message
git add src/auth/login.ts
aicommits

# Output example:
# feat(auth): add JWT token validation to login endpoint
#
# Use aicommits? (Y/n)

Review the generated message. If the type or description is wrong, reject it and either edit manually or re-run with a smaller staged diff. The tool reads only your staged changes, not the full repository, so atomic staging produces better results.

Exercise 2: Submit an AI-Reviewed PR

# Push your branch
git push origin feat/add-user-auth

# Open a PR on GitHub
gh pr create --title "feat(auth): add JWT token validation" \
  --body "AI-generated implementation of JWT validation middleware."

# If CodeRabbit is installed on your repo, it triggers automatically.
# If using Copilot, request a review:
# GitHub PR sidebar > Reviewers > Request from Copilot

CodeRabbit will post a summary with sequence diagrams, inline comments with severity labels, and one-click fix suggestions. Copilot provides inline comments with High/Medium/Low severity labels and groups similar comments to reduce noise (Source: GitHub Blog, 2026). Both are first-pass reviewers. Human approval is still required.

Exercise 3: Revert an AI-Generated Change

# Find the commit hash of the AI-generated change
git log --oneline -5

# Revert it (creates a new commit that undoes the change)
git revert abc1234

# In aider, the shortcut is:
# /undo
# This runs git revert on the last AI-generated commit.

# Verify the reversion
git diff HEAD~1

The key insight: git revert creates a new commit that undoes the change while preserving the full history. This is safer than git reset --hard, which destroys history. If the AI made multiple commits, revert them in reverse chronological order to avoid conflicts.

Exercise 4: Bisect an AI-Heavy History

# Start bisection
git bisect start

# Mark the current commit as bad (tests fail)
git bisect bad HEAD

# Mark a known-good commit (tests passed here)
git bisect good v1.2.0

# Automate with your test suite
git bisect run npm test

# Git performs a binary search:
# ~20 commits = ~5 test runs to find the exact breaking commit
# When done:
git bisect reset

This only works if your commits are atomic. A single bulk commit mixing 400 lines across 12 files cannot be bisected further, so the regression is somewhere in those 400 lines and you are back to reading every line. Atomic commits make bisection a 5-minute operation. Bulk commits make it a 5-hour one.

AI Code Review Tools

CodeRabbit

CodeRabbit is the most-installed AI review app on the GitHub Marketplace (Source: CodeRabbit docs, July 2026). It builds a code graph mapping cross-file dependencies, which lets it catch issues that diff-based analysis misses, like a function signature change that breaks downstream callers in files not included in the PR.

• Trigger: automatic on new PRs once installed.
• Configuration: .coderabbit.yaml in your repo root.
• Interaction: comment @coderabbitai summary, @coderabbitai help, or @coderabbitai approve on any PR.
• Pricing: free for open-source. Pro at approximately 24 to 30 dollars per user per month. Enterprise custom pricing (Source: CodeRabbit pricing, July 2026).

GitHub Copilot PR Review

Copilot's PR review uses agentic analysis: it scans the diff while pulling in broader repository context, not just the changed lines. Comments include severity labels (High, Medium, Low) and one-click fix buttons (Source: GitHub Blog and GitHub Docs, 2026).

• Trigger: request Copilot as a reviewer in the PR sidebar, or use gh pr edit --add-reviewer copilot.
• Custom instructions: define team standards in .github/copilot-instructions.md. Copilot respects these during review.
• Limitation: Copilot does not count as a mandatory human approval. Use it as a pre-filter, not a replacement for human sign-off.

Graphite

Graphite is a platform for stacked pull requests, where large features are broken into smaller, sequential, dependent PRs. After its acquisition by Anysphere (creators of Cursor) in December 2025, Graphite integrated Cursor Cloud Agents for AI-driven review (Source: Graphite docs and codeant.ai, July 2026).

• Best for: teams already using or ready to adopt stacked PR workflows on GitHub.
• CLI: gt (Graphite CLI) automates rebasing of dependent branches when a parent PR changes.
• Limitation: GitHub-only. Teams on GitLab or Bitbucket need alternatives.
• Pricing: free Hobby tier (limited AI reviews). Team tier approximately 40 dollars per user per month with unlimited AI reviews (Source: Graphite pricing, July 2026).

AI Review Tool Comparison

Branching Strategies for AI Work

Branch-Per-Ask

The branch-per-ask pattern creates a strict boundary around each AI interaction:

# One branch per AI request
git checkout -b feat/add-user-auth
# Ask the AI to implement auth
# Review, commit, push, PR

git checkout main
git checkout -b fix/cart-total-rounding
# Ask the AI to fix the rounding bug
# Review, commit, push, PR

git checkout main
git checkout -b refactor/extract-db-layer
# Ask the AI to refactor
# Review, commit, push, PR

Each branch contains exactly one intent. If the AI's implementation is wrong, delete the branch. No other work is affected. If it is right, merge it through your standard PR flow.

Experimental Branches

For rapid prototyping or R&D, use a prefix convention:

# Experimental branch for AI-driven exploration
git checkout -b exp/vector-search-approach

# Let the AI try multiple approaches
# When one works, cherry-pick the successful commits:
git checkout main
git cherry-pick abc1234 def5678

# Delete the experimental branch
git branch -D exp/vector-search-approach

What Not to Do

Reverting and Bisecting AI Changes

Reversion Strategies

Why git revert Beats git reset

git reset --hard destroys commit history. On a shared branch, this rewrites history and breaks every other contributor's local state. git revert preserves the original commit and creates a new one that undoes it. The full history remains intact, including the fact that the AI made the change and that you explicitly reversed it. For AI-generated code, this audit trail matters.

Effective Bisection

The binary search algorithm in git bisect tests approximately log2(N) commits. For 100 commits, that is roughly 7 test runs. Automate it:

# Fully automated bisection
git bisect start
git bisect bad HEAD
git bisect good v1.0.0
git bisect run npm test

# Git automatically checks out commits, runs the test,
# and marks each as good or bad based on exit code.
# Result: the exact commit that broke the build.

# Clean up
git bisect reset

AI-Assisted Root Cause Analysis

After bisect identifies the breaking commit, feed the commit diff and test failure output into an LLM for automated root cause analysis:

# After bisect finds the bad commit (abc1234):
git show abc1234 > /tmp/bad-commit.diff
npm test 2>&1 > /tmp/test-error.log

# Feed both to your local model via Ollama:
cat /tmp/bad-commit.diff /tmp/test-error.log | \
  ollama run qwen2.5-coder "Analyze this commit diff and test failure. \
  Explain the root cause and suggest a fix."

.gitignore for AI Development

What to Commit (Project Conventions)

What to Ignore (State and Artifacts)

# AI state files (session-specific, not shareable)
.aider.chat.history.md
.aider.input.history
.aider.tags.cache.v3/
.cursor/
!.cursor/rules/
.continue/
.copilot/

# Sensitive data (never version-control secrets)
.env
.env.*
*.pem
*.key
credentials.json
secrets/

# Build artifacts (save tokens, improve AI performance)
node_modules/
dist/
build/
.next/
*.log

The .cursorignore Pattern

Cursor's .cursorignore follows .gitignore syntax but controls what the AI indexes and reads during chat:

# Sensitive files (never send to LLM provider)
.env
.env.*
*.pem
credentials.json
secrets/

# Large files that waste context tokens
node_modules/
dist/
package-lock.json
yarn.lock
*.log

Review Gates for AI-Generated Code

The Three-Gate Minimum

GitHub Actions Example

name: CI Gates
on:
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
      - run: npm ci
      - run: npm test

  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
      - run: npm ci
      - run: npx eslint .

  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
      - run: npm audit --audit-level=high

Configure test, lint, and security as required status checks in your repository's branch protection rules. No PR merges without all three passing.

The AGENTS.md Context File

Create an AGENTS.md file in your repository root to give AI coding assistants explicit instructions about your project's architecture, coding standards, and patterns to avoid. Multiple tools (Cursor, Claude Code, Copilot) read this file to produce code that matches your existing codebase. This is the single most effective way to reduce the review burden on AI-generated PRs because the AI gets the context right the first time.

Frequently Asked Questions