Day 26 – GitHub CLI (gh): Manage GitHub from Your Terminal Today I explored how to use the GitHub CLI to manage everything without leaving the terminal — from creating repos to handling PRs and issues. 💡 Key Learnings: Installed & authenticated gh Created and managed repositories directly from terminal Worked with issues (create, view, close) Created & merged pull requests without browser Explored GitHub Actions workflows using CLI Discovered powerful commands like gh api, gh alias, and gh search Biggest takeaway: No more context switching between terminal and browser — everything can be automated and managed efficiently using gh. #90DaysOfDevOps #DevOpsKaJosh #TrainWithShubham #GitHubCLI #DevOps #Automation #CLI #Git #LearningInPublic #CloudComputing #Scripting #DeveloperJourney

I just published my first blog on Git 🚀🚀 Most of us at some point have created files like this while working on a project: file.txt file1.txt file2.txt ................ and so on. Managing changes like this quickly becomes messy🤯 and it's hard to keep track of what changed and when. So i write a beginner friendly blog to explain Git in the simplest way using visuals and examples. 🔗 https://lnkd.in/g8frAPDe Would love your feedback 🙌🏻💚 #git #github #technology #devloper #webdev

devpath-idp update — Phase 6. For those following along: I've been building an internal developer platform from the ground up and sharing the progress here. Phase 5 was software templates. Phase 6 is where things got interesting. One of the trickier debugging lessons I've had so far: A workflow completing successfully doesn't mean it actually did what you think it did. Here's what happened. Phase 6 is about the Backstage scaffolder — the part where a developer fills out a form and it automatically creates a GitHub repo, sets up the structure, and registers the service in the catalog. Self-service provisioning. That's the goal. I ran the template. The scaffolder showed steps completing. No obvious errors in the UI. It looked like it worked. Then I checked GitHub. The repo was empty. Something in the workflow had failed silently. The scaffolder didn't crash — it just didn't finish what it started. The GitHub push step timed out somewhere in the middle, and the UI wasn't loud about it. What made this tricky was the noise around it. When I restarted the backend during earlier sessions, the browser was throwing auth errors and stale token warnings. Those looked serious. They weren't — they were just the browser catching up after a restart. The real failure was quieter and further downstream. That's the thing about debugging distributed workflows: the loudest errors are often not the important ones. The important one here was silent — a repo that existed but had nothing in it. I'm still working through the fix. But the shift in understanding matters: I stopped asking "why is there an error?" and started asking "did this actually complete end to end?" Those are very different questions. And in platform engineering, the second one is usually the right one to ask first. Progress so far: ✅ Phase 1 — Base platform setup ✅ Phase 2 — GitOps foundation ✅ Phase 3 — Backstage portal setup ✅ Phase 4 — Catalog basics ✅ Phase 5 — Software templates 🔧 Phase 6 — Self-service provisioning (in progress) More on this when it's resolved. 🔧 #Backstage #PlatformEngineering #DevOps #InternalDeveloperPlatform #GitHub #Debugging #CloudEngineering #devpath

Most Go developers are using GitHub Actions wrong — and it’s costing them speed, reliability, and clarity. I wrote this to break that pattern. The problem isn’t YAML. It’s the way we think about CI/CD. In this article, I walk through: – Why most pipelines become messy and fragile – The mindset shift from “scripts in YAML” → “clean orchestration” – How to structure Go workflows for speed, simplicity, and production reliability – What senior engineers do differently when designing CI Good CI isn’t about making builds pass. It’s about making systems trustworthy. If your pipeline feels slow, confusing, or brittle — this is for you. Read here: https://lnkd.in/dtYNh43T #golang #githubactions #devops #backend #softwareengineering #cicd

I stopped fearing Git the day I learned these 20 commands.....😎 . . Most of us learn `git init`, `git add .`, and `git push` but GitHub is so much more than that. Here’s a quick breakdown I’ve covered in the PDF I’m sharing today: `git init` - Start a new repo `git add .` - Stage all files `git commit -m "message"` - Save the snapshot `git push origin main` - Push to GitHub `git pull origin main` - Get latest changes `git checkout -b branch-name` - Create & switch to a new branch `git log` - View history `git reset --hard` - Rollback changes `git stash` - Save work temporarily `git clean -fd` - Delete untracked files & dirs `git cherry-pick` - Pick specific commits `git rebase` vs `git merge` - When to use what This PDF is your mini GitHub survival kit Don't forget to follow Swadesh Kumar for more 🔥 Comment "Github" and I’ll DM you the PDF Join the group for more hiring updates : https://lnkd.in/gkrqgy_s Tag a dev friend who still says “GitHub scary hai” 😅 #GitHub #GitCommands #CheatSheet #Git

