Chapter 16: Version Control

The Problem

Your marketing configurations are files now—YAML for segments, journeys, and workflows. Files that change over time. Files that multiple people might edit. How do you track what changed? How do you undo mistakes? How do you know who changed what and why?

The Key Idea

Core concept

Git tracks every change to every file, with history, authorship, and the ability to undo anything.

Git is how developers have managed code for decades. Your marketing configurations are code now. Git works for you too.

What Git Does

Scenario	Without Git	With Git
Something broke	"What changed?"	git diff shows exactly what
Need to undo	Hope you have a backup	git revert undoes it
Who changed this?	Ask around	git blame shows authorship
Multiple editors	Overwrite each other	Changes merge safely

How Git Works

When you run git init, Git creates a hidden .git folder:

my-marketing-configs/
├── .git/                    ← Git's database (hidden)
│   ├── objects/             ← All file versions stored here
│   └── ...
├── segments/
│   └── high-value.yml
└── workflows/
    └── daily-refresh.dig

Everything Git knows lives in that .git folder—the complete history of every file, every change, every author. Your working files are just the current version.

Key insight: Git is local. The history is on your computer. No internet required to commit, view history, or undo changes.

To share with others, you git push to a remote server like GitHub. That's Chapter 17.

Core Concepts

Working files: The files you see and edit.

Staging area: Changes you've marked to include in the next commit.

History: The chain of commits stored in .git—your time machine.

Commit: A snapshot of staged changes, with a message and timestamp. Each commit has a unique ID like a3f2c1d.

Getting Started

AI can help you set up Git:

> "Initialize a Git repository for my marketing configurations"

git init
git add .
git commit -m "Initial commit: segments and workflows"

Your files are now tracked.

Saving Changes (Commits)

After making changes, save them:

> "Commit my changes with message 'Updated high-value threshold to $1000'"

git add high-value-customers.yaml
git commit -m "Updated high-value threshold to $1000"

This creates a snapshot you can always return to.

Viewing History

See what changed over time:

> "Show me the commit history"

commit a3f2c1d (2 hours ago)
Author: Sarah <sarah@company.com>
Message: Updated high-value threshold to $1000

commit 8b4e2f9 (yesterday)
Author: Mike <mike@company.com>
Message: Added purchase behavior to segment

commit 1c7d3e8 (last week)
Author: Sarah <sarah@company.com>
Message: Initial segment creation

Every change is recorded, with who made it and when.

Seeing What Changed

View differences between versions:

> "Show me what changed in the last commit"

 rules:
   - attribute: lifetime_value
     operator: Greater
-    value: 500
+    value: 1000

Lines starting with - were removed. Lines with + were added.

Undoing Changes

Undo uncommitted changes:

> "Discard my changes to high-value-customers.yaml"

git checkout high-value-customers.yaml

Undo a commit:

> "Revert the last commit"

git revert HEAD

This creates a new commit that undoes the previous one.

Go back in time:

> "Show me what this file looked like last week"

git show HEAD~5:high-value-customers.yaml

Who Changed What (Blame)

Find out who wrote each line:

> "Who last modified the threshold value?"

git blame high-value-customers.yaml

a3f2c1d (Sarah 2 hours ago) value: 1000

Useful when you need to ask someone about a change.

Branches: Safe Experimentation

Create a branch to try something without affecting the main files:

> "Create a branch called 'experiment-new-rules'"

git checkout -b experiment-new-rules

Make changes, test them. If they work, merge back:

> "Merge my experiment into main"

If they don't work, delete the branch—main is untouched.

Mental Model: Time Machine

Git is a time machine for your files:

     [commit 1]  →  [commit 2]  →  [commit 3]  →  [HEAD]
     "Initial"      "Add rule"     "Fix typo"     (you are here)

• HEAD is where you are now
• Every commit knows its parent (the previous commit)
• You can jump to any point in history
• Nothing is ever truly deleted—old versions live in .git

The .git folder is your time machine. Delete it, and you lose all history. Keep it, and you can always go back.

Common Git Commands

What You Want	Command	What AI Says
Save changes	git add . && git commit -m "message"	"Commit my changes"
See history	git log --oneline	"Show commit history"
See differences	git diff	"What's changed?"
Undo changes	git checkout <file>	"Discard changes to X"
Create branch	git checkout -b <name>	"Create a branch for X"
Switch branch	git checkout <name>	"Switch to branch X"

AI translates your intent into these commands.

Working with AI

AI and Git work well together:

> "Create a segment for churned customers"

AI creates the file. Then:

> "Commit this with message 'Add churned customers segment'"

The AI-generated work is now tracked in history.

Best Practices

Commit often with clear messages:

• Good: "Increased LTV threshold to $1000 for Q1 campaign"
• Bad: "Updated stuff"

One change per commit:

• Good: Two commits, one for each segment
• Bad: One commit changing five unrelated files

Review before committing:

> "Show me what I'm about to commit"

Pitfalls

"I committed the wrong thing."

Undo it immediately:

> "Undo my last commit but keep the changes"

"I'm on the wrong branch."

Switch branches:

> "Switch to main branch"

"I have merge conflicts."

This happens when two people edit the same line. AI can help:

> "Help me resolve these merge conflicts"

What You've Learned

• Git tracks every change with full history
• Commits are snapshots with messages
• You can view, compare, and undo any change
• Branches let you experiment safely
• AI translates your intent into Git commands

Next Step

Git tracks your changes locally. Chapter 17 shows you how to collaborate with your team—sharing changes, reviewing each other's work, and approving before deploying.

---

Your changes are tracked. Next, you'll learn to collaborate.