The Stack’s Post

🚀 Day 93 of #1000DaysOfCoding Today was less about coding… and more about becoming a real developer. I finally moved my full-stack project from local to GitHub — sounds simple, but the journey was full of real-world challenges: 💥 Faced Git errors like large file limits 💥 Accidentally pushed node_modules (never again 😅) 💥 Learned why .gitignore is not optional 💥 Understood how Git actually tracks history (not just files) 💥 Fixed branch & remote issues like a pro And the best part? ✅ Clean repo structure ✅ Proper version control setup ✅ Ready for deployment 🚀 This wasn’t just “uploading code” — It was understanding how developers actually work in production. 💡 Small lesson: If your code works locally but you can’t version or deploy it — you’re not done yet. Next step: 👉 Deploying this project live (Frontend + Backend + DB) Let’s see how it goes 🔥 #1000DaysOfCoding #Day93 #Git #GitHub #FullStackDevelopment #SpringBoot #ReactJS #MongoDB #LearningInPublic #DeveloperJourney

GitHub just officially entered the stacked PRs game - and it's a big deal. 🎉 If you've never heard of stacked PRs, here's the idea: instead of one massive pull request that's painful to review, you break your changes into a chain of smaller, focused PRs that build on each other. Each layer is independently reviewable. CI runs on all of them. Branch protection rules apply across the whole stack. And when you're ready, you can merge the entire thing in one click. GitHub's new native implementation includes: - A visual stack map right in the PR UI - The gh stack CLI for managing branches, rebases, and pushes - Merge queue support that's stack-aware - Auto-rebase of remaining PRs after a merge No more rebase hell. No more wondering if CI is passing for mid-stack PRs. No more losing review context on a 2,000-line diff. The concept isn't new. Facebook built Phabricator around stacked diffs back in 2011. Tools like Graphite have offered this on GitHub for years. But having it natively supported changes things. The bottleneck in modern development is no longer writing code - it's reviewing it. Currently in private preview. Worth joining the waitlist if you work on large codebases or fast-moving teams. #GitHub #SoftwareEngineering #DevTools #CodeReview #DeveloperExperience

A friend was about to make his Django project public. I checked the commit history before he pushed. Six weeks earlier, he'd put a Stripe secret key directly in settings.py. He removed it two commits later and never thought about it again. The current code was clean. But the git history had the full key, right there. The repo had been accessible for six weeks -> plenty of time for any automated scanner crawling GitHub for exposed keys to find it and try it. History scanning is on by default partly because of that conversation.

🚀 GitHub just made code reviews a lot smarter with Stacked PRs (gh stack) If you’ve ever opened a massive PR and thought: Who is going to review this? you’re not alone. That’s exactly the problem GitHub is solving with stacked pull requests. 💡 Instead of one huge PR: You break your work into small, logical layers, each as its own PR, stacked on top of each other. 👉 Example: PR #1 → Auth logic PR #2 → API endpoints (depends on #1) PR #3 → Frontend (depends on #2) Each PR is: ✔ Easier to review ✔ Faster to merge ✔ Less prone to conflicts And the best part? 🔧 GitHub now supports this natively with: • A stack-aware UI (navigate layers easily) • Cascading rebases with one click • CLI support via `gh stack` • Ability to merge the entire stack together No more messy rebasing or waiting for one PR to merge before starting the next. 🔥 Why this matters: • Improves developer velocity • Makes code reviews actually meaningful • Reduces “PR fatigue” in teams This feels like a big step toward how modern teams should be shipping code. 🔗 gh stack: https://lnkd.in/dRvP8Cny #GitHub #SoftwareEngineering #DevWorkflow #CodeReview #Developers #Tech

GitHub adds Stacked PRs to speed complex code reviews A new feature to facilitate code reviews and prepare for an AI-driven surge in code changes. My PoV included in InfoWorld news today. https://lnkd.in/gF9kzM42

I'm not the best developer in the room. But I show up. I figure it out. And I ship. Last week I picked up an open source issue that had zero guidance, zero documentation and a codebase I had never seen before. Most people scrolled past it. I opened my terminal. The issue looked simple: "Add a 🔒 emoji to Discord ticket channels when closed. Remove it when reopened." The reality? error TS2741: Property 'closedTicketEmoji' is missing error: Argument of type '"ticket-close"' is not assignable error: Compilation Failed And that was just day one. 😅 Here's what nobody tells you about open source: You won't understand the codebase immediately. You will break things. The errors will feel personal. But every single error is just a breadcrumb showing you exactly where to go next. What I actually shipped: → Traced the feature across 7 production files → Added TypeScript type definitions → Hooked into an existing architecture pattern → Handled both close AND reopen logic → Zero breaking changes to existing features Not because I'm smart. Because I refused to stop. The PR is live. And honestly? That feeling of seeing your code sitting in a real production repository used by thousands of Discord servers worldwide — No tutorial gives you that. Here's my honest advice to every developer grinding right now: Stop consuming. Start contributing. Pick ONE open source issue this week. It doesn't have to be perfect. It just has to be yours. Are you contributing to open source or still waiting until you feel "ready"? #OpenSource #Developer #TypeScript #GitHub #SoftwareEngineering #Programming #CareerGrowth #100DaysOfCode

