Timeline vs Git History

Git tracks what changed. SnapBack understands who changed it and why.

They’re complementary tools—use both for complete development visibility.

The Fundamental Difference

Aspect	Git	SnapBack Timeline
What it tracks	Commits you explicitly make	Every save, automatically
Granularity	Commit-level (you decide when)	Save-level (continuous)
AI awareness	None	Full attribution and context
Context captured	Commit message (optional)	Cursor, open files, AI tool, risk score
History model	Linear commits	Graph-based timeline with sessions
Primary purpose	Version control & collaboration	Understanding AI-assisted development

Visual Comparison

Git History

commit a1b2c3d (HEAD -> main)
Author: you@email.com
Date:   Tue Jan 14 15:30:00 2025

    Add user authentication

    - Implemented login/logout
    - Added session management
    - Fixed security issues

Git shows: What you committed and when

SnapBack Timeline

📁 src/auth/login.ts
├── 3:30 PM (Cursor ⚠️) - Async conversion, 78% AI contribution
│   └── Risk: High - Pattern match: async_without_error_handling
├── 3:28 PM (Manual ✓) - Added error logging
├── 3:25 PM (Copilot) - Generated boilerplate, 92% AI contribution
├── 3:20 PM (Manual ✓) - Initial function signature
└── 3:15 PM (Session Start)

SnapBack shows: Every change, who made it, and context

When to Use Each

Use Git When

✅ Creating checkpoints

Meaningful milestones you want to name and share

✅ Collaborating with team

Sharing code, pull requests, code review

✅ Deployment history

Tracking what shipped to production

✅ Long-term history

Understanding project evolution over months/years

Use SnapBack Timeline When

🤖 Understanding AI changes

”What did Cursor just do to my auth module?”

⏱️ Navigating between saves

”Go back to 5 minutes ago, before I accepted that suggestion”

📊 Comparing AI behavior

”Does Cursor or Copilot work better for this file?”

🔍 Debugging AI-introduced bugs

”When did this break, and which AI tool caused it?”

Real-World Scenarios

Scenario 1: Multi-File AI Refactor

What happened: Claude suggested refactoring your component library. You accepted. Tests are failing.

Git’s view:

# No commits yet—you haven't committed
git status: 4 files changed

SnapBack’s view:

Session: Component Library Refactor (Claude)
├── Button.tsx - Styling changes (low risk)
├── Input.tsx - API changes (medium risk) ⚠️
├── Form.tsx - Prop renames (medium risk)
└── validation.ts - Logic error (high risk) 🔴
    └── Pattern: async_conversion_without_await

SnapBack advantage: You can navigate back to before the refactor, or selectively explore each file’s changes with full context about what Claude changed and why it might be risky.

Scenario 2: Debugging a Production Issue

What happened: Users report login failures. Last deploy was 2 hours ago.

Git’s view:

git log --oneline -5
a1b2c3d Add user dashboard
e4f5g6h Update dependencies
i7j8k9l Fix header styling
m1n2o3p Add authentication # <-- Probably this one

SnapBack’s view:

📁 src/auth/login.ts (last 2 hours)
├── 1:45 PM - Copilot async conversion (91% AI) 🔴
│   └── Changed: sync validateCredentials → async
│   └── Missing: await on return value
├── 1:30 PM - Manual edit (your change)
└── 1:15 PM - Copilot suggestion accepted

SnapBack advantage: You can see exactly which AI-generated change introduced the bug, even within a single Git commit.

Scenario 3: Learning from AI Behavior

What happened: You want to know which AI tool works best for your codebase.

Git’s view:

# Git has no AI awareness
# You'd need to manually track this

SnapBack’s view:

📊 AI Tool Performance (last 30 days)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Cursor:     85% success | Best for: TypeScript refactoring
Copilot:    89% success | Best for: Boilerplate, common patterns
Claude:     92% success | Best for: Architecture, comprehensive edits

