Git Context

When to Use

Use this skill when:

• Understanding why code was written a certain way
• Finding related changes across the codebase
• Tracing the evolution of a feature or pattern
• Identifying who has expertise in a module
• Finding past bug fixes or regressions in an area

What It Does

Searches git history to build context about the codebase, using a combination of native git commands and the sem MCP tool for deeper analysis. Helps answer "why was this done this way?" and "what changed recently in this area?"

How to Execute

Find Recent Changes to a Module

# Recent commits touching this area
git log --oneline --all -20 -- path/to/module/

# Who works on this area most
git shortlog -sn -- path/to/module/

# When a specific function was introduced
git log -S "functionName" --oneline -- path/to/module/

Trace a Function's History

# When was this function introduced?
git log -S "export function calculateTotal" --oneline

# Who has modified it?
git blame path/to/file.ts -L 10,30

# What was the commit message?
git show <commit-hash> --no-patch

Find Related Changes

# Files changed together in the same commits
git log --all --name-only -- path/to/changed/file.ts | head -20

# Find commits that reference a ticket or pattern
git log --all --grep="fix|bug|hotfix" --oneline -20

Using sem for Deeper Analysis

# Entity-level blame (function level)
sem blame path/to/file.ts --function processOrder

# Impact analysis
sem impact path/to/file.ts --function processOrder

# Compare branches at function level
sem diff main..HEAD -- path/to/file.ts

Cross-Session Context

# Search past agent sessions about this module
ctx search "this module" path/to/module/

# Find past discussions about related changes
ctx search "bug fix" path/to/module/

Decision Tree

┌────────────────────────────┬────────────────────────┐
│ Need this                   │ Use this               │
├────────────────────────────┼────────────────────────┤
│ What changed recently      │ git log -20 -- path/   │
│ Who works on this module   │ git shortlog -sn path/ │
│ Why was this line added    │ git blame path/to/file │
│ When was function added    │ git log -S "funcName"  │
│ What else changed together │ git log --name-only    │
│ Impact of changing X       │ sem impact path/func   │
│ Past agent work on this    │ ctx search "topic"     │
└────────────────────────────┴────────────────────────┘

Common Patterns

Pre-Implementation Check

Before implementing a change, check:

# 1. Recent changes to affected modules
git log --oneline --all -10 -- src/feature/

# 2. Who has expertise
git shortlog -sn -- src/feature/ | head -5

# 3. Related commits (ticket/branch references)
git log --all --grep="feature-name" --oneline

# 4. Past bugs in this area
git log --all --grep="bug|fix|error" --oneline -10 -- src/feature/

Post-Change Verification

After implementing, verify:

# 1. What did I change?
git diff --stat

# 2. Are there unrelated changes?
git diff --cached --name-only

# 3. Did I miss anything?
git diff HEAD --name-only  # Unstaged changes

Tips

• Commit messages matter: Write clear messages — they become the primary documentation
• Use git log -S over grep for history: grep scans the working tree; git log -S scans history
• Combine with ctx: Past agent sessions often contain context that git history doesn't
• Be specific with paths: git log -- path/ filters to relevant commits, reducing noise
• Use --all for complete picture: Default git log only shows current branch history

Integration with Other Skills

• Use before /blindspots to gather initial context
• Use during context-discovery for deep git history analysis
• Log surprising git history findings in implementation-logger