3 PRs merged into GitHub's spec-kit: docs fix, community catalog, argument-hints

Excited to share something I've been working on 🎉 GemReview is live on npm — and just crossed 850+ downloads 📈 It's an AI-powered CLI tool that reviews GitHub Pull Requests using Google Gemini — and posts findings as inline comments directly on your PR. What started as a personal itch ("I wish someone would catch the obvious stuff before I even ask for review") turned into a full-featured developer tool: ✅ 4 review dimensions — bugs, security, tests, performance ✅ Inline PR comments anchored to the exact diff line ✅ Structured severity summary on every PR ✅ Personal Mode (your own key) + Team Mode (shared org credits) ✅ GitHub Actions integration — automatic reviews on every PR ✅ Works with any programming language ✅ Fully open-source (MIT) Building this taught me a lot about developer tooling, LLM prompt design, and shipping a real product end-to-end. If you're working on a team that could use faster, more consistent code reviews — I'd love for you to try it out. ⭐ https://lnkd.in/gkSMEVeU  📦 npm install -g gemreview #OpenSource #AI #CodeReview #DevTools #GitHub #GoogleGemini #TypeScript #BuildInPublic #SoftwareEngineering

I built a tool that gives git a memory. Git tells you what changed. It has no idea why. After 6 months on a codebase, you're staring at files like middleware.py and old_auth.py with no idea what feature they belong to, whether anyone still uses them, or if they're safe to delete. I built gitmind to fix that. Every time you commit, a post-commit hook runs a local LLM (Ollama — no API costs, your code never leaves your machine) that analyzes the diff and writes structured metadata directly into your repo: → What changed → Why it likely changed → Which feature it belongs to → Which files are part of that feature Six months later you can ask: what's stale? what's safe to remove? when was auth last touched? And get a real answer. The part I'm most proud of: the tool documented its own development. Every commit I made while building it was analyzed by the LLM and stored in metadata.json. The build log on the docs site was written entirely by the AI — no human wrote a single summary. https://lnkd.in/eusR5TqA It also ships with a local web dashboard (python3 cli/dashboard.py) — feature health cards, a commit frequency chart, and a staleness report with an interactive threshold slider. No npm, no Node.js, just Python. Stack: Python · Ollama · qwen2.5-coder:7b · vanilla JS · GitHub Actions for CI + docs Fully open source. Would love feedback from anyone who's felt the pain of undocumented codebases. 🔗 https://lnkd.in/e92UVU5h #buildinpublic #opensource #devtools #python #llm #git

🚀 I built an open-source library of Claude Code rules & skills to keep AI-assisted development consistent across all my projects. The problem: every time I started a new project, I was re-explaining the same conventions to Claude — Clean Architecture, SOLID, idiomatic Go, PEP 8, React hooks rules… over and over. The solution: my-rules-skills — a single .claude/ folder you drop (or symlink) into any project. Claude Code automatically picks up the rules and skills from there. What's inside: 📐 Shared rules (apply to every language) Clean Code (Uncle Bob) SOLID principles enforcer Object Calisthenics ⚙️ .NET — Clean Architecture with Brighter/Darker, Minimal API, C# conventions 🐹 Go — Effective Go + Google Style Guide: naming, concurrency, error handling, project structure 🐍 Python — PEP 8/257/20, type hints, logging, src layout, pyproject.toml + uv ⚛️ React — Component purity, hooks rules, feature-slice architecture, React Query, TypeScript Each language also ships with a skill — a step-by-step workflow Claude follows when you say "add a new feature", automatically covering domain → service → repository → handler → tests. How it works: # Drop it into any project (or symlink to keep rules in sync) ln -s ~/my-rules-skills/.claude ./. claude Rules activate automatically based on file type. Skills are invoked by name or by describing what you want to do. It's agnostic, extensible, and completely free. Add your own rules in Markdown — no config, no build step. 👉 https://lnkd.in/d-3uNxaf Would love to hear how others are managing Claude Code conventions across projects. Are you doing something similar? #ClaudeCode #AI #DeveloperTools #SoftwareEngineering #CleanCode #SOLID #dotnet #golang #Python #React #OpenSource

