Master Git with these simple commands

Git commands every developer should know with cheatsheet https://lnkd.in/gMNpS-YK 1. Git Setup and Configuration git config --global user.name "Your Name" git config --global user.email "your.email@example.com" git config --listView all Git configurations git config --global core.editor "code --wait" 2. Starting a Repository git init Initialize a new Git repository git clone <repo_url> Clone an existing repository git remote add origin <repo_url>Connect local repo to remote git remote -v View configured remotes 3. Working with Files git status Check repo status (modified, staged, etc.) git add <file>Stage a specific file git add .Stage all changes git restore <file> Discard changes in working directory git diff View unstaged changes git diff --stagedView staged changes 4. Committing Changes git commit -m "message" Commit staged changes git commit -am "message" Add and commit tracked files in one step git log View commit history git log --oneline --graph --decorate --all Pretty, compact commit graph git show <commit_id> Show details for a specific commit 5. Branching & Merging git branch List all branches git branch <name> Create a new branch git switch <branch> / git checkout <branch> Switch to another branch git merge <branch> Merge a branch into the current one git branch -d <branch> Delete a local branch git branch -m old_name new_name Rename a branch 6. Working with Remotes git fetch Download changes from remote (no merge) git pull Fetch + merge changes git pull --rebase Fetch + rebase changes git push Push commits to remote git push -u origin <branch> Set upstream branch for first push git push origin --delete <branch> Delete a remote branch 7. Undoing Changes git reset <file> Unstage a staged file git reset --hard Reset to last commit (destroy local changes) git reset --hard <commit_id> Reset to a specific commit git revert <commit_id> Create a new commit undoing previous commit git restore --source=HEAD <file>Restore a file to last commit state 8. Stashing (Temporary Save) git stash Save uncommitted changes temporarily git stash lis tList all stashes git stash apply Reapply last stash git stash pop Apply and remove stash git stash drop Delete a specific stash 9. Tagging (for Releases) git tag List tags git tag <name> Create a lightweight tag git tag -a <name> -m "message" Create an annotated tag git push origin <tag> Push tag to remote git push origin --tags Push all tags 10. Inspection & Debugging git blame <file> Show who changed each line and when git log -S <keyword> Search commits containing a specific keyword git grep <pattern> Search across files git bisect Find the commit that introduced a bug Watch my youtube channel - https://lnkd.in/gkB27ZDF Connect with me on Instagram - https://lnkd.in/gYG3QNfh PS: Do share and save the post with your friends and community and follow Praveen Singampalli for any job help

Git strategy cheat sheet that I believe will be a valuable resource for everyone… It helps streamline our workflow and improve our understanding of GIT.

GitHub का उपयोग कैसे करें - शुरुआत से अंत तक Complete Guide 🚀 pages 7 🔟 Best Practices (अच्छी आदतें) Commit Messages ✅ Good Examples: Add user authentication feature Fix navbar alignment on mobile Update README with installation steps Remove deprecated API endpoints Refactor database connection logic ❌ Bad Examples: update changes fix asdf ... Format: Type: Brief description (50 chars) Detailed explanation (if needed) - What was changed - Why it was changed - How it affects the system Types: feat: नई feature fix: Bug fix docs: Documentation style: Formatting refactor: Code restructure test: Tests chore: Maintenance Branch Naming ✅ Good Names: feature/user-login fix/navbar-bug hotfix/security-patch docs/api-documentation refactor/database-queries ❌ Bad Names: test new-branch my-branch branch1 Regular Habits Daily: [ ] Morning में git pull करें [ ] छोटे और frequent commits करें [ ] Clear commit messages लिखें [ ] Day end में push करें Weekly: [ ] README update करें [ ] Old branches delete करें [ ] Dependencies update करें Before Push: [ ] Code test करें [ ] Console errors check करें [ ] Unwanted files remove करें [ ] .gitignore update करें 1️⃣1️⃣ Quick Reference Commands Daily Use Commands # Repository setup git clone <url> # Download repository git init # New repository बनाना # Basic workflow git status # Changes देखना git add . # सभी changes add करना git add filename.txt # Specific file add करना git commit -m "message" # Commit करना git push origin main # Upload करना git pull origin main # Download करना # Branch operations git branch # Branches list git branch branch-name # New branch git checkout branch-name # Branch switch git checkout -b branch-name # Create + switch git merge branch-name # Branch merge करना git branch -d branch-name # Branch delete # Undo operations git restore filename.txt # File changes discard git restore --staged filename.txt # Unstage file git reset --soft HEAD~1 # Last commit undo git reset --hard HEAD~1 # Last commit + changes undo # Information git log # Commit history git log --oneline # Short history git diff # Changes देखना git remote -v # Remote URLs # Stash (temporary save) git stash # Changes save git stash pop # Changes restore git stash list # Stash list click on next post

