I’ve been using Git for over a decade. It’s one of the best tools ever made for software development. But after six months of heavy AI-assisted coding, I’ve had to admit something uncomfortable:

Git’s workflow doesn’t match how AI coding actually works.

This isn’t a criticism of Git. It’s an observation about how AI assistants have changed the development loop.

The Problem

Git was designed for deliberate, discrete changes. You work on something, stage it, write a meaningful commit message, and move on. The rhythm is: work → commit → work → commit.

AI coding breaks this rhythm completely.

When I’m iterating with Cursor or Claude Code:

• I try three different approaches in ten minutes
• The AI modifies files I didn’t explicitly ask about
• Changes happen faster than I can meaningfully review them
• I’m focused on guiding the AI, not thinking about version control

In practice, I end up with long gaps between commits. And those gaps are exactly when AI does something unexpected—deletes files it thinks are "unused," breaks imports, or refactors in a direction I didn’t want.

Git protects what I commit. It can’t protect what I don’t.

What I Tried First

More discipline: "Just commit before every AI operation." This works in theory. In practice, when I’m in flow and iterating quickly, I skip it. The one time I forget is the time Cursor deletes my middleware folder.

Cursor Checkpoints: These are useful but limited. They only cover Composer interactions, don’t persist across sessions, and revert everything from a prompt (including manual edits I made after).

VS Code Local History: File-by-file recovery. Tedious when AI changed 20 files.

Git stash: Manual, requires discipline, only one stash at a time.

None of these provided reliable, continuous protection.

What I Use Now

I found a tool called mrq that takes a different approach. Instead of requiring commits, it captures every file change automatically in the background.

npm install -g mrq-cli
mrq watch

That’s it. Now every change is recorded—from AI, from manual edits, from anything.

When something breaks:

mrq history          # See recent
snapshotsmrq restore abc123   # Go back to any point

I’m back to exactly where I was, even if I never committed. The mrq docs explain the full workflow, but honestly the basics are just those two commands.

How I Use Both Together

I haven’t replaced Git. I use both for different purposes: Git: Meaningful commits, collaboration, deployment, PR reviews mrq: Continuous protection during AI iteration

My workflow:

1. Start session: mrq watch
2. Work with AI freely, iterate fast
3. Hit a milestone: git commit -m "Feature complete"
4. Something broke? mrq restore

Git gives me clean history for collaboration. mrq gives me protection during the messy iteration phase.

When You Need This

If you’re doing light AI usage—occasional Copilot suggestions, simple completions—Git alone is probably fine.

If you’re doing heavy AI coding—Cursor Composer, Claude Code multi-file edits, agent mode—you need continuous protection. The speed and unpredictability of AI changes creates gaps that Git’s commit model doesn’t cover.

There’s a good breakdown of why git doesn’t fit AI workflows that explains this in more detail.

Conclusion

Git remains essential. It’s still the backbone of collaboration, deployment, and project history.

But AI coding has exposed a gap between commits where you’re unprotected. For me, the solution was adding automatic snapshots to my workflow—not replacing Git, but complementing it.

The developers I know who work confidently with AI have all set up some form of continuous protection. The specific tool matters less than having something that doesn’t require discipline to remember.

What do you use for AI coding protection? I’m curious if there are other approaches I haven’t tried.