As so many, I'd already landed on a pattern: using one model for development support, a different model family for code review. Just because the reviews were genuinely sharper. No grand theory, just vibes and better results. Turns out GitHub had the same instinct and decided to build it into the tool. Rubber Duck is a new experimental feature in Copilot CLI that pairs your primary coding agent with a reviewer from a completely different model family. For example, a Claude model orchestrates, and a GPT-model critiques... And crucially, it does this before anything gets built, not after you're already committed to a direction. Here's where it gets a bit uncomfortable though: Sonnet paired with Rubber Duck closed 74.7% of the performance gap between Sonnet and Opus on SWE-Bench Pro. Opus on a budget, basically. Great news, obviously, but if a second opinion from a different model family moves the needle that much, it's worth asking what that means for how we should be architecting agentic pipelines in the first place. Because the failure mode here isn't hallucination. It's compounding confidence... One assumption nobody questioned at step 2 quietly becoming a structural problem by step 47. Rubber Duck just asks the awkward questions early, before the damage is already baked in. Essentially a code reviewer who hasn't met you yet and has no reason to be nice. It turns out the duck needed a nemesis. 🐥🔪 I'm curious whether anyone else has stumbled onto patterns like this before the tools caught up? Drop them below, GitHub's clearly taking notes. 📋 Available now via /𝑒𝑥𝑝𝑒𝑟𝑖𝑚𝑒𝑛𝑡𝑎𝑙 in Copilot CLI. #GitHubCopilot #AIEngineering #AgenticAI

I just helped close a bug that had a developer stuck for 3 weeks. Not by writing a single line of code. Just by debugging it the right way. 🧠 Here's what was happening 👇 A developer was calling Appwrite's Users API with pagination. ✅ Without query params → 200 OK ❌ With query params → 401 Unauthorized Same API key. Same endpoint. Different result. He tried 5 different approaches over 3 weeks. Nothing worked. When I looked at it, the fix was one line. # ❌ What he was using queries[]=limit(1) # ✅ What actually works queries[0]={"method":"limit","values":[1]} Appwrite 1.x moved to JSON query format. He was still using the old 0.x shorthand syntax. 3 weeks. One syntax change. Issue closed. ✅ This is what I love about open source. You don't always need to write code to contribute. Sometimes showing up and helping someone debug is the most valuable thing you can do. If you're a developer, go contribute to open source. Comment on issues. Help others debug. You'll learn more from real bugs than from any tutorial. #OpenSource #GitHub #Appwrite #BackendDevelopment #BuildInPublic #SoftwareEngineering #DevCommunity #100DaysOfCode #Programming #APIDevelopment

Getting into a large codebase is a skill that does not get talked about enough. I was recently exploring the open-source codebase of Dub.co, and one thing became obvious very quickly: once a project gets large enough, reading code is no longer just about understanding syntax or logic. It becomes a navigation problem. The codebase is close to 100,000 lines, and at that size the real challenge is not just reading files. It is figuring out where to start, what actually matters, and how to build enough context to make meaningful contributions without getting lost. While exploring it, I came across a few tools that were genuinely helpful for reducing that initial friction: 1️⃣ DeepWiki   For public repos, you can usually take the GitHub repo URL and change the domain from github.com to deepwiki.com. It helps create a faster high-level map of the codebase. 2️⃣ Code Wiki   Paste the GitHub repository link directly into Code Wiki. It helps generate codebase docs and gives a more structured understanding of the project. 3️⃣ GitSummarize   You can take the GitHub repo URL and swap the domain to gitsummarize.com, or just paste the repo link into the site. It is useful for getting a quick summary of what the repository is doing. 4️⃣ Code2Tutorial   Paste a GitHub repository link into the site, and it turns the repo into a more tutorial-style walkthrough. Helpful when you want to learn the project in a more guided way. What I liked about these tools is that they do not replace reading the code. They make code reading more directed. They help answer questions like: Where should I start? What are the main modules? How does a request flow through the system? Which files are central, and which ones can wait? One thing I’m slowly learning is that reading a codebase well is a skill of its own. It is less about reading every file and more about building the right mental model early: architecture first, core flows next, implementation details after that. Curious how other people approach this: When you enter a large unfamiliar codebase, what is your method for getting productive quickly? #softwareengineering #opensource #programming #learninginpublic

