GitHub's MCP Server Built with Go for Scalable AI Tooling

Most portfolio projects could be built in a weekend. I wanted to build something that couldn't. So I reverse-engineered how GitHub works and built RepoDoc — a full-stack version control platform with a custom Git-like CLI, completely from scratch. Here's what it actually does: 🗂️ Repos → Full CRUD, in-browser file editing, commit history, S3-backed storage 👤 Users → Profile management, image uploads, JWT auth 🐛 Issues → Create, update, close, delete per repository ⭐ Social → Star / Unstar repos 💻 Custom CLI: init → spins up a local .repoGit directory add → stages a file commit → commits everything staged push → ships files to AWS S3 pull → pulls latest from S3 revert → rolls back to any commit by ID The CLI and integrating AWS with it alone took longer than most of my previous projects combined. Because when you build the tool instead of just using it, you finally understand it. The real takeaway wasn't the tech stack. It was finally understanding why the tools we use every day are designed the way they are. You don't get that from tutorials. You get it from breaking things and fixing them yourself. 🎥 Short walkthrough below. Drop your thoughts! 🔗 Live link in the comments. If you've ever built dev tooling from scratch, what broke first? #softwareengineering #buildinpublic #fullstackdevelopment #reactjs #nodejs #javascript #aws

GitHub just admitted their 10X capacity plan was not enough. They now need 30X. The CTO published an update today that reads like a war report. Two incidents in the last week: a merge queue bug that corrupted branch state across 658 repositories, and a search outage that killed UI functionality for hours. Both trace back to the same root cause. Agentic coding. Since late December 2025, autonomous AI coding agents have been hammering GitHub's infrastructure at a rate nobody planned for. Repository creation, pull requests, API calls, automation, large-repo workloads - all growing exponentially. And here is the part that makes it interesting: a single pull request can touch Git storage, mergeability checks, branch protection, GitHub Actions, search, notifications, permissions, webhooks, APIs, background jobs, caches, and databases. At scale, small inefficiencies compound. Queues deepen. Cache misses become database load. Retries amplify traffic. GitHub Actions is getting hit especially hard. Agentic workflows spawn long-running, parallel CI sessions that dwarf what human developers generate. Copilot code review now consumes GitHub Actions minutes on top of AI credits. The automation layer was not designed for agents running multi-hour autonomous sessions at this volume. The free ride is ending. Starting June 1, Copilot moves to usage-based billing measured in AI credits tied to token consumption. GitHub has already paused new sign-ups for several Copilot tiers. A quick chat question and a multi-hour autonomous coding session used to cost the same amount. That math does not work anymore. Which raises the real question: is the agentic era sustainable on infrastructure built for humans? GitHub is rearchitecting critical systems, isolating services, migrating off legacy frameworks, and pursuing multi-cloud. But the honest read is that the platform is playing catch-up to a usage pattern that showed up faster than anyone modeled. When your 10X plan lasts four months before you need 30X, the planning horizon itself is broken. The agentic era is not a future problem. It is a right-now infrastructure problem. And someone has to pay for it. #GitHub #AgenticAI #DevOps

GitHub just claimed your code belongs to them the moment you use Copilot. Are we actually okay with this? Starting April 24th, GitHub will use everything that flows through Copilot to train their models — by default. Your prompts, your accepted suggestions, your private repository context. Opt-out exists. It's just not the default. This is worth sitting with for a moment, because it raises a question most of us have been quietly avoiding. When AI is part of the writing process, who owns what gets written? You defined the problem. You wrote the prompt. You reviewed the suggestion, cut half of it, rewrote the rest, and shipped it. The model contributed structure; you contributed judgment. Now GitHub wants to feed that entire interaction — including the private repo context that shaped it — back into a model your competitor will use tomorrow. We had an earlier version of this debate with Stack Overflow. Developers spent years contributing answers freely. The platform packaged that knowledge and sold it to AI companies. The developers who built that knowledge base got nothing back. Copilot is the same dynamic with a sharper edge. Stack Overflow harvested your public posts. This harvests your private reasoning while you build. The justification I keep hearing is that better training data produces a smarter Copilot, and a smarter Copilot benefits you. That logic is real as far as it goes. It also justifies almost anything. We don't accept it from hospitals or banks. The logic alone doesn't settle where the line is. Three positions I've seen people land on: The first is that code written with AI assistance was never fully yours to begin with — the model contributed, so the model has a claim on the output. The second is that the tool is the instrument and the developer is the author — a photographer owns their work regardless of who manufactured the camera. The third is that ownership is the wrong frame entirely: the real question is who profits, and right now that answer is Microsoft, not you. I don't have a clean position on which of these is right. What I do think is clear: opt-out-by-default is a deliberate design choice. They could have made it opt-in. They chose not to. Making inaction equal to consent — and making that easy not to think about — is the part that should bother every developer reading this. Where do you land?