💻 The Ultimate Git Command Cheat Sheet  "Git is an essential tool for every developer, powering everything from version control to CI/CD pipelines. Below is a comprehensive list of must-know Git commands with concise explanations:" 🧩 Setup & Config Configure your identity and preferences. git config --global user.name "Your Name" git config --global user.email "you@example.com" git config --list      # View configuration 🏁 Repository Basics git init             # Create a new repo git clone <url>       # Copy a remote repo git status          # Check file status git add .            # Stage all changes git commit -m "message"  # Commit changes git log --oneline      # View commit history 🌿 Branching & Merging git branch       # List branches git branch feature/login     # Create a branch git checkout feature/login   # Switch to branch git merge feature/login    # Merge into current branch git merge --abort      # Cancel merge conflict git branch -d feature/login   # Delete branch 🚀 Remote Repositories git remote -v       # Show remotes git fetch origin      # Download updates git pull origin main     # Pull + merge updates git pull --rebase origin main   # Rebase instead of merge git push origin main     # Push commits git push --set-upstream origin feature/api # Push new branch 🧰 Undo & Fix git revert <commit>    # Undo a commit safely git reset --soft <commit>   # Undo, keep staged git reset --hard <commit>   # Undo completely git restore <file>    # Restore file git checkout <commit> -- <file> # Get old version of file 🍒 Cherry-Pick (Selective Commit) Apply specific commits from another branch. git cherry-pick <commit> 📦 Stash (Temporary Save) Save your current work to switch tasks quickly. git stash       # Save uncommitted changes git stash list     # View stashes git stash apply     # Reapply stash git stash drop     # Delete stash 🧠 Rebase & Squash Clean up your history and combine commits. git rebase main     # Move commits onto another branch git rebase -i HEAD~3    # Interactive squash/fixup 🔍 Bisect (Find Bugs Fast) Identify the exact commit that introduced a bug. git bisect start git bisect bad     # Mark current commit bad git bisect good <commit>   # Mark old commit good git bisect reset     # End bisect 🧹 .gitignore Exclude files and folders you don’t want to track. node_modules/ *.log .env __pycache__/ git rm -r --cached .    # Remove tracked ignored files 🔔 Webhooks (Automation) Webhooks let Git repos trigger CI/CD or notifications automatically. #Git #GitCheatSheet #DevOps #SoftwareEngineering #VersionControl #CodingTips #Programming #Developers #OpenSource #Productivity #Cloud #TechCommunity #Learning #CodeQuality #CI/CD #GitHub #TechTips

🌿 Branch creation & switching Best practices: git checkout -b feature/my-task  # create and switch in one # (or with modern Git) git switch -c feature/my-task Why: git checkout -b both creates the branch and moves HEAD there — a simple and safe way to isolate new work. 🔍 git log, git status — branch-specific views > git log shows the commit history from the commit your current branch points to; different branches may show different histories. Useful flags I used: git log --oneline --graph --decorate >git status shows untracked, staged, and unstaged changes for your current working tree — super helpful to avoid accidental commits. 🧰 git stash — emergency pause without committing Real scenario: you’re midway through work, a production hotfix arrives — you don’t want to commit unfinished work. Commands: git stash     # stash tracked changes git stash -u   # stash including untracked files (useful if you created new files) git stash list  # see stashed entries git stash pop   # restore the most recent stash and remove it from stash list # or git stash apply  # restore but keep the stash entry Important note: git stash -u hides untracked files from git status until you pop/apply them — they’re safely tucked away. 🔗 Commit hashes & branching from history I practiced using commit hashes to navigate and branch from past states: Create a branch from an older commit: git checkout -b fix-from-old-commit <commit-hash> # or git branch new-branch <commit-hash> git checkout new-branch That branch begins at the snapshot represented by <commit-hash>. After making changes you can merge back to main: git checkout main git merge fix-from-old-commit This helped me see how Git’s DAG (commit graph) works — commits are immutable snapshots, and branches are just movable pointers to commits. ✅ Final tips & precautions Always confirm your current branch: git branch --show-current or git status. Use git push origin HEAD:main only when you intend to update main from a non-main branch. Otherwise prefer git push origin <branch> or set upstreams. Protect main in remote repositories (branch protection rules) — don’t push directly to it in shared repos unless it’s intentional. Use descriptive branch names: feature/<ticket-id>-short-description. Use git log --graph --all to visually inspect how branches diverged and merged. #Git #GitCommands #VersionControl #DevOps #SoftwareEngineering #CodingJourney #LearningInPublic #100DaysOfCode #TechLearning #ProgrammersLife #DeveloperTools #SoftwareDevelopment #CodeNewbie #EngineeringExcellence #TechCommunity