The Senior Dev in Your Pocket Most developers treat GitHub Copilot like a smarter autocomplete. That's the wrong mental model and it's costing them. This article walks through five real scenarios where Copilot with Claude becomes the senior developer you always needed but could never monopolize: explaining unfamiliar code, working through architecture trade-offs, pre-reviewing your own PRs, onboarding faster, and debugging with a thought partner who never loses patience. Heavy on practical prompts. Grounded in .NET Core and React. Written for the developer who just got access and the one who's been underusing it. Her is a link to the full article: https://lnkd.in/g7DnQrvf

The Problem We've all been there: dozens of old repos from tutorials, abandoned side projects, and test experiments piling up. Cleaning them up one by one through the GitHub UI is painfully slow — especially when you need to delete 20+ at once. The Solution I got tired of the manual process, so I built GitHub Repo Bulk Deleter — a lightweight local web tool that lets you wipe out multiple repositories in seconds. How it works: Paste your GitHub token → your repos load automatically Search, filter by Public/Private, and tick the ones you want gone Confirm with a safety prompt → watch them delete in real time Key Features ✅ Auto-load: Fetches your entire repo list with one click — no URL copy-pasting ✅ Smart Select: Search, filter by visibility, or hit Select All ✅ Real-time Progress: Each deletion streams live via Server-Sent Events ✅ Safe by Design: Requires typing DELETE before anything is removed ✅ CLI Mode: Scriptable via file input or stdin for automation use cases Tech Stack Built with #NodeJS, #ExpressJS, and the #GitHubAPI — zero frontend frameworks, no build step required. Open Source The project is free, open-source, and ready for feedback! 👇 https://lnkd.in/gbX8MgNc #WebDev #SoftwareEngineering #OpenSource #CleanCode #Automation #GitHub #DeveloperTools #NodeJS

I spent a few weeks telling Claude Code to handle CI failures itself. Run gh pr checks, parse the JSON, find the error, fix the code. It worked. In short sessions. The longer the session ran, the worse it got. The GitHub API returns verbose JSON. A single check run log can be tens of thousands of lines. The agent ingests all of that to find the three lines that actually matter. In a fresh context window, it manages. Three hours into a loaded development session? It starts hallucinating fixes for the wrong error or missing the signal entirely. I noticed a pattern. Each failed CI parsing attempt added more noise to the context, making the next attempt less likely to succeed. The agent wasn't getting dumber. Its context was getting noisier. So I built bellwether. It's a TypeScript CLI that reads your PR state, CI status, review comments, merge state, and returns compact filtered output. The actual compiler error, not the ten thousand lines around it. I'm not sure this is the final shape. But raw GitHub API output vs filtered signal, that's the difference between an agent that degrades over a session and one that stays sharp. #devtools #opensource #aiengineering

🚨 Hey vibe coders — this one's for you. You just built something cool. You're hyped. You push it to GitHub. And somewhere, a bot already found your API key. Let's talk about two files that every developer needs to understand: .env and .gitignore 📄 What is .env? It's a simple text file where you store sensitive configuration — things your app needs to run, but that should never be public: DATABASE_URL=postgres://user:password@host/db OPENAI_API_KEY=sk-... SECRET_KEY=mysupersecretvalue Your app reads these values at runtime. The point is: the secrets live here, not hardcoded in your source code. 🙈 What is .gitignore? It's a file that tells Git: "don't track these files." When you add .env to your .gitignore, Git will completely ignore it — it won't show up in commits, won't be pushed to GitHub, won't be visible to anyone. # cat .gitignore .env node_modules/ .DS_Store ⚠️ The trap beginners fall into: They create .env with their API keys They forget to add it to .gitignore They push to a public repo Automated bots scan GitHub 24/7 and find exposed keys within minutes I've seen this happen with AWS credentials that racked up thousands of dollars in charges overnight. ✅ The fix is simple: Before your first commit, run: echo ".env" >> .gitignore Done. Your secrets stay local. Your repo stays clean. One more thing: if you already pushed a key by accident, rotate it immediately. Deleting the commit is NOT enough. It's already been scraped. Security doesn't have to be complicated. It starts with two files and five minutes of attention. Are you using .env properly in your projects? Drop a comment 👇 #programming #webdevelopment #beginners #vibecoding #security #git #github #devtips #100daysofcode