All posts
Product

Connect Claude to Your GitHub Repo — and What It Can't See

A step-by-step guide to Claude's GitHub connector, its documented limit — no commit history — and how to still answer "what changed this week?".

The DeployIt Team

We build DeployIt, an MCP server that lets a whole company ask its code from Claude and track each developer's work.

There are two official ways to connect Claude to your GitHub repository: the native GitHub connector built into Claude.ai, which syncs the files of one branch into your Projects, and the GitHub MCP server, which gives Claude tool-based access to the repo. The part most guides skip: the native connector only sees files — Claude's official documentation states that it does "not retrieve commit history, PRs, or other metadata."

This guide does both jobs honestly: the step-by-step setup, then a demonstration of the limit — on a question every team eventually asks — and your options when that limit matters. If MCP servers are new to you, our plain-language explanation covers the vocabulary in five minutes.

Connecting Claude's native GitHub connector, step by step

The native connector is the simplest route, and for many uses it is the right one:

  1. Open a Project in Claude.ai (or create one): Projects are where shared knowledge for a conversation lives.
  2. Add content from GitHub: in the Project's knowledge sources, pick GitHub and authorize the app on your account or organization.
  3. Select the repository and the branch, then the files or folders to sync. On a large repo, pick the useful folders rather than everything: the context window is not infinite.
  4. Ask your questions. Claude answers from the synced file contents — architecture, business logic, conventions, "where is X handled".
  5. After the code changes, re-sync manually: the connector does not follow your pushes on its own. The sync action reloads the current state of the branch.

For understanding a codebase as it is today, this connector does its job well. That is exactly the scope it was designed for.

What the connector sees — and what it can't see

Claude's native GitHub connector syncs the names and contents of the files on one branch. Nothing else: no commit history, no diffs, no pull requests, no metadata.

That is the definition worth remembering, and it comes from the documentation itself. In practice:

  • It sees: the current state of the synced files — code, config, embedded docs, as of the last sync.
  • It can't see: what those files were yesterday, what changed between two versions, who introduced a change, in which pull request, with what intent.

A concrete example: your config file says retry_limit: 3. Claude, connected through the native connector, will happily tell you the retry limit is 3 and where it applies. Ask it since when it has been 3, whether it used to be 5, and why it changed: it has structurally no way to know. That information is not in the current state of the files — it lives in the git history, which the connector never receives.

"What changed in the product this week?" — the question that fails

Ask Claude that question through the native connector, and the honest answer it can give is "I see the current state of the code, not its evolution." A snapshot contains no delta. And this is not a textbook edge case — it is a whole family of questions teams ask constantly:

  • What changed since v2.3? (the customer coming back after two months)
  • Why did this behavior change? (the mystery support ticket right after a release)
  • Does this week's update break my integration? (the integrator who depends on your API)
  • Is this feature new, fixed, or deprecated? (customer success preparing a client call)

All of them need the same raw material: commit history and the contents of the diffs, the source behind asking your product what changed this week. That is exactly what the native connector does not sync. It is not an implementation flaw — it is a scoping decision. But you want to know about it before building your support or onboarding on top.

The DIY option: the official GitHub MCP server

The second official route: the GitHub MCP server, plugged into Claude (or Cursor) as an MCP connector. This one accesses the repository with tools: listing commits, reading pull requests, searching code. For a developer holding credentials, part of the question family above becomes reachable — and if your team writes disciplined commit messages, "what changed this week" can get a decent answer by aggregating the recent ones.

Let's be precise about what DIY covers well, and where it stops:

  • The diff is reachable, but one commit at a time. Let's be exact, because the shortcut "it only sees metadata" is everywhere and it is wrong: the official server's get_commit tool takes a detail parameter whose full_patch value returns the entire patch — the docs themselves warn it can be "very large". The limit is not access, it is scale: one call per commit, one patch per call, and nothing that aggregates. On a commit list alone, if the messages are vague ("fix", "wip", "tweaks"), the answer inherits their vagueness; and "why did this behavior change" requires reading the diffs and reconstructing intent — analysis work, not a lookup.
  • Every asker needs credentials on the repo. For you, a developer, that is one more token. For someone in support, in customer success or in sales, handing out repository access just to answer product questions is out of proportion.

If you are a well-tooled developer with disciplined commit habits, the official GitHub MCP server may be all you need — that is the honest answer. We have published its setup guide, and a record of what it really answers. What follows is for the other cases: askers without credentials, and questions whose answer lives in the diffs.