I wasted 3 months with the wrong Claude Code setup. Here are 5 mistakes I made (so you don't have to): ❌ Mistake #1: Global MCPs Everywhere I enabled every MCP globally. Database connector. File system. Web search. API tools. Result: Context window full before actual work started. ✅ Fix: Project-level MCPs only. Enable on demand. Saved 40% of context for actual prompts. ❌ Mistake #2: One Workspace for Everything Mixed content creation with code development. Client projects with personal experiments. Business strategy with technical POCs. Result: Config conflicts. Constant context switching. Messy git history. ✅ Fix: 3 separate workspaces. - Operation/Strategy - Exploration - Building Each with isolated `.claude/` config. ❌ Mistake #3: Jumping to Agents 78% of developers use AI tools. I wanted to be in the cutting-edge 23% using agents. But I didn't have solid workflows yet. Result: Agents doing inconsistent work. More time debugging than building. ✅ Fix: Build skills first. Agents later. 15 custom skills now handle 80% of my needs. Consistent. Repeatable. Shareable. ❌ Mistake #4: Ignoring Git "I'll just save files locally." Then Claude accidentally deleted an entire directory. Lost 4 hours of work. ✅ Fix: Git for everything. Commit every 30-60 minutes. Push every 2-3 hours. GitOps = life insurance for your work. ❌ Mistake #5: No Backup Tool Claude sessions maxed out mid-project. Deadline in 2 hours. No backup plan. Result: Panic, stress, missed deadline. ✅ Fix: Codex or GLM as backup + `claude-code-switch` tool. Switch configs in 10 seconds. Zero downtime. Like having a spare tire in your trunk. The Pattern I Noticed All my mistakes had one thing in common: Optimizing for features instead of foundation. Global MCPs = more features, less usable context. Single workspace = more flexibility, less organization. Agents first = more automation, less consistency. What Actually Works → Start simple: Add complexity only when needed. → Separate concerns: Different workspaces for different purposes. → Foundation first: Skills before agents. Workflows before automation. → Git everything: Your future self will thank you. → Plan for failure: Backup tools, version control, recovery strategy. My Current Results After fixing these mistakes: - 2-3 hours saved daily - Zero data loss in 6 months - 15 reusable custom skills - Consistent output quality - Actually shipping instead of configuring What Mistakes Are You Making? Using global MCPs? No git workflow? Jumping to agents too early? Share your lessons in the comments. 👇 Let's learn from each other's mistakes. #ClaudeCode #LessonsLearned #DeveloperProductivity #AITools #WorkflowOptimization

Complete Git road map with working flow🔥 1.Core: •  git init •  git clone •  git add •  git commit •  git status •  git diff •  git checkout •  git reset •  git log •  git show •  git tag •  git push •  git pull 2.Branching: •  git branch •  git checkout -b •  git merge •  git rebase •  git branch --set-upstream-to •  git branch --unset-upstream •  git cherry-pick 3.Merging: •  git merge •  git rebase 4.Stashing: •  git stash •  git stash pop •  git stash list •  git stash apply •  git stash drop 5.Remotes: •  git remote •  git remote add •  git remote remove •  git fetch •  git pull •  git push •  git clone --mirror 6.Configuration: •  git config •  git global config •  git reset config 7. Plumbing: •  git cat-file •  git checkout-index •  git commit-tree •  git diff-tree •  git for-each-ref •  git hash-object •  git ls-files •  git ls-remote •  git merge-tree •  git read-tree •  git rev-parse •  git show-branch •  git show-ref •  git symbolic-ref •  git tag --list •  git update-ref 8.Porcelain: •  git blame •  git bisect •  git checkout •  git commit •  git diff •  git fetch •  git grep •  git log •  git merge •  git push •  git rebase •  git reset •  git show •  git tag 9.Alias: •  git config --global alias.<alias> <command> 10.Hook: •  git config --local core.hooksPath <path> 11.Experimental: (May not be fully Supported) •  git annex •  git am •  git cherry-pick --upstream •  git describe •  git format-patch •  git fsck •  git gc •  git help •  git log --merges •  git log --oneline •  git log --pretty= •  git log --short-commit •  git log --stat •  git log --topo-order •  git merge-ours •  git merge-recursive •  git merge-subtree •  git mergetool •  git mktag •  git mv •  git patch-id •  git p4 •  git prune •  git pull --rebase •  git push --mirror •  git push --tags •  git reflog •  git replace •  git reset --hard •  git reset --mixed •  git revert •  git rm •  git show-branch •  git show-ref •  git show-ref --heads •  git show-ref --tags •  git stash save •  git subtree •  git tag --delete •  git tag --force •  git tag --sign •  git tag -f •  git tag -l •  git tag --verify •  git unpack-file •  git update-index •  git verify-pack •  git worktree ------------------- END ------------------ Some good resources to Learn Git faster ☺️ 1.Git Official Documentation: https://git-scm.com/doc 2.GitHub Learning Lab: https://rb.gy/ksc45f 3.Codecademy Course https://lnkd.in/g-87iUdn 4. Pro Git: by Scott Chacon [Book] https://lnkd.in/gecriC8P 5. YouTube • FreeCodeCampOrg- beginer https://rb.gy/ljxt5s • FreeCodeCampOrg- Intermediate https://rb.gy/1x6mc • Programming with mosh https://rb.gy/vfkom --------------------------------------------- Feel free to add anything I missed 😊🌱 Also Checkout my friend YouTube channel, your support would be great helpful for me👇 https://lnkd.in/gJVpRAtv Follow @varsha varsha for more #git #github #githubproject #githubuniverse

update: Claude Code has checkpoints. Thanks for the corrections. Either it didn't have them when I first used it (it's been a bit) or it did and I just missed them. 🙂 Hello AI-assisted coders! I have another tip to share. I have used Claude Code, Cline, and Kiro over this past year. One thing that both Kiro misses but Cline has is checkpointing built in before changes. I found an easy way to correct that, though not with the same GUI accessibility as Cline has to restore the chat and/or files to that point in time. Add this to whichever steering file you use: ------------------markdown for wherever you save this sort of thing---------- ## Git Checkpointing Protocol **CRITICAL**: Before every file modification operation, create a checkpoint: ```bash git add [filename] && git commit -m "checkpoint: [brief description of change]" ``` Examples: - `git add src/api.py && git commit -m "checkpoint: add user authentication endpoint"` - `git add tests/test_auth.py && git commit -m "checkpoint: create authentication tests"` - `git add package.json && git commit -m "checkpoint: update dependencies"` This provides granular rollback points and change tracking during development sessions. -----end markdown---------------------------- I discovered this because I just started using Atlassian Rovo Dev on a personal project. It's a lot like Claude Code, but also offers GPT5 in addition to Sonnet 4 and 4.5. I'm guessing there might be a way to BYO model provider but I haven't gotten there yet (another update: no byo models yet in rovo dev). I'm really liking it so far. Being from Atlassian, it's hooked into Jira for task tracking and Confluence for documentation, rather than local markdown files for both. I could see this providing immediate benefits for teams. It might be my new favorite on my personal laptop, Kiro being the favorite I use on my AWS laptop right now. I'm definitely adding this "git bit" to my Kiro steering as well. :) Rovo created the steering instructions above, by the way. Your assistant could do similarly, so you might as well set it up so you can roll back to any change if your assistant of choice doesn't do this yet. #AICoding #AIDLC #AIDevelopmentLifecycle #Git #checkpoints #help with #AISlop

