Skip to main content

Version Control & Git

Version control is essential for any development project, especially when working with AI coding assistants. Git helps you track changes, collaborate with others, and safely experiment with AI-generated code.

Why Git Matters for AI-Assisted Development​

When working with AI coding tools, Git becomes even more important:

  • Track AI-generated changes and understand what was modified
  • Safely experiment with AI suggestions without fear of losing working code
  • Collaborate effectively when team members use different AI tools
  • Review AI contributions through proper commit history
  • Rollback problematic AI-generated code quickly
info

AI can generate code quickly, but Git ensures you can always return to a working state if something goes wrong.

Git Fundamentals​

Basic Workflow​

  1. Initialize Repository

    git init
    # or clone existing repository
    git clone https://github.com/username/repository.git

  2. Stage Changes

    # Stage specific files
    git add filename.js

    # Stage all changes
    git add .

    # Stage interactively
    git add -p

  3. Commit Changes

    # Commit with message
    git commit -m "Add user authentication feature"

    # Commit with detailed message
    git commit -m "Add user authentication

    - Implement JWT token generation
    - Add password hashing with bcrypt
    - Create login/logout endpoints
    - Add authentication middleware"

  4. Push to Remote

    git push origin main

Best Practices for AI-Assisted Development​

Commit Messages for AI Work​

Good commit messages for AI-generated code:

# Clear about AI assistance
git commit -m "AI: Generate user authentication system

- Used Cursor to create login/register endpoints
- Generated JWT middleware and password hashing
- Added TypeScript types for user model
- Reviewed and tested all generated code"

# Specific about changes
git commit -m "Refactor API routes with AI assistance

- Used Claude to modernize Express route handlers
- Converted callbacks to async/await
- Added proper error handling
- Maintained backward compatibility"

Branching Strategy for AI Experiments​

Feature branches for AI work:

# Create branch for AI-generated feature
git checkout -b feature/ai-user-auth

# Work with AI to implement feature
# Test and review generated code

# Merge when satisfied
git checkout main
git merge feature/ai-user-auth

Experimental branches:

# Try different AI approaches
git checkout -b experiment/ai-refactor-v1
git checkout -b experiment/ai-refactor-v2

# Compare results and choose the best approach

Reviewing AI-Generated Code​

Use Git to review changes:

# See what AI changed
git diff

# Review specific files
git diff HEAD~1 src/auth.js

# See commit history
git log --oneline

# Review changes in detail
git show commit-hash

Advanced Git Techniques​

Interactive Staging​

When AI generates multiple changes, stage them selectively:

# Review and stage changes interactively
git add -p

# This allows you to:
# - Review each change individually
# - Stage only the parts you want
# - Skip problematic AI suggestions

Stashing AI Work​

Save AI-generated work while switching contexts:

# Save current AI work
git stash push -m "AI-generated user dashboard components"

# Switch to different task
git checkout other-branch

# Return and restore AI work
git checkout main
git stash pop

Cherry-Picking AI Solutions​

Apply specific AI-generated commits to other branches:

# Apply specific AI solution to current branch
git cherry-pick commit-hash

# Apply multiple commits
git cherry-pick commit1 commit2 commit3

Collaboration with AI Tools​

Team Workflows​

When multiple team members use AI:

  1. Establish conventions for marking AI-generated code
  2. Review AI contributions more carefully in pull requests
  3. Document AI tool usage in commit messages
  4. Share successful prompts and techniques

Example team workflow:

# Branch naming convention
feature/ai-{tool-name}-{feature}
# Example: feature/ai-cursor-authentication

# Commit message format
{AI-TOOL}: {Description}
# Example: CURSOR: Generate React components for user dashboard

Code Review Process​

Reviewing AI-generated pull requests:

  1. Understand the prompt that generated the code
  2. Test functionality thoroughly
  3. Check for security issues and best practices
  4. Verify code style consistency
  5. Ensure proper documentation

Review checklist for AI code:

  • Code works as intended
  • Follows project conventions
  • Includes proper error handling
  • Has adequate test coverage
  • No security vulnerabilities
  • Performance is acceptable
  • Documentation is updated

Git Worktrees for AI Development​

Git worktrees allow you to work on multiple parts of your codebase simultaneously:

# Create worktree for AI experiment
git worktree add ../project-ai-experiment experiment/ai-refactor

# Work in the new directory
cd ../project-ai-experiment

# Use AI tools to experiment
# Changes are isolated from main working directory

# When done, remove worktree
git worktree remove ../project-ai-experiment

Benefits for AI development:

  • Parallel experimentation with different AI approaches
  • Safe testing without affecting main codebase
  • Easy comparison between AI-generated alternatives

Handling AI-Generated Merge Conflicts​

When AI-generated code conflicts with existing work:

# View conflict
git status

# Edit conflicted files
# Choose between AI suggestions and existing code
# Or combine both approaches

# Mark as resolved
git add conflicted-file.js

# Complete merge
git commit

Strategies for resolving AI conflicts:

  1. Understand both versions before choosing
  2. Test combined solutions when possible
  3. Consult team members for complex conflicts
  4. Document resolution reasoning in commit message

Git Hooks for AI Development​

Automate quality checks for AI-generated code:

Pre-commit hook (.git/hooks/pre-commit):

#!/bin/sh
# Run linting on AI-generated code
npm run lint

# Run tests
npm test

# Check for common AI code issues
./scripts/check-ai-code.sh

Commit message hook (.git/hooks/commit-msg):

#!/bin/sh
# Ensure AI commits are properly marked
if grep -q "AI:" "$1" || grep -q "Generated by" "$1"; then
    echo "AI-generated commit detected - ensure code is reviewed"
fi

Common Git Mistakes with AI​

Committing Without Review​

Problem: Committing AI-generated code without understanding it Solution: Always review and test AI code before committing

Poor Commit Messages​

Problem: Generic messages like "AI update" or "Generated code" Solution: Describe what the AI actually did and why

Not Using Branches​

Problem: Working directly on main branch with AI experiments Solution: Use feature branches for all AI-generated work

Ignoring Git History​

Problem: Not using Git to track AI development decisions Solution: Use detailed commit messages and branch names

Tools and Integrations​

Git GUIs for AI Development​

  • GitKraken: Visual branch management for AI experiments
  • SourceTree: Easy diff viewing for AI-generated changes
  • VS Code Git: Integrated Git tools in AI-enabled editors

Command Line Tools​

# Better Git logs
git log --graph --pretty=format:'%h -%d %s (%cr) <%an>'

# Find AI-related commits
git log --grep="AI:" --oneline

# See AI changes over time
git log --since="1 week ago" --grep="AI\|Generated"
warning

Never commit sensitive information like API keys, even in AI-generated code. Always review for secrets before committing.

Next Steps​