Shallow clones with depth in Git - Commands & Configuration

Introduction

Sometimes you only need the latest part of a project history, not everything. Shallow clones let you copy just the recent changes from a Git repository. This saves time and space when you don't need the full history.

When you want to quickly get the latest version of a project without downloading all past changes.

When your internet connection is slow and you want to save bandwidth by downloading less data.

When you are working on a small fix and don't need the full project history.

When running automated builds or tests that only need the current code state.

When you want to save disk space on your computer by avoiding the full repository history.

Commands

This command copies the Git repository but only downloads the latest commit. The --depth 1 flag tells Git to make a shallow clone with just the most recent history.

Terminal

git clone --depth 1 https://github.com/git/git.git

Expected Output

Cloning into 'git'...

remote: Enumerating objects: 1000, done.

remote: Counting objects: 100% (1000/1000), done.

remote: Compressing objects: 100% (800/800), done.

Receiving objects: 100% (1000/1000), 2.5 MiB | 1.2 MiB/s, done.

Resolving deltas: 100% (500/500), done.

→

--depth 1 - Limits the clone to the latest commit only, making it shallow.

Change directory into the cloned repository to start working with the files.

Terminal

cd git

Expected Output

No output (command runs silently)

Shows the commit history in a short format. Since this is a shallow clone, you will see only one commit.

Terminal

git log --oneline

Expected Output

e83c516 Initial commit

→

--oneline - Shows each commit in one line for easy reading.

This command fetches more history, increasing the depth to 5 commits. It adds more recent commits to your shallow clone.

Terminal

git fetch --depth=5

Expected Output

From https://github.com/git/git

 * [new ref]         refs/heads/master -> origin/master

Updating e83c516..a1b2c3d

Fast-forward

 ...

→

--depth=5 - Increases the shallow clone depth to include 5 commits.

Check the commit history again. Now you will see up to 5 recent commits because of the increased depth.

Terminal

git log --oneline

Expected Output

a1b2c3d Fix typo in README

9f8e7d6 Add new feature

7d6c5b4 Update docs

4c3b2a1 Improve tests

e83c516 Initial commit

→

--oneline - Shows each commit in one line for easy reading.

Key Concept

If you remember nothing else from this pattern, remember: shallow clones let you save time and space by downloading only recent commits instead of the full history.

Common Mistakes

Cloning without the --depth flag when only recent history is needed.

This downloads the entire repository history, wasting time and space.

Always add --depth 1 or another depth number to limit the clone size.

Trying to push changes from a shallow clone without fetching full history.

Git may reject pushes because the shallow clone lacks full commit context.

Fetch full history or unshallow the clone before pushing changes.

Assuming shallow clones have all branches and tags.

Shallow clones may miss some branches or tags because they only fetch limited commits.

Fetch specific branches or tags explicitly if needed after cloning.

Summary

Use git clone --depth 1 to get only the latest commit and save time and space.

Check your shallow clone history with git log --oneline to see limited commits.

Increase depth later with git fetch --depth=N to get more history if needed.

Practice

1. What does the --depth option do when used with git clone?

easy

A. It compresses the repository to save disk space.

B. It clones all branches including remote ones.

C. It creates a shallow clone with limited commit history.

D. It initializes a new empty repository.

Solution

1. Step 1: Understand the purpose of --depth

   The --depth option limits the number of commits cloned, creating a shallow copy.

2. Step 2: Compare with other clone types

   Unlike a full clone, a shallow clone saves time and space by copying recent commits only.

3. Final Answer:

   It creates a shallow clone with limited commit history. -> Option C

4. Quick Check:

   Shallow clone = limited history [OK]

Hint: Remember: --depth limits commit history depth [OK]

Common Mistakes:

• Thinking --depth clones all branches
• Confusing shallow clone with compression
• Assuming it creates an empty repo

2. Which of the following is the correct syntax to clone a repository with a depth of 5 commits?

easy

A. git clone --depth=5 https://example.com/repo.git