Git Commit Messages: Why "fixed bug" Is Killing Your Team Your commit history is documentation. Not an afterthought. Not a formality. It's the story of why your code exists. And messages like "fixed bug" or "updates" are destroying your team's ability to understand that story. The Problem Six months from now, someone (probably you) will ask: "Why did we change this?" If your commit says "fixed stuff", you've lost that context forever. No git blame. No PR link. No explanation. Just archaeological mystery in your own codebase. Bad commit messages are technical debt. Red Flags in Your Commit History 🚩 "fixed bug" (which bug? how?) 🚩 "updates" (what updates?) 🚩 "WIP" never cleaned up 🚩 "asdfasdf" (smashing keyboard) 🚩 "final version" followed by "final version 2" 🚩 100 files changed in one commit 🚩 Commit messages copied from PR title 🚩 No context about why, only what What Makes a Good Commit Message The formula: [Type] Brief summary (50 chars max) Why this change was needed What approach was taken Any context future you needs Fixes #123 ``` **Types that help:** - feat: New feature - fix: Bug fix - refactor: Code restructure - docs: Documentation - perf: Performance improvement - test: Test updates ## Bad Commits vs Good Commits **Bad:** ``` fixed bug updated code changes removed stuff ``` **Good:** ``` fix: Prevent duplicate email registration Users could register with same email twice due to race condition in validation. Added unique constraint at database level and concurrent test coverage. Fixes #456 The difference? One is useless archaeology. The other is living documentation. Best Practices Checklist ✅ Write in imperative mood ("fix bug" not "fixed bug") ✅ Explain WHY, not just WHAT ✅ Keep subject line under 50 characters ✅ Leave blank line before body ✅ Wrap body at 72 characters ✅ Reference issue/ticket numbers ✅ One logical change per commit ✅ Write for your future self The "Why" Matters Most Code shows WHAT changed. Commit message explains WHY. What: Removed caching layer Why: Cache was causing stale data in checkout, impacting revenue The why is what saves hours of debugging later. Quick Commit Message Test Before committing, ask: Can someone understand this without seeing the diff? Does it explain why, not just what? Would this help during a production incident? Will I understand this in 6 months? If no—rewrite it. The Bottom Line Commit messages are for humans, not compilers. Write them like you're explaining to a teammate who'll maintain this code next year. Because you probably will be that teammate. Good commits take 30 extra seconds. They save hours later. Your turn: What's the worst commit message you've seen in a codebase? Hit reshare ♻️ to improve how teams document code changes. #Git #SoftwareEngineering #CommitMessages #CodeQuality #VersionControl #DeveloperLife #Programming #CleanCode #BestPractices #SoftwareDevelopment #EngineeringCulture #TechCommunity

