$
git statusDisplays the state of modified, tracked, and untracked files
Run this before staging files to verify exactly what changed.
Standard
Changes Transport Pipeline
Select any action arrow to inspect exact commands01
Working DirectoryYour local untracked files
02
Staging AreaPrepared for the next commit (Index)
03
Local RepositoryYour commit history (.git)
04
Remote RepositoryGitHub, GitLab, or origin server
Supplementary Workflows
Day-to-day essential concepts/
Move changes from the working directory to the Staging Area (Index).
$
git diffShows unstaged line-by-line code differences
Compares your working directory against the staging area.
Standard
$
git add Stages a specific file for the next commit
Example: git add index.html styles.css
Basic
$
git add .Stages all changes in the current directory and subdirectories
Includes modifications, new files, and deletions.
Basic
$
git add -pInteractive patch mode: review and stage hunk by hunk
Best practice for crafting clean, atomic commits.
Advanced
Capture a permanent snapshot from staging area into the local repository.
$
git commit -m "feat: clear message"Creates a new commit with a descriptive message
Follow conventions like Conventional Commits (feat, fix, docs, refactor).
Basic
$
git commit -am "message"Stages tracked files and commits in a single command
Does not include untracked new files created recently.
Standard
$
git commit --amendModifies the most recent commit (add changes or update message)
Use only before pushing your commit to a shared remote repository.
Advanced
$
git log --oneline --graph --decorateVisualizes commit history in a concise ASCII tree graph
Essential command to inspect branch divergence and HEAD location.
Standard
Upload your local commits to the shared remote repository.
$
git push origin Pushes local commits to the specified remote branch
Example: git push origin feat/login
Basic
$
git push -u origin Pushes and sets up upstream tracking for future shortcut pushes
After this, you can just run `git push` or `git pull` on this branch.
Standard
$
git push --force-with-leaseSafe force-push: overwrites remote only if no one else pushed new work
Always prefer this over destructive `git push --force`.
Standard
$
git push origin --delete Deletes a feature branch from the remote server after merging
Keeps the remote repository tidy and free of dead branches.
Standard
Retrieve changes from the remote server into your local environment.
$
git fetch originDownloads latest remote references without touching working files
Safe and non-destructive: updates origin/main without merge conflicts.
Standard
$
git pull origin Fetches remote changes and merges them immediately into current branch
Shorthand equivalent to: git fetch + git merge.
Basic
$
git pull --rebase origin Pulls remote changes and replays your local commits on top cleanly
Avoids cluttering the commit graph with unnecessary merge commits.
Advanced
Revert uncommitted modifications or move between commit snapshots.
$
git restore Discards uncommitted changes in working directory for a file
Irreversible action! Restores the file to the last committed state.
Standard
$
git restore --staged Unstages a file back into working directory without losing edits
The modern and clear replacement for the confusing `git reset HEAD <file>`.
Standard
$
git clean -fdRemoves untracked files and directories from your working tree
Always run `git clean -nd` first to dry-run and preview what will be erased.
Standard
Global Git configuration, identity, default branch, and aliases.
$
git config --global user.name "Your Name"Sets the author name associated with all your future commits
Configures your identity in ~/.gitconfig.
Basic
$
git config --global user.email "you@example.com"Sets the author email associated with your commits
Must match your GitHub/GitLab verified account email.
Basic
$
git config --global init.defaultBranch mainSets "main" as default branch name for all new repositories
Industry standard replacing legacy master naming.
Standard
$
git config --list --show-originDisplays all active Git configurations and where each file is located
Great for debugging SSH, credential helper, or user identity conflicts.
Standard
Create, navigate, rename, and manage isolated lines of development.
$
git branchLists all local branches and highlights active branch with asterisk
Use `git branch -a` to view remote tracking branches as well.
Basic
$
git switch Switches to an existing branch (modern recommended syntax)
Modern, unambiguous alternative to legacy `git checkout <branch>`.
Basic
$
git switch -c Creates a new branch and immediately switches into it
Example: git switch -c feat/user-authentication
Standard
$
git branch -d Safely deletes a local branch that has already been merged
Use -D with caution to force deletion of unmerged branches.
Standard
$
git branch -m Renames the currently checked out branch
Quickly fixes typos in branch names.
Standard
Integrate feature branches, resolve conflicts, and maintain clean linear history.
$
git merge Merges the specified branch into your current active branch
Creates a merge commit unless fast-forward is possible.
Basic
$
git merge --no-ff Forces creation of a merge commit even if fast-forward is possible
Preserves the historical boundary of a feature branch.
Standard
$
git rebase Replays current branch commits on top of base-branch tip
Creates a pristine linear history without merge bubbles.
Advanced
$
git rebase -i HEAD~3Interactive rebase: squash, edit, reorder, or drop last 3 commits
Clean up local WIP commits before opening a pull request.
Advanced
$
git merge --abortAborts an active merge process and resets files to pre-merge state
Your emergency escape button when merge conflicts get messy.
Standard
Temporarily shelve uncommitted work to switch context without committing.
$
git stashSaves uncommitted modifications into a temporary stash stack
Leaves working directory completely clean to switch branches.
Basic
$
git stash save "wip: working on checkout form"Saves changes with a clear descriptive message for later retrieval
Helpful when you have multiple stashes saved.
Standard
$
git stash popReapplies the most recent stashed changes and drops it from the stack
Restores your shelved changes right where you left off.
Basic
$
git stash listLists all currently saved stash entries in the repository
Displays stash@{0}, stash@{1}, etc.
Standard
$
git stash clearDeletes all stored stashes permanently
Use with caution: dropped stashes cannot be restored easily.
Standard
Recover discarded commits, unstage files, and travel back in time.
$
git reflogChronological safety diary of every HEAD movement in your repository
Your #1 tool to recover accidentally deleted branches or reset commits.
Advanced
$
git reset --soft HEAD~1Undoes last commit while keeping its changes staged in Index
Perfect for modifying a commit message or adding forgotten files.
Standard
$
git reset --hard HEAD~1Destroys last commit and wipes out its working directory changes
Dangerous! Only use if you are 100% sure you want to discard the work.
Standard
$
git revert Creates a new commit that records the exact inverse of a past commit
The safe and standard way to undo bugs already pushed to production.
Standard
Matches found across all command categories.
Interactive Playground
Live Terminal Simulator
Experience the Git lifecycle in real time. Run sample commands to watch terminal outputs and follow how changes progress through pipeline stages.
bash — git-demo@localhost: ~/my-project (main)
developer@pc:~/my-project (main)$ git status
On branch main Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) modified: src/app.js modified: public/styles.css Untracked files: (use "git add <file>..." to include in what will be committed) src/auth.js no changes added to commit (use "git add" to track)
developer@pc:~/my-project (main)$
Current state of your changes:
1. Working Directory
→
2. Staging Area
→
3. Local Repository
→
4. Remote
Visual Lab
Visual Branch Simulator: Merge vs Rebase
Observe how commits connect and reorder in real time when running merge or rebase operations in Git.
Master the Dreaded Conflict
Interactive Merge Conflict Resolver
Learn what actually happens when Git pauses during a merge or rebase. Practice resolving real code collisions and understand the <<<<<<< HEAD markers.
Merge conflict while updating authentication method and JWT token expiration window.
src/config/auth.tsUNRESOLVED
Terminal commands to finalize:
1
Stage resolved file
git add src/config/auth.ts2
Complete merge commit
git merge --continueSOS
Panic! Abort everything safely
git merge --abortBinary Search Bug Hunter
Git Bisect: Pinpoint the Buggy Commit
Find which exact commit introduced a bug in production using binary search O(log N). Step through bisecting good/bad revisions or automate with tests.
Status: Ready to start bisecting
Commit C8 is broken (bad) and C1 is verified working (good). Click Start to let Git bisect the midpoint.
C1
a1b2c3dfeat: setup base project structureC2
e4f5a6bfeat: add user login endpointC3
c7d8e9ffix: handle token expirationC4
1a2b3c4perf: optimize sql queries in authC5
5e6f7a8refactor: change payload signature in parserC6
9b0c1d2style: format response json outputsC7
3e4f5a6docs: update api swagger documentationC8
7b8c9d0feat: add analytics event pingInteractive History Rewriting
Interactive Rebase Playground (git rebase -i)
Experiment visually with interactive rebase. Reorder commits, squash bugfixes, reword messages, or drop commits without fear. Discover why Git recalculates SHA-1 hashes and creates a pristine linear history.
OrderAction (Command)HashCommit Message
.git/rebase-merge/git-rebase-todo (vim buffer)
# git-rebase-todo previewBefore Rebase (Old History):
After Rebase (Rewritten Clean History):
Golden Rule of Rebase:Never rebase commits that have already been pushed to a public or shared branch (e.g. main/production). Rebasing rewrites SHA-1 hashes, which forces other contributors into painful synchronization conflicts.
Git SOS — Rescue Mode
Messed Up? Here Is Your Safety Net
Git mistakes happen to everyone. Find your exact scenario and follow verified steps to recover your code without panicking.
Riesgo mediaramas
Committed directly to the wrong branch (e.g. main)
Move your latest commit to a new feature branch safely
Situación:
You made code changes and committed directly to the main branch instead of creating an isolated feature branch.
Pasos de solución:
1
git branch feat/my-correct-branchCreates the new feature branch pointer right at the current commit.
2
git reset --hard HEAD~1Rewinds main branch back by 1 commit, leaving main pristine.
3
git switch feat/my-correct-branchSwitches into your new branch where your commit is waiting untouched.
If you already pushed the commit to GitHub, avoid reset --hard; use `git revert` to create an audit-safe inverse commit.
Riesgo bajacommits
Typo in last commit message or forgot a file
Fix the most recent commit instantly
Situación:
You made a typo in the commit message or realized you forgot to stage one more file.
Pasos de solución:
1
git add forgotten-file.js(Optional) If you missed a file, stage it first with git add.
2
git commit --amend -m "feat: corrected descriptive message"Overwrites the message and absorbs staged files into the previous commit.
Only use --amend before pushing your commit to a remote shared repository.
Riesgo altaarchivos
Accidentally committed API keys, secrets, or .env
Remove sensitive files before deploying to production
Situación:
You staged and committed private credentials or secrets into your local Git repository.
Pasos de solución:
1
echo ".env" >> .gitignoreEnsures Git ignores future edits to the secret configuration file.
2
git rm --cached .envRemoves .env from Git tracking without deleting it from your local disk.
3
git commit -m "chore: remove sensitive env credentials from tracking"Records the removal in history.
If you already pushed secrets to GitHub, immediately rotate and revoke the compromised API keys in your provider dashboard.
Riesgo mediaconflictos
Merge conflicts got out of hand
Abort the merge and return to a clean working state
Situación:
You ran git merge, encountered dozens of conflict markers (<<<<<<<), and want to start over.
Pasos de solución:
1
git merge --abortCancels the merge in progress and cleanly restores all files.
If resolving an interactive rebase conflict, the equivalent command is `git rebase --abort`.
Riesgo altaramas
Accidentally deleted a branch or lost commits
Time travel rescue using the Git Reflog diary
Situación:
You deleted a branch thinking it was merged, or ran git reset --hard by mistake.
Pasos de solución:
1
git reflogDisplays a chronological ledger of every time HEAD moved in your repository.
2
git switch -c recovered-branch HEAD@{2}Creates a new branch pointing directly to the commit before the accidental deletion.
Git Reflog keeps orphaned commits for roughly 30 to 90 days before running garbage collection.
Team Workflow Guides
Step-by-Step Guided Workflows
Learn industry-standard procedures. Every step includes the exact terminal command and the mental model reasoning behind it.
Beginner
Publish First Repository to Cloud
Learn the exact initial sequence to turn a local directory into a cloud-hosted Git repo.
5Pasos clave
1
Initialize Git locally
Creates the hidden .git directory to begin version control.
$
git initModelo mental: Spawns a local ledger for this project folder.
2
Stage all initial files
Prepares your code in the Staging Area.
$
git add .Modelo mental: Packs everything into the first shipping crate.
3
Create genesis commit
Creates your initial permanent snapshot.
$
git commit -m "feat: initial project setup"Modelo mental: Seals the first milestone in your local history.
4
Link remote repository
Connects your local project with GitHub/GitLab origin URL.
$
git remote add origin https://github.com/user/my-repo.gitModelo mental: Establishes the communication conduit to the cloud.
5
Publish commits to remote
Uploads your main branch and sets upstream tracking.
$
git push -u origin mainModelo mental: Syncs your local safe to the cloud server.
Collaboration
Team Collaboration (Feature Branch Workflow)
The global industry standard for developers working in parallel.
4Pasos clave
1
Synchronize local main
Pull latest approved changes from teammates before branching.
$
git switch main && git pullModelo mental: Ensures you branch off the freshest codebase.
2
Create task branch
Open an isolated branch lane with a descriptive semantic name.
$
git switch -c feat/oauth-authenticationModelo mental: Isolates code so bugs never affect production main.
3
Stage and commit milestones
Record small, atomic units of work.
$
git add . && git commit -m "feat(auth): add google sign-in"Modelo mental: Provides clear check-ins for code reviewers.
4
Push and open Pull Request
Upload branch to GitHub to request team peer review.
$
git push -u origin feat/oauth-authenticationModelo mental: Shares your code for review without directly touching main.
Essential
Merge Conflict Resolution
Master how to identify, resolve, and commit when two people edit the same lines.
4Pasos clave
1
Identify colliding files
Git flags files with overlapping changes.
$
git statusModelo mental: Conflicted files are listed under "both modified".
2
Inspect conflict markers
Open file and look for <<<<<<< HEAD and >>>>>>> branch.
$
code <conflicted-file>Modelo mental: Decide which changes to keep, delete markers, and save.
3
Stage resolved files
Tells Git you resolved the differences.
$
git add <resolved-file>Modelo mental: Marks the conflict as settled in the index.
4
Finalize the merge commit
Completes the merge process cleanly.
$
git commit -m "merge: resolve conflicts with main"Modelo mental: Closes the conflict loop permanently.
Head to Head
Head-to-Head Comparisons
Clear up common Git confusion. Understand key technical differences, pros/cons, and the exact moment to use each option.
Option A
git fetch
Downloads latest commits, refs, and branches from the remote server WITHOUT altering your working directory files.
When to use:
When you want to see what your teammates pushed without risking merge conflicts in your active files.
Advantages:
- 100% safe and non-destructive
- Allows diffing against origin/main before integrating
Trade-offs / Caveats:
- Does not update your local branch files automatically
Option B
git pull
Executes git fetch and immediately merges remote changes into your current active local branch.
When to use:
When you want to update your local branch quickly and you know your working tree is clean.
Advantages:
- One-step convenience
- Saves time in routine updates
Trade-offs / Caveats:
- Can trigger unexpected merge conflicts while you are in the middle of coding
- Can create unnecessary merge bubbles if not using --rebase
Option A
git merge
Combines two independent branch histories by creating an explicit join commit with two parent commits.
When to use:
When closing a feature branch via Pull Request to preserve historical context of branch lifetime.
Advantages:
- Completely non-destructive
- Preserves exact chronological timestamps
Trade-offs / Caveats:
- Can clutter commit graph with noisy "Merge branch" commits
Option B
git rebase
Takes your feature commits and replays them one by one on top of the newest commit of the base branch.
When to use:
To clean up local commits before opening a Pull Request and keep history completely linear.
Advantages:
- Creates a pristine linear history
- Makes git bisect debugging much easier
Trade-offs / Caveats:
- Golden Rule: NEVER rebase a public branch already shared with others
Option A
git restore & reset
Affects the local working tree and index. Restore discards uncommitted file edits; reset moves branch pointers.
When to use:
To undo uncommitted mistakes or rearrange local unpushed commits.
Advantages:
- Cleans up your local workspace quickly
- Modern git restore prevents accidental checkout bugs
Trade-offs / Caveats:
- git reset --hard is destructive and deletes uncommitted work permanently
- Must never be used on branches already pushed to remote
Option B
git revert
Creates a brand NEW commit that applies the mathematically exact inverse of the commit you wish to cancel.
When to use:
Whenever a bug has already been pushed to main, GitHub, or production.
Advantages:
- 100% safe for shared public branches
- Never rewrites past history; adds a transparent audit record
Trade-offs / Caveats:
- Adds one more commit to the repository history
Option A
git switch
Modern command (Git 2.23+) designed with a single responsibility: navigate or create branches.
When to use:
Whenever you change branches or create a new branch using the -c flag.
Advantages:
- Intuitive syntax with zero ambiguity
- No risk of accidentally overwriting file content
Trade-offs / Caveats:
- Only handles branches (file restoration moved to git restore)
Option B
git checkout
Legacy multi-tool command that handled branch navigation and file discarding at the same time.
When to use:
Only in legacy tutorials or older systems with outdated Git binaries.
Advantages:
- Widely mentioned on older StackOverflow answers
Trade-offs / Caveats:
- Confusing syntax: a missed argument could wipe out a file instead of switching branches
- Deprecated in practice by the Git core maintainers
Smart Assistant
Assisted Command Generator
Fill in your parameters and get exact commands ready to paste into your terminal, following production-grade best practices.
Tool 1
Semantic Branch Name Builder
Create clean branches following conventional naming standards.
Command ready to run:
$
git switch -c feat/oauth-authenticationTool 2
First Repository Sequence
Generates the complete set of commands to publish a local project directly to GitHub in one run.
Complete script (5 steps):
Professional Standard
Conventional Commits Assistant
Learn to write clean, standardized messages following the Conventional Commits specification. Improves git log clarity and enables automated semantic releases and changelogs.
Generated commit command:
$
git commit -m "feat(auth): implement jwt token authentication"Error Prevention
Interactive .gitignore Generator
Prevent accidental leakage of secrets, API keys, or bulky folders like node_modules/. Select your stack and download a ready-to-use file.
Select your stack and tools:
.gitignore
Supercharged Terminal
Productivity Aliases & .gitconfig Vault
Senior developers do not retype repetitive commands. Configure high-speed aliases and battle-tested global flags directly in your ~/.gitconfig.
git lg
Visual, ultra-compact colored history graph formatted into one line per commit.
Expands to:
git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relativegit st
Short status display showing current branch and tracking relation to upstream.
Expands to:
git status -sbgit unstage
Unstages changes from the index without discarding local working tree edits.
Expands to:
git restore --stagedgit undo
Undoes the most recent commit while keeping all changes staged in the index.
Expands to:
git reset --soft HEAD~1git amend
Stages modifications into the previous commit without opening the message editor.
Expands to:
git commit --amend --no-editgit br
Lists local branches with their latest commit SHA, message, and remote tracking status.
Expands to:
git branch -vvgit cleanup
Safely deletes all local branches that have already been merged into the active branch.
Expands to:
git !git branch --merged | grep -v "\*" | xargs -n 1 git branch -dgit wip
Quickly creates a temporary snapshot commit for uncommitted work in progress.
Expands to:
git !git add -A && git commit -m "chore: work in progress [skip ci]"~/.gitconfig
Optimized template including automatic branch rebasing, branch defaults, and reuse of recorded conflict resolutions (rerere).
[init]
defaultBranch = main
[pull]
rebase = true
[rerere]
enabled = true
[core]
autocrlf = input
[color]
ui = auto
[help]
autocorrect = 1
[alias]
st = status -sb
lg = log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative
undo = reset --soft HEAD~1
unstage = restore --staged
amend = commit --amend --no-edit
br = branch -vv
cleanup = !git branch --merged | grep -v "\\*" | xargs -n 1 git branch -d
wip = !git add -A && git commit -m "chore: work in progress [skip ci]"Defensive Engineering
Git Hooks & Quality Automation Hub
Prevent bugs, unformatted code, and leaked .env secrets before they ever touch your repository. Copy production-tested hook scripts.
pre-commitClient-side
Security audit and linter check before commit creation
Runs before the commit message editor opens. If it exits with a non-zero code, the commit is aborted immediately.
.git/hooks/pre-commit
#!/bin/sh
# 1. Prevent accidental .env secrets commit
if git diff --cached --name-only | grep -E "(^|/).env"; then
echo "ERROR: Attempted commit of sensitive .env file detected!"
echo "Unstage it using: git reset HEAD .env*"
exit 1
fi
# 2. Run linter on staged files
echo "Running code quality checks..."
npm run lint-staged || exit 1commit-msgClient-side
Enforce Conventional Commits specification
Receives the path to the temporary commit message file. Validates that it matches feat:, fix:, docs:, chore:, etc.
.git/hooks/commit-msg
#!/bin/sh
MSG_FILE=$1
COMMIT_MSG=$(cat "$MSG_FILE")
# Validate format: type(scope)?: description
REGEX="^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([a-z0-9_-]+\))?: .+"
if ! echo "$COMMIT_MSG" | grep -qE "$REGEX"; then
echo "ERROR: Invalid commit message format!"
echo "Required format: feat(auth): imperative summary"
exit 1
fipre-pushClient-side
Ensure all tests pass before sending data to remote
Runs immediately before transmitting data to the remote origin server during git push. Prevents broken commits from reaching CI/CD.
.git/hooks/pre-push
#!/bin/sh
echo "Running automated test suite before pushing..."
npm test -- --bail
if [ $? -ne 0 ]; then
echo "ERROR: Tests failed. The push was aborted to protect the remote branch."
exit 1
fiModern Workflow
Configure Automated Hooks with Husky
Rather than manually managing local .git/hooks (which are not tracked by Git), modern web teams use Husky to commit hook configurations directly to the repository.
Terminal (Node.js / NPM)
# 1. Instalar Husky en tu proyecto moderno
npx husky init
# 2. Agregar hook de pre-commit para linter y secretos
echo "npx lint-staged" > .husky/pre-commit
# 3. Agregar hook para validar Conventional Commits
echo "npx --no -- commitlint --edit $1" > .husky/commit-msgUnder The Hood
Git Object Anatomy & Plumbing Internals
Git is not magic—it is a simple cryptographic content-addressable directed acyclic graph (DAG). Discover how Blobs, Trees, Commits, and References work under the surface.
A Blob stores only raw compressed bytes of a file using zlib. It does not store file names, permissions, or timestamps—only raw payload addressed by its cryptographic SHA-1 hash.
Object Graph Linkage (DAG):
Commitf4a1209
➔Tree (root)83ba6fc
➔Blob70a34b2
Did you know?A Git branch like main is simply a 41-byte plain text file inside .git/refs/heads/main containing the SHA-1 of the latest commit.
$
git cat-file -p 70a34b2SHA-1 / SHA-256 HASH:
70a34b220377e8a93da26042e9154a43c7b3992dDecompressed Object Payload:
console.log("Hello World!");
export const API_KEY = "secure_token";Mental Dictionary
Visual Glossary of Key Concepts
Git has its own jargon. Here are technical definitions translated into everyday real-world metaphors so you never forget what each concept represents.
punteros
HEAD
Technical definition:
A symbolic pointer referencing the most recent commit on the currently active branch in your repository.
git show HEADpunteros
Detached HEAD
Technical definition:
A state where HEAD points directly to a specific commit hash rather than a named branch. Any new commits will be lost if you switch away without creating a branch.
git switch -c rescue-changesremotos
Origin & Upstream
Technical definition:
"origin" is the default alias assigned to the remote repository you cloned. "upstream" is typically the alias for the main source repo when collaborating on open-source.
git remote -vestructuras
Commit Hash (SHA-1 / SHA-256)
Technical definition:
A unique 40-character alphanumeric checksum calculated from the file tree snapshot, author, date, and parent commit.
git log --onelineestructuras
Working Tree
Technical definition:
The actual unpacked files and directories in your local filesystem that you are editing right now.
git statusestructuras
Staging Area (Index)
Technical definition:
An intermediate preparation layer where changes are formatted and curated before forming the next commit.
git add <file>operaciones
Fast-Forward Merge
Technical definition:
A merge where the target branch has no diverging commits, allowing Git to move the branch pointer forward without generating a merge commit.
git merge --ff-onlyoperaciones
Cherry-Pick
Technical definition:
A command that copies and reapplies the exact patch introduced by a specific commit from any branch into your current branch.
git cherry-pick <commit-hash>operaciones
Squash (Commit Collapsing)
Technical definition:
The process of combining multiple small or WIP commits into a single cohesive commit before merging into main.
git merge --squash <branch>punteros
Reflog (Reference Logs)
Technical definition:
A local safety journal that records every time HEAD changed position, enabling recovery of deleted branches and lost commits.
git reflogTest Your Knowledge
Interactive Mini Challenges
Test your intuition about Git workflows with these practical scenarios.
Your score:
0/ 5
Scenario:
You edited "styles.css" and ran "git add styles.css", but realized you are not ready to commit it yet.
Which modern command unstages "styles.css" without losing your written code?
Technical explanation:
Scenario:
You want to create a branch named "feat/profile" and switch to it immediately in a single step using modern Git syntax.
What is the recommended command according to current Git official documentation?
Technical explanation:
Scenario:
You are working on a feature and your manager asks you to urgently review a hotfix on main. You have unfinished code and do not want to create an ugly WIP commit.
How can you temporarily shelve your uncommitted work safely?
Technical explanation:
Scenario:
A commit introduced a critical production bug and is already merged into the public "main" branch on GitHub.
What is the safest, team-friendly command to undo this change in production?
Technical explanation:
Scenario:
You just ran "git commit -m 'fix: responsive header'" and immediately realized you forgot to stage "header.css".
How do you absorb "header.css" into the commit you just made without creating a second commit?
Technical explanation: