The Moment I Realized I Was Living in the Future
A few weeks ago I was staring at a pile of GitHub issues — bug reports, feature requests, a few "this is broken" messages with zero details — and I had to triage them before a Monday standup. It was Sunday afternoon. I did not want to be doing this.
On a whim, I connected the GitHub MCP server to Claude and typed something like: "Look at my open issues and give me a priority-sorted list with a one-line summary of each." Within about thirty seconds I had exactly that. Claude had read every issue, summarized them, and even flagged two that looked like duplicates.
I closed my laptop at 2pm. That basically never happens.
If you've been hearing about MCP but aren't sure what to actually do with it, this is a great place to start. GitHub is something almost every developer touches daily, and the GitHub MCP integration is genuinely one of the most useful ones out there.
Quick Recap: What MCP Actually Is
MCP stands for Model Context Protocol. It's basically a standardized way to give Claude (or another AI) access to external tools and data sources — like your file system, a database, or in this case, GitHub.
Without MCP, Claude knows nothing about your repos. It can't see your issues, your PRs, your commit history. It's just a smart chat window. With MCP, it gets a live connection to whatever you plug in.
The GitHub MCP server is an official server maintained by GitHub (and Anthropic contributed to the spec), so it's well-supported and actively updated. It's not some sketchy third-party plugin — this is real infrastructure.
Already used MCP for file access?
The setup pattern here is identical — you add a server entry to your MCP config file. If you've done it once, this will feel very familiar.
Step 1: Create a GitHub Personal Access Token
Before you touch any config files, you need a token so the MCP server can actually authenticate with GitHub on your behalf. This is a standard GitHub PAT — nothing exotic.
Head to GitHub → Settings → Developer settings → Personal access tokens → Tokens (classic). Click Generate new token.
For scopes, at minimum you'll want:
- repo — full repo access (read + write)
- read:org — if you work in a GitHub org
- read:user — for user-level queries
Copy the token immediately and save it somewhere safe (like a password manager). GitHub won't show it again after you leave the page.
Fine-grained tokens are even better
GitHub now supports fine-grained PATs that let you restrict access to specific repos. If you're security-conscious (you should be), use those instead of classic tokens with broad repo access.
Step 2: Install the GitHub MCP Server
The GitHub MCP server runs as a local Node.js process. You'll need Node installed (run node --version to check — anything v18+ is fine).
You don't actually install it as a global package. Instead, Claude Desktop (or Claude Code) will spin it up on demand using npx. You just need to configure it.
# Verify Node is installed
node --version
→ v20.11.0
# Verify npx works (comes with Node)
npx --version
→ 10.2.4Step 3: Add the Server to Your MCP Config
Now open your MCP configuration file. If you're using Claude Desktop, it lives here:
- Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
- Windows: %APPDATA%\Claude\claude_desktop_config.json
Add the GitHub server entry inside the mcpServers block:
// Your full config file
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "your_token_here"
}
}
}
}Replace your_token_here with the PAT you generated. Save the file, then fully quit and relaunch Claude Desktop. Not just close the window — actually quit it from the menu bar.
Don't commit this file to Git
Your PAT lives in plain text in this config. Make sure it's not in a version-controlled directory, or add it to your global .gitignore. Leaking a token is a bad day.
Step 4: Verify It's Working
When Claude Desktop relaunches, you should see a small hammer icon in the chat interface — that's the indicator that MCP tools are available. Click it and you should see GitHub-related tools listed.
Now test it with a simple prompt:
# Start simple — just confirm the connection works
List the repos in my GitHub account.
→ Claude will call the GitHub API and return your repo list
→ You'll see a "Using GitHub" tool call indicator in the chatIf it returns your repos, you're live. If you get an error about authentication, double-check your token and make sure you didn't accidentally add a space or cut it off.
Real Workflows You Can Run Right Now
Okay, here's where it gets fun. These are prompts I actually use, not theoretical examples.
Triage open issues:
Look at open issues in my-username/my-repo.
Summarize each one in a sentence, flag any duplicates,
and suggest priority labels (high/medium/low).Summarize a PR before reviewing it:
Read PR #47 in my-username/my-repo.
Give me a plain-English summary of what it changes
and flag anything that looks risky or worth a closer look.Draft an issue from a bug description:
The login button stops working after a user idles
for 10+ minutes on mobile Safari. Create a well-formatted
GitHub issue in my-username/my-repo with steps to reproduce,
expected vs actual behavior, and a suggested label.That last one blew my mind the first time. Claude wrote a better bug report than I would have, opened the issue, and gave me the link. Total time: maybe 20 seconds.
What the GitHub MCP Server Can (and Can't) Do
Here's a realistic rundown so you don't go in with wrong expectations:
It can: List and read repos, issues, PRs, commits, and file contents. Create and update issues. Add comments. Create branches. Open PRs with a title and body.
It cannot (yet): Run GitHub Actions, merge PRs on its own, manage org-level settings, or handle things that require GitHub's web UI specifically. It's API-driven, so if the GitHub REST API supports it, MCP can probably do it. If it doesn't, it can't.
The practical upshot: it's a powerful read-and-draft layer. You still review and approve the important stuff yourself. I think of Claude as the world's fastest junior dev who preps everything for me — I still make the final call.
A Note on Security Before You Go All In
I want to be real with you here. You're giving Claude live write access to your GitHub repos. That's meaningful. A few habits worth building:
- Use fine-grained PATs scoped to specific repos, not a blanket token for everything.
- For anything destructive (deleting branches, closing issues in bulk), ask Claude to show you what it's about to do before it does it.
- Rotate your token every few months. GitHub will remind you if you set an expiration.
- Watch the tool call indicators in Claude's UI — you can always see exactly what it's calling before results come back.
None of this should scare you off. It's the same mindset you'd apply to giving any service OAuth access to your GitHub. Just be deliberate about it.
Start with a test repo
If you're nervous, create a throwaway public repo and point Claude at that first. Get comfortable seeing how it behaves before connecting it to anything mission-critical.
This Is What MCP Is Actually For
When people ask me why MCP matters, I always come back to GitHub as my go-to example. It's not a toy integration — it's a real productivity multiplier for something you use every single day.
The mental model shift for me was realizing Claude isn't just answering questions anymore. With MCP, it's actually doing things — in your tools, in your repos, in your world. That's a different kind of useful.
Start with the read-only stuff. List your issues. Summarize a PR. Get the feel for it. Then when you're comfortable, let it draft that issue for you and actually create it. You'll wonder pretty quickly why you were ever doing any of this by hand.
More tutorials in this category, or explore the full field guide.