GitHub shifting to they own own your code, prompts, etc. when you use CoPilot is fundamentally different than Stack Overflow having rights to the coding Q&A data on their platform. Stack Overview was community based with people answering questions knowing they were contributing their knowledge and expertise for free to the development community. If GitHub is switching to a business model where they own the prompts, manual and AI generated code, and can glean the expert judgement you used to accept/reject/modify the AI generated code to power and enhance their AI models using your private repositories by default, that is sneaky at best and outright theft at worst.

I've been putting more and more context into GitHub repos. Not just code, but the why behind decisions. Design docs, ADRs, transcripts of meetings where someone argued for approach A and someone else pushed back with approach B, etc. If you're using AI agents like Claude Code, this context matters a lot. Without it, the agent will re-ask questions your team already settled six months ago in a meeting. It can see the code but not the reasoning. The catch is that the more context you add, the harder it gets to find anything. grep "retry" doesn't find the issue titled "Resilience strategy for upstream timeouts." The words don't match even though the topic is the same. I looked at existing semantic search tools and they all have the same friction. Either you need to build an index before you can search (which goes stale), or a hosted service. Neither works when you just cloned a repo 2 minutes ago and need to find something now. That's the actual workflow when working with agents, though. So I built vex (Vector EXamine). Ask a question in plain English, get back the relevant code, docs, and issues. It searches by meaning. No setup, and it's fast enough to not break your flow. There's also vex sync github, which pulls your issues and PRs down as local Markdown. After that, searches automatically cover them too. So "why did we change the auth flow" might surface the PR discussion from three months ago, the architecture doc, and the code, all together. It ships with a Claude Code skill so agents can use it alongside their usual tools too. Still a work in progress. Try it and let me know what you think: https://lnkd.in/gKuEmB8w (Short video attached. 1.5gb of files, no index, results in under a second)

GitHub's uptime dropped below 90% this year. Features ship late. And the companies that filled those gaps? GitHub is now coming for them. But is the platform reliable enough? They shipped native stacked PRs in private preview. Meta proved this workflow over a decade ago. Graphite launched it three years ago. GitHub is only just catching up, and both Graphite and Aviator have gotten a little less defensible. The smart ones built beyond the gap. Graphite's review UI and AI reviewer are ahead of GitHub's. Blacksmith, WarpBuild, and Depot have Docker caching, sandboxes, and build optimisations GitHub hasn't touched. But the pattern is still worth watching: ecosystem finds a gap, builds a business, GitHub ships a "good enough" native version. Runners are the biggest example. Blacksmith and WarpBuild both exist because Actions is slow and overpriced. GitHub even tried charging $0.002/min for self-hosted runners on your own hardware. Reversed in 24 hours after community revolt. "Postponed." Not cancelled. GitLab hasn't won the market. AWS and Google both tried and walked away. AI means teams are shipping faster than ever, and that needs a platform you can rely on. If you can't deploy because CI is down, or you can't open a pull request because GitHub is unavailable, that directly impacts one of the things that matters most right now: how fast you can ship against your competition. Maybe the answer isn't another layer on top of GitHub. Maybe it's replacing it entirely. The question is will anyone try?

I started my career writing code in C++ and Java. Then moved to Python, Rust, and more — but now? I write in plain Markdown 🙂 Recently, I wrote a skill for GitHub Copilot to calculate your Azure bill. For those unfamiliar, there's a marketplace for GitHub Copilot skills (https://lnkd.in/e2tDyqfw) where you can add extra superpowers to your Copilot. The project has 300+ contributors (https://lnkd.in/eH9tZN3g) — it's a thriving community! Search for "Azure Pricing" to find my skill, or explore others that can make your Copilot even more powerful.