That is the slot DeployIt occupies. DeployIt is an MCP server. Your company gets one link, https://mcp.deployit.ai/<company>/<code>; each person adds it to Claude (on the web, on the desktop or in Claude Code) and signs up with a name and an email, which is not verified; their questions are logged under that name. Everyone starts with the Everyone profile: questions about the product, answered from the code; a filter removes the code, the file paths and the names of team members it recognises from the answers, without proving their absence, and a leak test tells you what still gets through. An administrator gives the Developers profile (excerpts) or the Leadership profile (developer statistics) to whoever needs it. Repositories are connected from GitHub or GitLab; DeployIt makes no commit, branch or pull request, and only adds one webhook per repository.

It reads the current code and the recent git history, and its copy is updated when you push, with no button to click. "What changed in the product this week?" goes to the recent_changes tool, which lists what landed over 90 days at most, by pull request or by module. To understand one change, ask_code reads the current code and the commits of the last 30 days at most: their messages and dates for every profile, their diffs as well for the Developers profile only. A question about behavior goes to ask_code, which investigates in the code before answering and labels the answer: verified, backend only, not found, or no conclusion.

The structural difference with the two routes above fits in one sentence: the people asking get the answers, not the code. Nobody receives a credential on the repository; each person holds their own DeployIt token, issued at sign-up, and removing the person turns it off.

Adding DeployIt to Claude, step by step

  1. An administrator connects the repositories in DeployIt, from GitHub or GitLab, and copies the company link.
  2. In Claude, open Settings, then Connectors, and add a custom connector with that link. On a Team or Enterprise plan, an owner adds it once for the whole organization; each member then clicks "Connect".
  3. Claude opens a DeployIt page: give your name and your email. That is the sign-up; it starts you on the Everyone profile.
  4. Ask a question: "What changed in the product this week?"

The link carries your company's code: share it inside the company, and change the code if it leaks. A machine does not sign up this way: a data tool connects with a key, and that key only reads statistics. For the whole product, including developer statistics, see DeployIt: ask your code and follow each developer's work from Claude.

Where your code goes

And because the question deserves to be turned around: yes, DeployIt itself reads your repositories. A working copy of the code is kept while a repository is connected, hosted by DigitalOcean in London (UK); at indexing, each source file is sent to the model to be summarised, then the passages needed for an answer and the diffs of the commits that are scored; OpenAI's models by default, or the provider whose key you bring. Removing a repository from DeployIt erases its copy. The details are on the security page.

On the rest of the landscape: Context7 covers public libraries, DeepWiki documents GitHub repos (public first), Mintlify generates an MCP server from written documentation, drift included. Your private product, read from the code itself and asked by the whole company, is the gap DeployIt fills.

Mini-FAQ

Does Claude's GitHub connector read commit history? No. The official documentation is explicit: only file names and contents on one branch are synced — no commit history, no PRs, no metadata.

Is Claude project knowledge the same thing as an MCP server? No: it is a folder of files, synced by hand, against a source queried at the moment of the question. The three gaps are laid out in our comparison of Claude project knowledge and an MCP server.

Is the official GitHub MCP server enough for "what changed"? Partly, for a developer with credentials: it lists commits and reads PRs. Answer quality tracks commit-message quality, and "why did this behavior change" requires analyzing diffs. Askers without repo access stay locked out either way.

Can my support team, or our AI support agent, use either of these routes? Not as a machine. Both routes assume GitHub credentials per asker. With DeployIt, the people on your support team sign up through the company link from Claude and ask there; an AI support platform does not query the code, since a machine only reads statistics. What changes for an AI support agent is covered in AI support agents that don't know your product.

Does DeployIt see all my code? It reads the connected repositories, writing nothing to them but one webhook per repository, and keeps a working copy while they are connected. What it shows depends on the profile: no code, file path or name that the filter recognises for Everyone; excerpts for Developers. A leak test checks the filter on each profile and tells you what came out; it warns and blocks nothing.


Connecting Claude to GitHub is the right instinct; you just need to know what each route can see. For the current state of the code, the native connector is enough. For the "what changed" family, and for people who should not hold repository access, you need the history, the code and one company link: that is DeployIt's job.

Price. Free plan: 15 questions a week for the whole company. A 30-day trial, no card. Plans from €290 a month excluding tax for up to 25 tracked developers: see pricing.

Ask your code from Claude

30-day trial, no card. Or try the demo first: add https://mcp.deployit.ai/demo to your Claude connectors.

Connect my code

Continue reading