Files with AI issues:
  src/auth/login.ts      - 3 issues (all Cursor)
  src/db/queries.ts      - 2 issues (mixed)

SnapBack advantage: You can make data-driven decisions about which AI tool to use for specific tasks.

How They Complement Each Other

Recommended Workflow

1. Work on feature with AI assistance
   └── SnapBack captures every change with context

2. Review SnapBack timeline
   └── Understand what AI changed
   └── Navigate back if needed

3. Commit to Git when ready
   └── Clean, intentional checkpoint
   └── Only vetted changes included

4. Continue development
   └── SnapBack timeline continues
   └── Git history stays clean

Best Practices

📝 Git Best Practices

• Commit after verifying AI changes work
• Write clear commit messages about intent
• Don’t commit known broken code
• Use branches for experimental AI work

🧢 SnapBack Best Practices

• Review timeline before committing
• Use sessions to group related changes
• Check AI attribution on failing tests
• Let pattern learning build over 30+ days

Technical Comparison

Storage Model

Aspect	Git	SnapBack
Storage location	.git/ directory	.snapback/ directory
Data format	Object database (blobs, trees)	Binary state.bin + indexes
Compression	Delta compression	State-based deduplication
Typical size	Grows with history	Capped with retention policy
Sync	Remote repositories	Local-first, optional cloud

Context Captured

Context	Git	SnapBack
File contents	✅ Full diff	✅ Full state
Commit message	✅ Required	⚪ Optional note
Timestamp	✅ Commit time	✅ Save time
Author	✅ Committer	✅ + AI tool attribution
Cursor position	❌	✅
Open files	❌	✅
AI contribution %	❌	✅
Risk score	❌	✅
Pattern analysis	❌	✅

Query Capabilities

Git queries:

git log --oneline           # List commits
git show abc123             # Show commit details
git diff HEAD~5             # Compare with 5 commits ago
git blame file.ts           # Line-by-line history

SnapBack queries:

snap timeline               # Show protection states
snap show state_abc         # Show state details
snap diff --time 5m         # Compare with 5 minutes ago
snap blame file.ts          # Line-by-line with AI attribution
snap patterns tools         # AI tool performance
snap sessions               # View session groupings

Migration and Coexistence

They Don’t Conflict

SnapBack and Git operate independently:

SnapBack stores data in .snapback/ (add to .gitignore)
Git stores data in .git/
Neither modifies the other’s data
Both can run simultaneously

Recommended .gitignore Addition

# SnapBack local state (add this)
.snapback/

Summary

Use Git for:

Version control and collaboration
Deployment and release management
Long-term project history
Code review and pull requests

Use SnapBack for:

Understanding AI-assisted development
Navigating between saves with context
Debugging AI-introduced issues
Learning which AI tools work best

Together, they give you complete visibility into your development process.

Next Steps

📈 Pattern Learning

How SnapBack learns your codebase patterns over time.

Learn more →

⏱️ Sessions

How sessions group related changes in your timeline.

Explore sessions →

Timeline vs Git History

The Fundamental Difference

Visual Comparison

Git History

SnapBack Timeline

When to Use Each

Use Git When

✅ Creating checkpoints

✅ Collaborating with team

✅ Deployment history

✅ Long-term history

Use SnapBack Timeline When

🤖 Understanding AI changes

⏱️ Navigating between saves

📊 Comparing AI behavior

🔍 Debugging AI-introduced bugs

Real-World Scenarios

Scenario 1: Multi-File AI Refactor

Scenario 2: Debugging a Production Issue

Scenario 3: Learning from AI Behavior

How They Complement Each Other

Recommended Workflow

Best Practices

📝 Git Best Practices

🧢 SnapBack Best Practices

Technical Comparison

Storage Model

Context Captured

Query Capabilities

Migration and Coexistence

They Don’t Conflict

Recommended .gitignore Addition

Summary

Next Steps

📈 Pattern Learning

⏱️ Sessions

On this page