What is the difference between git add and git commit?

git add places files in the staging area (a sort of draft). git commit permanently records the staged files in the project history. Both steps are necessary: first add, then commit.

Can I modify a commit I just made?

Yes, with git commit --amend. This command replaces the last commit with a new one that includes the additional changes. Warning: never use --amend on a commit that has already been pushed to a shared repository.

How many files should go in a single commit?

A commit should contain one coherent logical change. If you fix a bug, only commit the files related to that fix. This is called an "atomic commit". Avoid catch-all commits that mix multiple topics.

What happens if I make a commit without a message?

Git will not allow a commit without a message (unless you use the --allow-empty-message option, which is not recommended). If you type git commit without -m, Git will open a text editor for you to write your message.

How do I undo a commit?

To undo the last commit while keeping changes: git reset --soft HEAD~1. To safely undo an older commit: git revert . The revert command creates a new commit that undoes the changes, which is cleaner for a shared history.

What is a commit hash?

Each commit has a unique identifier called a hash (or SHA), a string of 40 hexadecimal characters (e.g., a1b2c3d4e5f6...). The first 7 characters are often used as a shorthand. This hash is calculated from the commit content, its author, the date, and the parent commit.

Git commit explained simply

The commit is the most fundamental operation in Git. Understand what it does, how to use it correctly, and what the best practices are for clear messages.

Practice commits View the full glossary

gitquest — enquête

What is a Git commit?

A commit is a snapshot of your project at a given point in time. It's like a smart save: Git records the exact state of all files you added to the staging area.

Each commit contains: the changes made, a descriptive message, the author's name, the date, and a reference to the previous commit (the parent). This chain of commits forms your project's history.

Unlike a simple Ctrl+S, a commit is permanent and shareable. Once committed, your work is protected: even if you break everything afterward, you can always go back to that state.

Basic syntax

How to make a commit

A commit always involves two steps. First, you add modified files to the staging area with git add. Then, you record them with git commit.

The -m flag lets you specify the message directly on the command line. Without it, Git will open your default text editor.

gitquest - basic commit

# Make a simple commit

$git add index.html

$git commit -m "feat: add homepage"

[main a1b2c3d] feat: add homepage

1 file changed, 42 insertions(+)

gitquest - commit options

# Commit with common options

$git commit -am "fix: responsive header correction"

# -a: automatically stage modified files (not new ones)

# -m: specify the message inline

$git commit --amend -m "fix: responsive header + footer correction"

# --amend: replace the last commit

Useful options

Most commonly used commit options

-m "message"

Specify the commit message directly on the command line.

-a

Automatically stage all modified tracked files. Does not include new files.

--amend

Replace the last commit. Useful to fix a message or add a forgotten file.

--no-edit

Used with --amend to keep the previous commit message unchanged.

Commit message best practices

A good commit message explains why a change was made, not just what. Here are the most widely used conventions in the industry.

Good examples

feat: add contact form
fix: correct cart total calculation
style: refactor sidebar CSS
docs: add installation instructions
test: add User unit tests

Bad examples

fix Too vague, fix what?
update Update what?
wip Work in progress is not a commit
asdfgh No message = no useful history
changed everything Catch-all commit impossible to review

The Conventional Commits convention

The most widespread convention in the industry follows the format: type: short description

feat: new featurefix: bug fixdocs: documentationstyle: formatting, CSSrefactor: refactoringtest: adding testschore: technical tasksci: continuous integration

History

View the commit history

The git log command displays the list of all commits. The --oneline option condenses each commit to a single line for a quick overview.

A clean history with clear messages and atomic commits is a sign of professionalism. It also makes debugging and collaboration much easier.

gitquest - history

# View commit history

$git log --oneline -5

a1b2c3d feat: add homepage

b2c3d4e fix: navigation link correction

c3d4e5f style: header CSS refactoring

d4e5f6g docs: update README

e5f6g7h chore: ESLint configuration

Common mistakes with git commit

Forgetting to run git add first

If you run git commit without staging any files, Git will tell you "nothing to commit". Don't forget the git add step.

Committing sensitive files

.env files, API keys, passwords: once committed, they stay in the history even after deletion. Use .gitignore before your first commit.

Making a massive commit

A commit that touches 50 files and mixes 3 topics is impossible to review and undo cleanly. Prefer atomic commits: one topic = one commit.

Using --amend on an already pushed commit

Amending a commit that is already on the remote will create conflicts for the entire team. Use git revert instead.

Part of the Git Basics guide

Related commands

git status

Check what will be committed

git log

View commit history

git push

Send commits to the remote

GitQuest is created by Anaïs (nouvelle fenêtre), web developer and head of education, specializing in tech training and digital accessibility.

Questions fréquentes

Ready to master git commit?

Practice commits in realistic scenarios with GitQuest investigations. It's free.

Get started now