GitHub Copilot just made a quiet but significant move — and it reveals a structural problem worth understanding. This week, GitHub removed Claude Opus from its Pro plan entirely. Opus 4.7 is now Pro+ only, at a 7.5x premium request multiplier ("promotional" until April 30). For context: the standard Opus multiplier was 3x. That's a 150% price jump on their most capable model, with limited advance notice. New Pro and Pro+ sign-ups are also temporarily paused as of April 20. This isn't a pricing complaint. It's a trust and architecture problem. Copilot has evolved into a multi-model marketplace — GPT, Claude, Gemini, Grok all available. That's genuinely useful. But it also means Copilot doesn't control the economics of the models it resells. When Anthropic prices Opus at frontier rates, Copilot absorbs that cost and passes it on — unpredictably, mid-cycle, with multipliers that change without warning. Developers in GitHub's own community forums documented costs jumping from 1x to 3x overnight on Opus 4.5 with no prior communication. One team wrote: "seeing costs jump from 1x to 3x without any prior communication creates a difficult situation." This is the core tension: Copilot's strength is distribution — IDE integration, GitHub context, enterprise rollout. Its weakness is that it doesn't own the intelligence it's built on. For boilerplate and autocomplete, this is fine. But for agentic workflows, deep debugging, and architecture decisions — the tasks where model capability actually changes outcomes — unpredictable access to frontier models is a reliability problem, not just a pricing complaint. The teams I've seen migrate to Claude Code or direct API access aren't doing it for raw capability. They're doing it for predictability and control. As AI becomes load-bearing in engineering workflows, those two things will matter just as much as benchmark scores.

I built a Docker management dashboard with 105+ features. It uses ~50MB of RAM. Here's the thing — Portainer CE uses ~250MB and still locks  half its features behind a $120/node/year paywall. So I built Docker Dash. Open source. MIT license. Zero paywall. What started as a weekend project turned into something with: → Sandbox Mode — paste a GitHub URL, it auto-detects the stack,   installs dependencies, and runs the app in an isolated container → Enterprise UI Mode — ESXi-inspired interface with right-click   context menus, bottom task bar, and column configuration → Multi-Host Overview — vCenter-style view of all your Docker   hosts, stacks, and containers on one page → AI Container Doctor — plug in OpenAI or a local Ollama and   get diagnostics directly in the dashboard → 46 built-in How-To guides (EN + RO) for beginners → CIS Docker Benchmark with one-click hardened compose generation → 20 developer tools built in (regex tester, IP calculator,   hash generator, JSON formatter...) No build step. No React. No Angular.  Just Node.js, vanilla JavaScript, and SQLite. One command to install: docker compose up -d The whole thing runs in a single container. It's MIT licensed because I believe infrastructure tools  should be free. Not freemium. Free. ⭐ GitHub: https://lnkd.in/dpEwcxYz If you manage Docker containers — give it a try and let me  know what you think. PRs and feedback welcome. #OpenSource #Docker #DevOps #SelfHosted #InfrastructureAsCode

GitHub is sitting in a strange spot right now: critical infra for almost every dev team, but struggling with reliability just as AI agents are flooding it with new load. Availability dropping to "one nine" and a steady stream of outages point to infra that was built for humans, not thousands of bots spinning up repos and hammering APIs in the background. At the same time, a tiny startup like Pierre Computer claims to handle repo creation at a scale that looks tailor-made for agents, not people. If GitHub wants to stay the top git platform for AI-native development, it has to treat agent traffic as first-class. That means an AI-native git layer, better scaling of stateful systems like databases and Redis, and a clear North Star around being the backbone for agentic code lifecycles. The current mix of Copilot branding, internal politics, and no CEO naturally pulls attention away from the boring but essential work of hardening the platform. But it is also worth being cautious with the clean narrative. GitHub runs a very different workload from a greenfield product in closed beta, with years of baggage, enterprise constraints, and a massive ecosystem to keep stable. Self-reported numbers from a startup and a rough month of incidents are not enough on their own to declare the incumbent broken or the new model proven. Shutting down Copilot or slicing away half the product surface sounds decisive, yet could throw away real value while the market is still figuring out how devs and agents should work together. The useful takeaway is not that GitHub is doomed or that an AI-only platform will automatically win, but that infrastructure and product strategy now have to be designed around agents and humans coexisting at scale. Getting that tradeoff right - reliability for everyone, while building new, agent-native primitives with a clear focus - will matter a lot more than any single outage or launch over the next few years. https://lnkd.in/dECY42Vt