If your repository looks like a teenager's bedroom then this guide is the violent but necessary intervention. We will walk through safe Git cleanup strategies that keep your history readable and your disk usage reasonable. No magic, no made up commands, just proven version control moves that save time and dignity.

Start with a quick inspection and stash your WIP

Before you do anything heroic take a breath and look around. Run git status and git diff to see what is actually different. That tells you if you are about to trash something important or just a few stray temp files.

If you have half finished work that you do not want to lose stash it instead of committing garbage into history. Use a descriptive message so your future self does not curse you.

git stash push -m 'WIP'

Stash keeps the working tree clean and gives you permission to run destructive commands without crying later.

Remove untracked files safely

Untracked files are often the main source of clutter. Do not blindly delete them. First run a dry run to preview what will be removed.

git clean -n -d

If the preview looks reasonable then remove the files with force.

git clean -f -d

The dry run shows what would be deleted so you avoid the classic facepalm moment of losing a file you actually needed.

Prune local branches without crying later

Branches pile up like receipts. Find branches already merged into your main branch and delete them. Replace main with your default branch name if needed.

git branch --merged main

That command lists merged branches. To remove a safe branch run

git branch -d branch-name

If a branch has diverged and you are absolutely sure you want it gone use

git branch -D branch-name

Always double check the branch name before using the capital D. It forces deletion even if commits would be lost.

Rewrite local commits the careful way

Local history can be cleaned up with interactive rebase when you want tidy commits for a pull request. But do not rebase published commits unless you enjoy merge conflicts and awkward conversations.

Create a quick safety net branch before you rewrite history.

git branch backup

Then run an interactive rebase to squash, edit or reorder recent commits.

git rebase -i HEAD~N

Replace N with the number of commits to review. Follow the interactive instructions to pick, squash or reorder. If anything goes wrong you can recover from the backup branch.

Compress the repository and prune unused objects

Over time unreachable objects and loose data bloat the repo. Run garbage collection to compress objects and free disk space. This can take a while on very large repositories so plan accordingly.

git gc --aggressive --prune=now

Prune stale remote references to keep your repo tidy.

git remote prune origin .

Those commands reduce disk usage and speed up common operations. They are standard repository maintenance moves for teams that do not want morning slow builds.

Quick checklist for safe cleanup

• Inspect changes with git status and git diff
• Stash unfinished work with git stash push -m 'WIP'
• Run a dry run before removing files with git clean -n -d
• Delete merged branches after review with git branch -d
• Create a backup branch before rebasing with git branch backup
• Compress and prune with git gc --aggressive --prune=now and git remote prune origin .

Automation and ongoing repository maintenance

Make cleanup boring and regular. Add a periodic job in your developer tools that runs git gc and prunes remote refs. Scripts that automate conservative cleanup save developer time and prevent the repository from looking like a dumpster.

Final thought Keep dry runs and backups as your ritual before any destructive command. These simple patterns for git cleanup protect history and keep your team from debugging slow machines and mysterious merge nightmares.