What Is Version Control? Git for AI App Builders
What is version control? It records every change to your code so you can go back to any earlier state. Here's how Git works and how to use it for an AI-built app.
Overview & context
Version control is a system that records every change to your code with a date and a description, so you can return to any earlier state of the app. Git is the most widely used tool for it. GitHub is the best-known service for hosting Git repositories. It matters even more for an AI-built app: an assistant edits dozens of files at once and without history you can't tell what changed or when the app last worked. This article explains the basic terms, shows how to start with Git and how to keep the repository and versions next to the app.
1. What is version control
Version control is a way to keep the whole history of a project: who changed what and when. Instead of folder copies, you store the project as a series of named changes and can restore any of them. The Pro Git book explains it in more detail.
Git is the most widely used version control system and runs locally on your computer. GitHub, GitLab and Bitbucket are services that store a Git repository on their servers, so it's backed up and you can share it with other people. Git and GitHub aren't the same thing.
2. Why an AI-built app needs version control
Version control lets you return to the last working state when an assistant breaks something. AI tools like Lovable, Bolt or Cursor change several files per prompt and fixing one problem sometimes brings back an earlier one. With Git you can see the difference between two states and go back to the one that still worked.
Many tools keep their own change history and most offer a GitHub connection. A copy of the code in a repository outside the tool is still the only one you can keep using if you switch tools, hand the app over or run into trouble with your account.
3. Git basics: repository, commit, branch and tag
Four terms are enough to understand what happens in Git. You'll pick up the rest over time.
| Term | What it means | Example |
|---|---|---|
| Repository | The project folder including the whole change history | github.com/your-company/room-booking |
| Commit | A saved state of the project with a description of the change | "Add booking cancellation" |
| Branch | A separate line of changes, for example to try a new feature | main, new-feature |
| Tag | A named marker on a specific commit, typically a released version number | v0.1.0 |
4. How to start using Git with AI
You can start by storing the app's code in a GitHub repository and making a commit after each working change. The steps are the same whether you build the app in Lovable, Bolt or Cursor.
git add . and git commit save your changes, git log --oneline lists the history, git restore discards unsaved changes in a file, git revert HEAD creates a commit that undoes the last change, git tag marks a version and git push sends everything to GitHub.
- 1
Create a GitHub account and a repository
Create a new repository for the app on GitHub. If the code shouldn't be public, make it private.
- 2
Connect your tool to the repository
AI app builders have a GitHub connection in the project settings and push the code to the repository for you. If you work locally, use the commands in the example below.
- 3
Keep secrets out of the repository
The file with your service keys belongs in .gitignore so it never reaches the repository. The article on the .env file shows how.
- 4
Make a commit after each working change
When the app works after an edit, save it as a commit with a description of what changed. Frequent small commits make it easier to find when something broke.
- 5
Practice going back
Check once that you know how to undo the last change. When you need it, you won't be doing it under stress.
git init
git add .
git commit -m "First working version"
git log --oneline
git restore src/App.tsx
git revert HEAD
git tag v0.1.0
git push origin main --tags5. Commit vs. tag vs. app version
A commit is one saved change, while an app version is the number you give a released state, such as 0.1.0. You record the version in Git as a tag. The commits between two tags make up the release notes.
Pick the version number according to your app versioning scheme. If several developers join later, the overview of branching strategies will help you. A simple app can start with a single main branch.
6. How to keep the repository and version history next to the app
Put the repository link and version history right next to the app so you have them at hand. In AboutTheApp you add the repository in the Source Code & Architecture category and record versions in the Product versions window.
AboutTheApp doesn't connect to GitHub and doesn't pull commits or tags from it. It stores the repository as a link. You record version numbers by hand or from CI/CD.
- 1
Add the repository link
In the AboutTheApp dashboard open the app for editing, go to Resources, click Add resource, choose the Source Code & Architecture category and paste the repository URL. If you upload the project folder when you create the app, the repository link is prefilled from package.json and other files.
- 2
Mark the repository as private
If the repository isn't public, set the link to private. It's shown only to logged-in users and people who enter the unlock code.
- 3
Record released versions
Use the Product versions icon on the app card to open the Product versions window, click Add version and fill in the version number (the same as the Git tag) and the changes. A new version starts out private. The eye icon makes it public.
- 4
Set the current version
Use Set as current to mark the version that's in production. Public versions appear on the About page in the Product versions tab.
Frequently asked questions
What is version control?
Version control is a system that records every change to your code with a date and a description and lets you return to any earlier state of the project. Git is the most widely used tool.
What's the difference between Git and GitHub?
Git is the version control tool that runs on your computer. GitHub is a service that stores Git repositories on a server, so they're backed up and can be shared.
Do I need Git if my AI tool keeps its own change history?
It's a good idea to keep a copy of the code in a repository outside the tool, which keeps you from depending on a single service (vendor lock-in). The tool's history only works inside it, while a repository can be handed to another developer or used in another tool.
How often should I commit?
After every change that leaves the app working. Small commits make it easier to find when something broke and to go back to the last working state.
How do I go back to a previous version of my app?
For unsaved changes in a file, use git restore. For the last commit, use git revert HEAD, which creates a new commit with the opposite change and keeps the history.
What's the difference between a commit and an app version?
A commit is one saved change to the code. A version is the number, such as 0.1.0, that you give a released state of the app. In Git it's recorded as a tag on a chosen commit.
How do I keep the repository and app versions in one place?
In AboutTheApp you add the repository link in the Source Code & Architecture category, set a non-public repository to private and record released versions in the Product versions window. Public versions appear on the About page.
In short
Version control records every change to your code and lets you return to a working state. Keep the app's code in a repository, commit after each working change and keep the repository link and released versions next to the app.
AboutTheAppWant the repository and versions next to your app?
Create an app in AboutTheApp for free and add the repository link and version history.