Version Control Explained for AI-First Developers

If you learned to code with AI assistants, version control might feel like an artifact from a different era. Traditional tutorials assume you’re writing code slowly and deliberately, not accepting rapid-fire AI suggestions.

This guide explains version control in terms that make sense for how you actually work.

What Version Control Actually Is

At its core, version control is saving snapshots of your project over time. Each snapshot represents a state you can return to. If you break something, you restore a previous snapshot. If you want to try an experiment, you can always go back.

Think of it like save points in a video game. You save before the boss fight. If you lose, you restart from the save point rather than the beginning.

For AI coding, this is especially important because AI breaks things unexpectedly. The save points aren’t optional. They’re survival.

The Two Approaches

There are fundamentally two ways to handle version control.

Manual version control means you decide when to save. You do some work, you decide it’s worth keeping, you explicitly save a snapshot. Git is the most common tool for this. You run git commit when you want to create a save point.

The advantage is that your snapshots are meaningful. Each one represents a deliberate choice. The disadvantage is that you have to remember to save, and when you forget, you lose work.

Automatic version control means every change is captured without you doing anything. You just work, and snapshots are created continuously. When you need to go back, you find the right snapshot from the stream.

The advantage is that you can’t forget. The disadvantage is that the history is less meaningful. Rather than “added login feature,” you have “state at 3:42pm.”

For AI coding, automatic version control often makes more sense. Changes come so fast that stopping to commit after each one is impractical. Having everything captured automatically means you can iterate at AI speed without worrying about protection.

Setting Up Automatic Protection

The simplest way to start is with mrq, which was built specifically for AI coding workflows.

Install it:

npm install -g mrq-cli

mrq login

Start watching your project:

cd your-project
mrq watch

That’s it. Every file change is now captured. When something breaks:

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

You’re protected without having to think about it.

Adding Git (When You’re Ready)

At some point you’ll want Git, probably when you need to deploy or collaborate. Here’s the minimum to get started.

In your project folder:

git init

Create a file called .gitignore to exclude things that shouldn’t be versioned:

node_modules/
.env

Make your first commit:

git add .
git commit -m "Initial commit"

That’s a working Git setup. From here, when you finish something meaningful:

git add .
git commit -m "Description of what you did"

If you want to undo uncommitted changes:

git checkout .

Ignore everything else about Git until you need it. Branches, merging, rebasing can all wait.

How They Work Together

The best setup uses both automatic and manual version control together.

mrq runs in the background, capturing everything. This is your safety net while you’re working, especially during rapid AI iteration.

Git captures intentional milestones. When you finish a feature or reach a state worth documenting, you commit.

Your typical workflow looks like:

mrq watch                              # Start protection

# ... code with AI, iterate rapidly ...
# ... mrq captures everything ...

git add .
git commit -m "Login feature complete" # Mark the milestone

This gives you two layers of protection plus meaningful history for collaboration and deployment.

Key Concepts to Know

Commit: A saved snapshot. In Git, you create these manually. In mrq, they’re created automatically.

Repository (repo): Your project folder with version control enabled.

Remote: A copy of your repo on a server like GitHub. Useful for backup, collaboration, and deployment. Not necessary to start.

History: The list of all snapshots. Git history is meaningful commit messages. Automatic history is a stream of states.

The Practical Takeaway

You need version control. AI coding is too unpredictable to work without a safety net.

Start with automatic protection. It requires no discipline and works immediately.

Add Git when you have a reason: deploying, collaborating, or wanting structured history.

Using both together gives you the benefits of each. Safety without effort, plus meaningful checkpoints when you want them.

Do I Need to Learn Git? - Honest advice on Git
Cursor Checkpoints vs Git vs mrq - Comparing your options
Best Practices for AI Pair Programming - Complete guide

mrq is automatic versioning for AI coding. Set it once, never lose work again.