Git Basics for Designers Who Now Ship Code: A 12-Point Checklist
For years I handed developers a Figma file and they handled everything after that. Now that I build some of my own designs with AI coding tools, I've had to learn the thing developers treated as background noise: version control.
I'm not a Git expert, and this isn't an expert's guide. It's the short checklist I'd give a designer who just started shipping code. The focus is on habits that protect your work, not on clever commands.
01Understand the mental model first
1. Think of a commit as a named save point
A commit is a snapshot of your project with a message attached. It isn't a backup of a single file, and it isn't a sync. If you've ever named a Figma version "before client feedback," you already get the idea.
2. Know the three places your changes live
Your changes move through three stages: the working folder (edited, not recorded), the staging area (picked for the next commit), and the commit history (recorded). Most early confusion comes from not knowing which stage a change is in. git status tells you.
3. Remember that Git is not GitHub
Git runs on your computer. GitHub, GitLab and Bitbucket are places to host a copy of the repository. You can use Git with no internet at all, and that's worth knowing when a push fails and you assume your work is gone. It isn't.
02Build a daily rhythm
4. Run git status constantly
It's free and it never changes anything. Run it before you start, before you commit, and whenever you feel unsure. I'd treat it like glancing at the layers panel.
5. Commit small and often
One commit per idea: "Add pricing card hover state," not "Updates." Small commits are easy to review and easy to undo. This matters more with AI tools, because one prompt can touch ten files. If you commit before each prompt, you have a clean line to go back to.
6. Write messages for your future self
Say what changed and, if it isn't obvious, why. Compare:
- "fix stuff"
- "Increase tap target on mobile nav links to 44px"
The second one is useful six weeks later when you're wondering why the padding looks odd.
7. Read the diff before you commit
git diff shows exactly which lines changed. This is the most valuable habit for a designer using AI tools. Say you asked for a button color change and the diff shows 200 lines altered in a layout file. You'd want to know that before it lands in your history. If you want a fuller review routine, I wrote a designer's checklist for reviewing AI-built UI before shipping.
03Protect main and experiment safely
8. Never experiment directly on main
Treat main as the version that's live, or about to be. Make a branch for each piece of work:
git switch -c feature/pricing-page-redesign
A branch is a parallel copy of your timeline. If the experiment goes badly, you delete the branch and nothing else is affected. For a designer who likes trying three directions, this is the closest thing Git has to duplicating a frame.
9. Pull before you start, and keep branches short-lived
If anyone else touches the project, including a developer you work with, fetch their changes before you begin. Long-running branches drift away from main, and merging them later gets painful. A branch that lives a day or two is much easier to merge than one that lives a month.
10. Use pull requests even when working alone
A pull request is a page showing the diff between your branch and main. Opening one for yourself gives you a deliberate pause to read what you're about to merge. If a teammate is involved, it also gives them a place to comment on specific lines. Many hosting platforms, Vercel among them, can build a preview from a branch, so you can look at the result before it goes live.
04Know what to keep out and how to recover
11. Set up .gitignore before the first commit
Some files should never be in your history:
node_modules/, the downloaded dependencies, which are large and can be reinstalled.envfiles, which hold secrets like API keys- Build output folders and system files like
.DS_Store
The secrets point is the serious one. If a key lands in a commit and you push it to a public repository, deleting it in a later commit doesn't remove it from the history. Treat the key as exposed and replace it. Prevention is much easier than cleanup, which is why this goes in before the first commit.
If you use an AI tool to scaffold a project, check that a .gitignore exists and covers these. Don't assume.
12. Learn the undo commands before you need them
You don't need many. These cover most situations:
- Discard changes to one file you haven't committed:
git restore <file>. This is destructive, since those edits are gone for good. - Unstage a file:
git restore --staged <file> - Undo a commit safely:
git revert <commit>. It creates a new commit that reverses the old one and keeps history intact. - Set work aside temporarily:
git stash, and bring it back withgit stash pop
Be careful with git reset --hard and git push --force. Both can erase work, and force-pushing can overwrite other people's commits. If an instruction from a tutorial or an AI assistant includes either, stop and make sure you understand what it will delete first. A cheap safety move is to commit or create a temporary branch before anything risky, so there's always a point to return to.
05A minimal workflow you can copy
Here's the whole loop in one place:
git statusto see where you aregit switch -c feature/short-nameto start a branch- Make a change, or prompt your AI tool for one
git diffto read what actually changedgit addthe files you intended to change, thengit commit -m "Clear message"- Repeat steps 3 to 5
- Push the branch, open a pull request, read it once more
- Merge, then delete the branch
That's it. You can do real work with just these commands for a long time.
06Mistakes I'd expect designers to make
These are predictions based on how Git works, not stories from a specific project:
- Committing everything with
git add .without looking. This is how stray files and secrets get in. Checkgit statusfirst. - Working for days without committing. One bad prompt or bad merge can then cost you everything from that stretch.
- Treating merge conflicts as disasters. A conflict just means two changes touched the same lines and Git wants you to choose. Read both versions, keep what you want, and continue.
- Being afraid of the terminal. The commands are few, and
git statusexplains most of what's happening.
07Where to go from here
Don't try to memorize everything. Pick the habits that protect you most: small commits, branches for experiments, reading the diff, and a proper .gitignore. Those four prevent most of the painful situations.
If you're building with AI tools, Git is also your safety net for trusting them at all. You can let the tool move fast because you can see what it did and step back from it.
08Frequently asked questions
Do designers really need to learn Git if an AI tool writes the code?
Yes. AI tools change many files quickly, and Git is how you see what changed and undo it. Without it, a bad suggestion can be hard to separate from the good work around it.
Should I use a Git GUI app or the command line?
Either works. A GUI is fine for viewing diffs and staging, but learning about ten commands helps when something goes wrong and you need to follow instructions from docs or an AI assistant.
What is the safest way to undo a mistake in Git?
Before anything risky, commit or stash your work so there is a saved point to return to. Then prefer commands that add a new commit, such as git revert, over ones that rewrite history, such as git reset --hard.
Denny Pratama
Product designer in Indonesia. Since 2018 I’ve designed SaaS products, dashboards and marketing sites, and now I build my own designs too.