Once I understood the core commands, everything changed, here is the GitHub Crash Course for you ....... . . If you're still stuck on "how to use GitHub properly"? Here's a simple breakdown that helped me (and will help you too): - Repository = Project folder (local or remote) - Commit = Save a snapshot of your changes - Branch - Parallel version of your project - Merge = Combine branches - Clone / Push/Pull = Sync local and remote repos Most Useful Git Commands (with purpose): git init: # Start a new Git repo git clone <url>: # Copy repo to your local system git status: # See current changes git add.: # Stage all files for commit git commit -m "msg": # Save changes with message git push: # Upload changes to GitHub git pull: # Fetch latest from GitHüb git branch: # List branches git checkout -b dev: # Create & switch to new branch git merge dev: # Merge dev into main Connect Swadesh Kumar for more such content Repost it to share in your network Save it if you don't wanna miss it Comment "GitHub" & I'll DM it to you directly. 👇Bonus Tips : ✅ Always write meaningful commit messages ✅ Never push directly to main in a team project ✅ Use .gitignore to avoid uploading junk files

Ever wanted to grab a subset of a Github repo and ended up downloading way more than you needed? That kept happening to me, especially with larger repos. So instead of working around it, I decided to understand how Git handles this under the hood. That led me to build GitSubset. It’s a small TUI tool that lets you: • Explore a repository’s file tree before downloading anything • Select specific files or folders • Download only what you need using Git’s sparse checkout While building it, I got to dive deeper into: • How Git handles repository data and checkouts • Sparse checkout and partial clones • Structuring and releasing a CLI tool (cross-platform installs, scripts, workflows) This wasn’t meant to be a showcase project, it came from a real need, and it ended up teaching me a lot more about Git internals and shipping tools than I expected. If you’ve ever needed just part of a repo, this might be useful: https://lnkd.in/dqkhkrSB Would appreciate any feedback or thoughts. #programming #softwareengineering #golang #opensource #devtools #git

Never Google "how to undo a git commit" again. 🛑💻 Whether you’re a junior dev just starting out or a senior engineer who still triple-checks their syntax, Git is your daily driver. Here are the 12 absolute essential commands you need to master to navigate your repositories like a pro. Pro Tip: Always run git status before you commit. Trust me, it saves lives. 😉 🔖 Hit BOOKMARK to keep this cheat sheet handy at your desk! 🚀 Share this with a friend who is learning to code! #LearnToCode #CodingBootcamp #Git #GitHub #TechTips

Every developer knows this loop: write a GitHub Actions workflow, push, CI fails, fix, push again, repeat 😒 Not fun. Not efficient. That's why I've been using act for my side projects. It runs your GitHub Actions workflows locally — before you push anything. It reads your .github/workflows/ files, spins up Docker containers that mirror the GitHub runner environment, and executes your jobs exactly as GitHub would. Two things I find particularly useful: it works as a local task runner to replace Makefiles, and there's a VS Code extension that lets you trigger workflows directly from the editor. https://lnkd.in/den8P42D #GitHubActions #DevTools #DeveloperProductivity #CI #DevOps

GitHub Rejected My Push — Here’s What I Learned Last week I ran into a frustrating issue while pushing my Reliant Carriers trucker logistics project to GitHub. I kept getting an error saying: “File exceeds GitHub's 100MB limit” After digging deeper, I realized the problem: I had accidentally committed my virtual environment (myenv/), which included a large file (~184MB). Why this is a problem Virtual environments contain installed dependencies and system-specific files. They are not meant to be tracked in version control and can quickly exceed GitHub’s file size limits. What I did to fix it Since the large file was already in Git history, simply deleting it wasn’t enough. I resolved it by: Removing the Git history (clean reset) Creating a .gitignore file to exclude myenv/ Reinitializing the repository Pushing a clean version to GitHub (force push - because I'm working alone,no branches.) Key lesson: Your repository should only contain your code — not your environment. For Python projects, always exclude: venv/ or myenv/ __pycache__/ And use a requirements.txt file to manage dependencies instead. This was a small challenge, but a valuable reminder of how Git actually tracks history — not just files. #SoftwareEngineering #Git #LearnSomethingNew #DevJourney