Solving the SpecKit Update Problem: Preserving Customizations  I'm excited to release an open-source Claude Code skill that addresses a critical pain point for teams using GitHub's SpecKit framework.  The Challenge:  SpecKit is an excellent tool for specification-driven development, but keeping templates up-to-date has been problematic. The standard update approach (specify init --force)  overwrites all customizations, forcing teams to choose between:  - Staying on outdated templates  - Manually merging changes (time-consuming and error-prone)  - Losing valuable customizations  The Solution:  I've developed a Claude Code skill that makes SpecKit updates safe, automated, and reversible:  🔍 Smart Detection - Uses normalized file hashing to identify customizations vs. official templates  🔀 Conflict Resolution - Integrates with VSCode's 3-way merge editor for guided conflict resolution  📦 Automatic Backups - Creates timestamped backups with retention management  ⚡ Fail-Fast Safety - Automatically rolls back on any error  📊 Version Tracking - Maintains a manifest of installed versions and file states  Technical Implementation:  - 6 PowerShell 7+ modules with clear separation of concerns  - 7 specialized helper functions for workflow orchestration  - Comprehensive test suite (132 passing tests with Pester 5.x)  - CI/CD pipeline with GitHub Actions  - Full specification documentation and implementation plan  Key Features:  ✅ Dry-run mode to preview changes ✅ Selective updates preserving customizations ✅ Custom commands never overwritten ✅ Integration with GitHub Releases API ✅ Context-aware UI (VSCode or terminal)  Use Case:  Ideal for development teams using:  - Specification-driven development practices  - Claude Code for AI-assisted development  - SpecKit for project structure and workflow management  Get Started:  Repository: https://lnkd.in/gBmR_tfT  Installation is straightforward—clone to your Claude Code skills directory and restart VSCode.  Contributions and feedback are welcome! If your team uses SpecKit, I'd love to hear about your update workflow challenges.  #SoftwareDevelopment #DevOps #OpenSource #ClaudeCode #SpecificationDriven #PowerShell #DeveloperTools