What is research-git-patterns?

The Research Git Patterns skill is a specialized Git-aware tool designed to streamline software development by extracting implementation patterns and story context directly from Git history. By leveraging story IDs, it allows developers and AI agents to quickly understand how features were built, find reusable code patterns, and reconstruct the implementation timeline of specific tasks. This skill significantly accelerates context building for coding tasks, offering a 3-5x speed improvement over manual file-based searching.

When should I use research-git-patterns?

research-git-patterns is useful in the following scenarios: • Feature Implementation Analysis: Retrieve the full history, code changes, and test coverage for a specific User Story ID to understand exactly how a feature was constructed. • Pattern Mining & Reuse: Search Git history for specific architectural patterns (e.g., authentication logic or rate limiting) to find reusable code blocks and maintain consistency across the codebase. • Context Building for AI Agents: Efficiently generate summaries of modified files and commit logs to provide Claude with high-quality, historical context for debugging or feature expansion. • Historical Timeline Tracking: Calculate implementation time and visualize the evolution of a feature by analyzing commit timestamps and metadata associated with a specific story ID. • Codebase Auditing: Identify when and why specific code snippets were introduced by searching for keywords or patterns across the entire repository's history.

name	research-git-patterns
description	Git-aware skill for finding implementation patterns and retrieving story context from git history. Use when searching for similar implementations or understanding how a feature was built. To use this skill, you must have a story ID (e.g., "US-001-auth-login-admin"). Use research-user-stories skill to find the story ID.

Research Git Patterns

When to Use

INVOKE when user asks about:

How a feature was implemented
Finding similar code patterns
Understanding implementation history
Retrieving story context

Git Commands for Story Retrieval

Find All Commits for a Story

# Get full implementation history
git log --grep="US-001-auth-login-admin" --oneline --graph

# Get detailed changes with code
git log --grep="US-001-auth-login-admin" -p --follow

# Get just the files changed
git diff --name-only main...$(git log --grep="US-001-auth-login-admin" -1 --format=%H)

Analyze Implementation Patterns

# Find similar authentication implementations
git log --grep="auth\|login\|clerk" --oneline

# See how rate limiting was implemented across stories
git log -S"RateLimiter" -p

# Find all FastAPI endpoint additions
git log --diff-filter=A -- "apps/server/src/api/**/*.py"

Extract Story Context

# Get story implementation timeline
git log --grep="US-001-auth-login-admin" --format="%ai %s" | sort

# Calculate implementation time
git log --grep="US-001-auth-login-admin" --format="%at" | awk 'NR==1{first=$1} END{print (last-first)/3600 " hours"}'

# Get test coverage evolution
git log --grep="US-001-auth-login-admin" --format="%h" | xargs -I {} sh -c 'git show {}:coverage.json 2>/dev/null | jq .total'

Build Complete Context

# Create story summary
story="US-001-auth-login-admin"
echo "=== Story $story Implementation ==="
echo "\n📝 Commits:"
git log --grep="$story" --oneline

echo "\n📁 Files Modified:"
git diff --name-status main...$(git log --grep="$story" -1 --format=%H)

echo "\n✅ Tests Added:"
git diff main...$(git log --grep="$story" -1 --format=%H) -- "*test*.py" --name-only

echo "\n📊 Statistics:"
git log --grep="$story" --shortstat | grep -E "files? changed"

Pattern Mining

Find Reusable Patterns

# Example: Find all endpoint security patterns
patterns = {
    "auth": "git log -S'@router.post.*Depends.*get_current_user' -p",
    "rate_limit": "git log -S'RateLimiter' -p",
    "validation": "git log -S'@validator' -p",
    "error_handling": "git log -S'HTTPException' -p"
}

Generate Implementation Template

# Extract common backend structure from story
git show --format="" --name-only $(git log --grep="US-001-auth-login-admin" --format=%H) |
  grep "apps/server" |
  sed 's|apps/server/||' |
  sort -u

Context Building for Claude

When building context from git:

Start with story commits
```
git log --grep="US-XXX" --oneline
```
Get implementation details
```
git show <commit-hash>
```
Find related patterns
```
git log -S"<key-concept>" --oneline
```
Build file history
```
git log --follow -p -- <file-path>
```

Integration with User Stories

The minimal user story files reference git commits. Use these commands to expand context:

# From user story: "Implementation: git log --grep='US-001-auth-login-admin'"
# Expand to full context:
git log --grep="US-001-auth-login-admin" --stat --format=fuller

Efficiency Tips

Use git aliases for common patterns:

git config --global alias.story 'log --grep'
git config --global alias.pattern 'log -S'

Cache results in Memory MCP:
- Story implementation summaries
- Common patterns
- Reusable code blocks

Batch operations for multiple stories:

for story in US-001-auth-login-admin US-002 US-003; do
  echo "=== $story ==="
  git log --grep="$story" --oneline
done

Error Recovery

If git history is unclear:

Check commit message conventions
Use broader search patterns
Fallback to file-based search
Ask user for clarification

Performance Metrics

Git operations are typically:

git log --grep: <100ms
git show: <50ms per commit
git diff: <200ms for feature branch
Full story context: <2 seconds

Compare to file reading:

Multiple file reads: 500ms-2s
Context building: 2-5s
Pattern searching: 1-3s

Git approach is 3-5x faster for context retrieval

research-git-patterns

When & Why to Use This Skill

Use Cases