smart_toy Artificial Intelligence › Article

Git for designers: version control without the jargon

Git keeps a project's change history and lets you go back. Commit, diff and branch explained without jargon for designers who build with AI tools.

info Quick Definition

Git is a version control system: it keeps the change history of a project so you can compare, recover and go back to any earlier version. For anyone working with AI, it is the safety net that remains when something goes wrong.

What problem does it solve?

A project changes many times a day. Without a record, when something breaks you do not know when it started or what caused it. With Git, each important change is saved with a date, an author and a description. According to the official Git book, version control exists precisely to recall specific versions, compare changes over time and see who modified something that causes a problem (Pro Git, About Version Control).

A detail worth knowing: every copy of the repository holds the full history. While your copy exists, your work is not lost if the cloud service fails.

What are a commit, a diff and a branch?

Concept	What it is	Everyday example
Commit	A saved point with a description	“Add the empty state to the search box”
Diff	The difference between two versions	Lines in green (added) and red (removed)
Branch	A separate line of work	Trying a redesign without touching the main version

A commit is like a photo with a caption. The diff is the comparison between two photos. A branch is a parallel line of work you can discard or merge into the main version once you are happy with it.

Why does it matter to someone working with AI?

Because an AI can change many files in a single step. Without commits, reverting a change means guessing what it touched. Before each important session, save a commit; after each change that works, save another. That way, if the next change breaks something, you go back to the last point that worked.

Restore points in some tools help, but they do not replace Git. The Claude Code documentation, for example, states that its checkpoints only track edits made with its file-editing tools: changes made by terminal commands or by other sessions are not recorded.

Which commands do you need?

You do not need to memorize many. These cover everyday basic use:

git status: which files changed since the last commit.
git diff: exactly what changed.
git add and git commit: save a point with a description.
git log: see the history.
git restore <file>: discard a file’s unsaved changes and return it to its last commit. Careful: what you discard this way cannot be recovered.
git revert <commit>: create a new commit that undoes an earlier one, without erasing the history.

An AI tool usually runs these commands for you. Your job is to review the result: read the diff before accepting. That reading is the same skill described in reading code without knowing how to program.

Example

Illustrative example: a designer has a contact form that works. Before asking the AI to change the design, she makes a commit: “Contact form working”. The AI redesigns the form and also changes the validation file. When she reviews the diff, she sees the change to the validation, which she did not ask for. She reverts only that file to its state at the previous commit, asks for the redesign to leave the validation alone and saves a new commit. Without the saved point, she would have had to rebuild the validation by hand.

How do you start tomorrow?

Start version control in your design or prototype project (git init) and save a first point with the current state, with a message that says what works.
Before each AI session, check whether there are unsaved changes. If there are, decide whether to save or discard them before starting.
After each change that works, save a point with a one-sentence description: what was added or what was fixed.
When the AI finishes, open the diff and review at least the file names. If one appears that you did not expect, ask why before saving.

With these four habits, a mistake becomes a rollback of one point instead of a lost week.

A habit that avoids conflicts: when you start each day, check the project’s state before asking for changes, and when you finish, save a point even if the work is incomplete, with “in progress” in the message. That way tomorrow you know where you stopped without relying on the memory of the previous conversation. If you wonder what changed in a file nobody touched, the history answers, even when the tool no longer remembers. These commands run from the terminal, and the way to share those changes with others is in branches and pull requests.

Common mistakes

Working for weeks without saving history points.
Writing commit messages such as “changes” or “fix” that say nothing a month later.
Accepting AI changes without looking at the diff.
Believing the cloud keeps everything Git keeps.
Editing files by hand in the middle of an AI session without telling the tool.
Trusting the AI’s history to replace the project’s history.

Sources

Scott Chacon and Ben Straub, “Pro Git”, chapter 1.1, “About Version Control”: https://git-scm.com/book/en/v2/Getting-Started-About-Version-Control
Anthropic, “Checkpointing” in the Claude Code documentation (what restore points track and what they do not): https://code.claude.com/docs/en/checkpointing
Git, git restore documentation: https://git-scm.com/docs/git-restore
GitHub Docs, “About pull requests” (how a change is reviewed before it is integrated): https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests

Frequently asked questions

What is Git?

It is a version control system that records changes to one or more files over time, so you can compare, recover and go back to earlier versions.

What is a commit?

It is a saved point in the history, with a description of what changed. Each commit lets you return to that state of the project or see what changed compared with the previous one.

Why do I need Git if the AI already saves changes?

The restore points of an AI tool usually capture only the changes made with its own editing tools. Changes made from the terminal or by other processes are not recorded. Git is the complete record.

What is a branch?

It is a separate line of work inside the same project. It lets you test a change without touching the main version, until you decide to integrate it.