DEV Community

Cover image for Using GitHub MCP With Continue to Review PRs and Issues 5 Faster
Anita Ihuman 🌼
Anita Ihuman 🌼

Posted on

Using GitHub MCP With Continue to Review PRs and Issues 5 Faster

#webdev #ai #productivity

As developers embrace sophisticated AI assistants like Continuous AI, the barrier between context, collaboration, and code generation is dissolving. But how do you bridge the gap between an intelligent AI in your IDE and the complex, living ecosystem of your codebase, which often resides on GitHub?

In private repositories, you might ship a new feature in minutes, but you still have to write a detailed PR description, link related issues, and hope a busy maintainer gets to it soon. In open source, the challenge is even heavier. Maintainers are flooded with pull requests, each requiring mental context switching, security scrutiny, and style-guide checks—all of which contribute to the burnout that many in the community report. However, what if you could use your AI assistant to understand the entire conversation happening on your GitHub repository from your IDE?

In this article, we are going to integrate Continuous AI directly with GitHub using the Model Context Protocol (MCP) to intelligently triage issues, suggest PR fixes, and understand your project's history from VS Code.

What the GitHub MCP Does (and Why It Matters)

The Model Context Protocol (MCP) is an open standard that allows AI tools to interact securely and contextually with external systems. Since GitHub introduced its MCP server, it quietly changed how AI tools could interact with repositories. It’s like giving your AI assistant access to now understand your repo’s context, read issues and pull requests, and even help you generate responses or code suggestions with full context instead of generic guesses.

When you integrate this MCP with an assistant coding tool like Continuous AI, your IDE gains awareness of:

  • The current branch, commits, and recent pull requests
  • Open issues with labels, authors, and comments
  • Code diffs, line-by-line changes, and linked discussions

Prerequisite:

Before you dive in, make sure you have the following setup.

  • Install the extension. Ensure you have the Continue extension installed in your preferred IDE (VS Code or JetBrains).
  • Install Tools & Authenticate: Install the Continue CLI (npm i -g @continuedev/cli) and the GitHub CLI (gh). Authenticate the GitHub CLI by running gh auth login in your terminal.
  • A GitHub account and a repository to work with Generate GitHub Token: Create a GitHub Personal Access Token (PAT) with the necessary scopes (at least repo:read).

Step 1: Connecting Continue.dev to GitHub

To make your Continue assistant talk to GitHub repository, you need to register the GitHub MCP server. This process is a one-time setup.

  1. Install GitHub MCP via Continue Mission Control: You can install the pre-built GitHub agent by going to the GitHub Project Manager Agent page within the Continue Mission Control interface and clicking the Install button. The listing provides a pre-configured MCP block to your agent.

  2. Set the Secret: Head over to the settings in the Continue Hub and

    • Provide your GITHUB_TOKEN to Continue Mission Control, set it in your shell environment.
    • You will also need to provide an Anthropic API key. So navigate to the console and create one (subscription is required).

  3. Select Your Config: Head over to your IDE to the Continue panel and click the config selector in your IDE’s Continue panel. You can create a new configuration file in your project's directory.

  • Manual Config (e.g., in .continue/config.yaml): You need to define a custom agent that includes the GitHub MCP as a tool that will handle the underlying connection. Use the following sample code and update it with your API keys and token. 
# This is an example configuration file
# To learn more, see the full config.yaml reference: https://docs.continue.dev/reference
name: Example Config
version: 1.0.0
schema: v1
# Define which models can be used
# https://docs.continue.dev/customization/models
models:
 - name: my gpt-5
   provider: openai
   model: gpt-5
   apiKey: YOUR_OPENAI_API_KEY_HERE
 - uses: ollama/qwen2.5-coder-7b
 - uses: anthropic/claude-4-sonnet
   with:
     ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