Recently, I accidentally fell into a rabbit hole… and instead of climbing out, I opened the source code of an AI coding agent 👀 I’ve been curious about agentic coding for a while, so I gave Opencode a spin. And yes, my selection criteria were extremely rigorous… mainly “ooh nice UI” and “that name sounds cool” 😄 While using it, I noticed something odd (atleast to me): It only listed my sessions when I was inside the same folder where they were created. Switching folders? No sessions. Naturally, curiosity kicked in — so I dug into the source code 🔍 Here’s what I found: 👉 Project Identification Opencode generates a unique project ID to track sessions. It does this in two ways:  - If the folder is a Git repo:      It runs   $ git rev-list --max-parents=0 HEAD       to get the Git directory, then derives the project identity from it.       And here’s the fun part — it caches this inside .git/opencode.   Yes, it casually writes into your .git folder. Pretty clever.  - If Git is not initialized:       It falls back to a constant global value (so basically, all such folders look the same to it, no because there are some other conditions too). 👉 Session Tracking Each session gets its own unique ID. 👉 How it links everything It stores sessions in a SQLite database and connects them using the project ID as a foreign key. You can even find where this DB lives with: opencode db path 💡 Why sessions don’t show across folders? Because each folder = different project ID (especially if Git is initialized). No shared project ID → no shared session list. Honestly, I love these small design decisions. Simple idea, clean implementation, and very “developer-minded.” Diving into source code like this always feels like uncovering tiny engineering stories hidden beneath the UI 🚀 #OpenSource #AI #AgenticAI #CodingAgent #DeveloperLife #SoftwareEngineering #TechDeepDive #CodeReading #LearnInPublic #Git #SQLite #Programming #Developers #TechCuriosity #BuildInPublic #EngineeringInsights #Debugging #DevTools #BackendEngineering #CleanDesign

Yesterday, I joined the Open Source Friday live stream featuring Serena from GitHub. It was an insightful deep dive into collaborative development and real-world problem-solving. Watching experts navigate a codebase in real-time offers a perspective you can't get from documentation alone. It highlights the critical thinking, the debugging logic, and the architectural "why" behind every decision. My main takeaways from the session: Community-Driven Growth: Open source is about collective intelligence and making technology inclusive. The Learning Curve: Continuous exploration remains a constant, even for seasoned developers. The Reality of Building: Exploring the Serena project (https://lnkd.in/d9EKMbCn) was a great reminder that every polished feature begins with iterative, sometimes complex steps. For those looking to go beyond watching and start using it, here is how to get Serena MCP running on your machine: 1. Installation on Windows The simplest way to run Serena MCP is using uvx. It allows you to run Python packages on the fly without a complex local setup: Ensure Python is installed. Use uvx in your terminal to execute the package directly as per the documentation. This keeps your environment clean while giving you full access to Serena's capabilities. 2. Setup in VS Code (using GitHub Copilot) Once the server is ready, you can integrate it into your workflow in seconds: Add a configuration file: Create a .vs code folder in your project and add an mcp.json file. Register the server: Use the "Add Server" button or the command palette to link your MCP server. You can run it via a local command or even a Docker image. Interact: Once connected, your tools will appear directly in the Copilot chat, allowing you to query the Serena codebase or perform tasks through the MCP protocol seamlessly. A big thank you to Serena and the GitHub team for promoting the "Build in Public" mindset. 🚀 Are you currently contributing to any open-source initiatives or exploring MCP tools in your IDE? I’d love to hear about your experience in the comments. #OpenSource #GitHub #SoftwareEngineering #MCP #VSCode #SerenaProject #WebDevelopment #LearningInPublic #TechCommunity

📚 #PythonJourney | Day 146 — Documentation & Repository Setup After fixing the code and getting Docker running (Days 144-145), today was about making the project shine on GitHub. Key accomplishments: ✅ Fixed Git repository structure: • Moved .git from app/ to project root • Created comprehensive .gitignore • Cleaned up untracked files ✅ Created detailed README.md: • Project overview & features • Complete tech stack documentation • Local development setup guide • API endpoints reference • Docker commands • Development status & roadmap ✅ Added GitHub repository metadata: • Meaningful "About" description • Keywords and documentation • Clear project visibility ✅ Pushed all changes to GitHub What I learned: → Repository structure matters for large projects → Good README is as important as good code → Clear documentation attracts contributors & employers → Git workflow: understand your project root location The project now has: - Clean code structure - Detailed documentation - Professional GitHub presence - Clear roadmap for next steps Next: Create SQLAlchemy models and start writing tests. #Python #FastAPI #GitHub #Documentation #Backend #OpenSource #SoftwareDevelopment #DevOps

This article discusses how GitHub Copilot CLI utilizes the Rubber Duck model to provide developers with a second opinion on code suggestions. I found it interesting that this approach leverages different model families to enhance coding efficiency and reduce errors. What strategies are you using to ensure code quality and accuracy in your projects?