If you ever typed git reset --hard and felt the sudden urge to apologize to your repository you are in the right place. This short, slightly sarcastic git tutorial shows how to prepare the working tree before a hard reset then use git log and git reflog to inspect and recover git history when things get dramatic.

Prepare the working tree the boring but useful way

Think of this as the safety net you should have raised before doing something destructive. Use git status to see what is staged and what is untracked. If you have uncommitted work that you care about stash it or commit it.

• Check status with git status
• Stash uncommitted changes with git stash if you want to preserve work without committing
• Or commit to a quick local branch if you prefer an explicit record

Pro tip for the boldly lazy: create a throwaway branch before doing risky things. Branch management is the duct tape of version control.

Perform the hard reset and know what it does

When you run git reset --hard <commit> you move HEAD to that commit and force the index and working tree to match. That is efficient and merciless. Expect uncommitted changes to vanish unless they were stashed or committed first.

git reset --hard <commit-hash-or-ref>

This is great when you want to undo a messy experiment and get back to a known state. This is terrible when you ran it without looking. That is also why branches exist.

Inspect history with git log like a curious detective

git log is the flashlight for your commit history. Use a compact view to see relationships between branches and commits without scrolling for an hour.

• Graphical compact view: git log --graph --oneline --decorate
• Limit output when history is long: git log -n 20
• Search messages or authors with git log --grep="text" if you remember something about the commit

Make git log actually fun by experimenting with formats and aliases. You will spend less time guessing which branch did what and more time pretending you always planned it that way.

Recover a commit with git reflog when you forgot you were a hero

The reflog records where HEAD has been. If you accidentally nuked something with a hard reset it often holds the key to redemption.

git reflog
git reset --hard <reflog-hash>
# or create a branch at the hash
git branch rescue <reflog-hash>

Browse the reflog to find the pointer you need. Then either reset back to it or create a branch to preserve that state. The reflog is like the repository memory after a night you do not fully remember.

Quick recap and developer tips

• Check git status and stash or commit before running git reset --hard
• Use git log --graph --oneline --decorate to inspect git history quickly
• Search the reflog with git reflog to recover lost HEAD positions
• Create a branch for risky experiments and practice branch management

Final note for the brave and exhausted: git reset --hard is powerful and irreversible on uncommitted changes. Use it with the respect it demands and a backup if you can stomach the extra steps. Follow these developer tips and you will avoid most small tragedies and enjoy fewer frantic searches for lost commits.