Git: 'fatal: not a git repository' - How to Fix It

This error means Git could not find a repository in the folder you are standing in (or any folder above it). You ran a Git command somewhere that is not tracked by Git. The one-line fix is one of three things: cd into your actual project folder, run git init if this is a brand-new project, or run git clone if you meant to download an existing one.

Here is the full message Git prints:

fatal: not a git repository (or any of the parent directories): .git

What the error actually means

Every Git repository has a hidden .git folder at its root. That folder is the repository: it holds your commit history, branches, config, and staged changes. When you run a command like git status or git add, Git walks up from your current directory looking for that .git folder. If it reaches the top of the filesystem without finding one, it gives up and prints fatal: not a git repository.

So the error is not really about a broken repo. Almost always it means one of these:

• You are in the wrong directory (your terminal is somewhere outside the project).
• The project was never initialised as a Git repo in the first place.
• You meant to clone a remote repository but ran a command before doing so.
• The .git folder got deleted or you are inside a subfolder that was copied out of a repo.

Step 1: Check where you are

First, confirm which folder your terminal is sitting in:

pwd
ls -la

pwd prints the current directory. ls -la lists everything, including hidden files. If this is a Git repo, you will see a .git entry in the listing:

drwxr-xr-x  12 techearl  staff   384 May 31 10:02 .git
-rw-r--r--   1 techearl  staff   166 May 31 10:01 README.md

No .git line means there is no repository here. That is the whole diagnosis.

Step 2: Pick the right fix

What you do next depends on what you were actually trying to do.

Fix A: You are in the wrong folder

This is the most common cause. Your project lives in one directory, but your terminal opened somewhere else (your home folder, a parent folder, a sibling project). Just move into the right place:

cd ~/projects/my-app
git status

Tab-completion helps here: type cd ~/proj and press Tab to let the shell fill in the rest. Once git status prints a branch name instead of the fatal error, you are inside the repo.

Fix B: This is a new project with no repo yet

If you just created the folder and never set up version control, there is genuinely no repository to find. Create one:

cd ~/projects/my-app
git init

git init creates the .git folder in the current directory and turns it into a repository. From there you make your first commit, though Git will often stop you first to set your name and email before that first commit. I walk through that full first-commit flow in Git for Beginners: How to Actually Get Started, and there is a focused guide on setting up Git for a new project if you are starting from scratch. If the folder already has files in it, see how to add Git to an existing project.

One thing to watch: run git init in the project root, not in a random parent folder. If you accidentally initialise a repo one level too high, you will track far more than you intended. If that happens, delete the stray .git folder and start again in the right place:

rm -rf .git

Be careful with that command. It permanently removes the repository in the current directory. Make sure pwd shows the wrong location before you run it.

A freshly init'd repo has no commits yet, so the next wall is often its sibling error on the first push. If you hit it, here is how to fix fatal: not a git repository's sibling, the 'not a valid object name' / no-commits state.

Fix C: You meant to clone a remote repo

If the code lives on GitHub (or any remote) and you have not downloaded it yet, there is nothing local for Git to find. Clone it first:

git clone https://github.com/your-name/my-app.git
cd my-app
git status

git clone creates a new folder, downloads the full history into it, and sets up the .git folder for you. That URL is the HTTPS form; you can also clone over SSH, and how to use git clone vs starting fresh - SSH vs HTTPS remote choice walks through which to pick. If the clone itself fails (rather than landing you in the wrong folder), the usual culprit is auth: if the clone URL itself is rejected for auth, it is almost always because GitHub dropped password authentication over HTTPS. Notice the cd my-app step: cloning drops the repo into a subfolder named after the project, so you have to move into it before Git commands will work. Forgetting that cd is a classic way to land right back on the same fatal error.

If you are deciding between cloning and forking, fork vs clone in Git explains the difference. And once you have the repo, how to start working on an existing Git project covers the next steps.

The hidden .git folder, explained

It is worth understanding what .git actually is, because once you do, this error stops being mysterious.

When you run git init or git clone, Git creates a folder named .git at the root of your project. The leading dot makes it hidden on Unix systems, which is why a plain ls does not show it (you need ls -la). Inside it, Git stores everything that makes the project a repository:

.git/
├── HEAD          # points at your current branch
├── config        # this repo's settings and remotes
├── objects/      # every commit, tree, and file blob
├── refs/         # branch and tag pointers
└── index         # the staging area

Your actual project files (the source code, the README) live alongside .git, in what Git calls the working tree. The .git folder is the database; the working tree is what you edit. Delete .git and you delete the entire history, even though the current files survive: the folder reverts to being an ordinary, untracked directory, and you are back to fatal: not a git repository.

This is also why the staging area and your commit history persist between sessions. They live inside .git, not in your shell. If you want to dig into how Git stores commits and what those objects/ files are, the Git reflog is a good next read.

A practical security note: because .git carries your whole history, you never want it served publicly on a web server. An exposed .git directory lets anyone reconstruct your entire source tree and any secrets committed along the way.

Other ways to land on this error

A few less obvious cases that produce the same message:

• You copied files out of a repo. If you copy a project's source files (without the hidden .git folder) into a new location, the copy is not a repository. Re-init or re-clone.
• You are inside a non-repo subfolder. Git searches upward, not downward. If your repo root is ~/app but you are in ~/Downloads, Git will never find it no matter how the project relates to you. Only the path upward from your current directory is searched.
• A submodule or nested folder confusion. Standing in a folder that is not itself a repo and not inside one will fail, even if a sibling folder is a repo.
• GIT_DIR is set wrong. Rare, but if the GIT_DIR environment variable points at a path that does not exist, Git will not find the repo. Run echo $GIT_DIR (if it prints anything, that is the cause) and unset it.

Once you have a working repository, the rest of the basics get easier: Git branching for beginners and using a .gitignore file are the natural next steps once git status runs cleanly.