# MCP Servers that Continue can access
# https://docs.continue.dev/customization/mcp-tools
mcpServers:
 - uses: anthropic/memory-mcp
    with:
     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     # OPTIONAL: You may need a host if using GitHub Enterprise
     # GITHUB_HOST: ${{ secrets.GITHUB_HOST }}
Enter fullscreen mode Exit fullscreen mode

4.Sync and Code: Click “Reload config” to pull your latest settings
5.Launch the Agent: From your repo root, in the terminal, run the following command:

cn --agent continuedev/github-project-manager-agent
Enter fullscreen mode Exit fullscreen mode

Now, when you enter a prompt like this: “List my open issues labeled bug and summarize priorities,” you should be able to see the list of available issues in the repository, along with a summary of the issue.

Step 2: The Developer Flow - Creating Issues and Summaries

As a developer, you can use the integrated agent to handle post-coding administrative tasks without leaving your code editor.

Use Case 1: Creating a Post-Development Issue

You finished a feature, but you noticed a low-priority item that needs to be addressed later (e.g., "The API response mapping needs type enforcement").

  • Prompt in Continue Chat: "Create a new GitHub issue titled 'Refactor: Add type enforcement to /api/v1/user response mapping.' Assign it the label 'enhancement' and add a brief description explaining that the current implementation is brittle."

Use Case 2: Summarizing Code for the Commit Message/PR Description

You’ve made a large refactor. You don't want to manually scan the diff for the commit message.

  • Prompt in Continue Chat (after staging changes): "Analyze all staged files. Summarize the changes in a concise, bulleted list that could serve as the body of my Pull Request description. Focus on the 'why' and the new architecture."

  • Agent Action: Although I do not have a PR or any recent updates to this repo. However, ideally, the agent will use the diff resource (from the local workspace context) and the GitHub MCP's file context for comparison. It then returns a clean summary ready for you to copy-paste into your git commit or PR template. This is a massive time-saver for detailed documentation.

Step 3: The Maintainer Flow - Reviewing PRs and Triaging Backlogs

As a maintainer of an open source project, you can automate the initial screening and feedback loop for pull requests received to the project repository.

Use Case 3: Automated Initial PR Review

For example, let's say a new contributor submits a PR. Before you read a single line of code, you will need a quick technical assessment.

  • Prompt in Continue Chat: "Review Pull Request #5 on the main branch. Check for obvious security flaws (e.g., using eval() or un-sanitized input) and summarize if it adheres to our project's max-line-length rule. Post the summary as a single comment on the PR."
  • Agent Action:
    1. The agent uses the GitHub MCP's get_pull_request_diff tool to pull the content.
    2. It applies specialized Rules (custom functions defined in Continue) to scan the code for the requested patterns.
    3. It uses the GitHub MCP's add_comment tool to post the findings, and you should get something like this: “ AI Review: No immediate security flaws detected. However, three files exceed the 80-character line limit. Please address these before human review.”

Use Case 4: Mass Backlog Triage

If you need to clean up a stale issue backlog by prioritizing or closing old items, you can also use the GitHub MCP we configured to handle this.

  • Prompt in Continue Chat: "List all open issues older than 90 days with no activity in the last 30 days. For each, draft a comment asking, 'Is this still a relevant issue? If no response in 7 days, we will close it.' Only draft the comments, do not post them automatically."
  • Agent Action: The agent will query GitHub MCP's get_issues tool with the specified filters (age, activity). It compiles a list and provides the draft comments for you to review and approve one by one before they are posted to GitHub.

Why Does This Matter?

According to GitHub’s 2024 Octoverse Report, developers spend nearly 40% of their coding time navigating, reviewing, or refactoring existing code. Tools like Continue use these MCPs to reduce that friction by merging context, intent, and automation.

For open source maintainers, this means fewer cognitive jumps between contexts, and for developers, it means faster reviews and higher-quality contributions. And for teams, it’s a subtle but meaningful shift toward flow-based collaboration, where context lives where you work, not in the dozen browser tabs you left open.

Top comments (0)