B. git clone -depth 5 https://example.com/repo.git

C. git clone --depth 5 https://example.com/repo.git

D. git clone --deep 5 https://example.com/repo.git

Solution

1. Step 1: Recall correct git clone syntax for depth

   The correct syntax uses --depth with an equals sign or a space and the number, like --depth=5 or --depth 5. Both are valid.

2. Step 2: Identify incorrect options

   git clone -depth 5 https://example.com/repo.git uses a single dash which is invalid. git clone --deep 5 https://example.com/repo.git uses an invalid flag --deep.

3. Final Answer:

   git clone --depth=5 https://example.com/repo.git -> Option A

4. Quick Check:

   Correct syntax = --depth=5 or --depth 5 [OK]

Hint: Use --depth=5 or --depth 5 for shallow clone [OK]

Common Mistakes:

• Using '=' instead of space after --depth (both valid but some prefer equals)
• Typing -depth instead of --depth
• Using --deep instead of --depth

3. What will be the output of the following commands?

git clone --depth 2 https://example.com/repo.git
cd repo
git log --oneline

medium

A. Shows commits from all branches.

B. Shows the full commit history.

C. Shows no commits because depth is too low.

D. Shows only the last 2 commits in the log.

Solution

1. Step 1: Understand shallow clone effect on history

   Using --depth 2 clones only the last 2 commits, so git log shows those.

2. Step 2: Analyze git log --oneline output

   This command lists commits in short form, limited to the shallow clone's depth.

3. Final Answer:

   Shows only the last 2 commits in the log. -> Option D

4. Quick Check:

   Depth 2 clone shows 2 commits [OK]

Hint: Shallow clone limits log to depth commits [OK]

Common Mistakes:

• Expecting full history in shallow clone
• Thinking no commits show if depth is low
• Assuming all branches' commits appear

4. You ran git clone --depth 3 https://example.com/repo.git but later need the full history. What should you do to fix this?

medium

A. Run git fetch --unshallow inside the cloned repo.

B. Delete the repo and clone again without --depth.

C. Run git clone --depth 0 to get full history.

D. Run git pull --depth=full to fetch all commits.

Solution

1. Step 1: Understand how to convert shallow clone to full

   Inside the shallow clone, running git fetch --unshallow downloads the full commit history.

2. Step 2: Evaluate other options

   Deleting the repo and cloning again without --depth works but is inefficient. Options C and D use invalid syntax or commands.

3. Final Answer:

   Run git fetch --unshallow inside the cloned repo. -> Option A

4. Quick Check:

   Use git fetch --unshallow to get full history [OK]

Hint: Use git fetch --unshallow to complete shallow clone [OK]

Common Mistakes:

• Trying to reclone instead of fetching full history
• Using invalid git pull options
• Assuming --depth 0 is valid

5. You want to clone a large repository but only need the last 10 commits of the main branch and no other branches. Which command achieves this efficiently?

hard

A. git clone --depth=10 https://example.com/repo.git

B. git clone --depth 10 --single-branch --branch main https://example.com/repo.git

C. git clone --branch main https://example.com/repo.git

D. git clone --shallow-since=10days https://example.com/repo.git

Solution

1. Step 1: Identify options to limit clone depth and branches

   Use --depth 10 to limit commits and --single-branch --branch main to clone only main branch.

2. Step 2: Check other options for correctness

   git clone --depth=10 https://example.com/repo.git clones all branches shallowly. git clone --branch main https://example.com/repo.git clones full history of main. git clone --shallow-since=10days https://example.com/repo.git uses invalid flag.

3. Final Answer:

   git clone --depth 10 --single-branch --branch main https://example.com/repo.git -> Option B

4. Quick Check:

   Depth + single branch = efficient clone [OK]

Hint: Combine --depth with --single-branch for focused clone [OK]

Common Mistakes:

• Not using --single-branch clones all branches
• Using invalid flags like --shallow-since
• Assuming --depth=10 clones only main branch