5 ways to transform your workflow using GitHub Copilot and MCP

Traditional AI coding assistants typically operate in isolation, limited to the code in your current workspace. Now with the introduction of the Model Context Protocol (MCP), AI development workflows are further evolving to incorporate more tools and context. 

MCP can enable AI assistants to interact with external systems like knowledge bases, data stores, and testing applications.

The real value of MCP integration is that you can now perform tasks that previously required multiple tools, context switching, and manual effort—all directly in your IDE. That means you can save time, maintain focus, and ship code faster.

In this article, we’ll explore five practical ways MCP integrations with GitHub Copilot can streamline your workflow. We’ll follow a realistic scenario: implementing a secure JWT (JSON Web Token) authentication system for a web application, illustrating an end-to-end workflow with MCP.

Let’s jump in. 

1. Using MCP to bridge design and development with Figma 

The gap between design and development has long been a source of friction in product teams. MCP provides a standardized way for GitHub Copilot to securely access and interpret design specifications directly. 

Instead of manually translating design details into code, MCP enables Copilot to automatically retrieve exact design parameters—such as colors, spacing, typography, and component states—and generate accurate, ready-to-use code. This integration reduces guesswork and streamlines the handoff between designers and developers.

We’ll start developing our new JWT authentication system by taking a look at the user-facing side. Let’s say the design team updated the authentication UI components in Figma, including login forms, error states, loading spinners, and success messages. Now, you need to implement these changes to match the new design system.

Start by asking Copilot, “What are the latest design updates for the login form and authentication components?” It will then retrieve specs for the elements that need to change. Then you can prompt it to create React components for each element:

• LoginForm with exact spacing, colors, typography
• AuthErrorMessage component with proper error styling
• TokenRefreshNotification component

Copilot will then give you ready-to-use code that maintains consistency with the design specifications from Figma.

2. Tap into your Obsidian knowledge base with MCP

When implementing complex features like JWT authentication, you often need to reference past decisions, architectural notes, and research findings scattered across your knowledge base. The unofficial, community-maintained Obsidian MCP server bridges this gap by connecting GitHub Copilot directly to your Obsidian vault.

Let’s say you’re implementing JWT token validation and need to understand your team’s previous security decisions. You tell Copilot: “Search for all files where JWT or token validation is mentioned and explain the context.”

With that, Copilot can:

• Search across all Markdown files in your vault for relevant security patterns
• Retrieve contents from specific architecture decision records (ADR)
• Access meeting notes from previous security reviews
• Pull implementation guidelines from your team’s coding standards

You might follow up with the following prompt: “Get the contents of the last architecture call note about authentication and summarize the key decisions.” Copilot will locate the relevant file and extract the critical information you need to inform your implementation approach.

Once you’ve gathered the necessary context, you can ask Copilot to synthesize this information: “Create a new note called ‘jwt-implementation-summary.md’ that combines our authentication standards with the new JWT approach.” Copilot will create this documentation directly in your vault, helping maintain your team’s knowledge base.

Setup note: This integration requires the community “Obsidian Local REST API” plugin and an API key.

With your research complete and documented, you can proceed to test your application.

3. Test your code with Playwright

Integrating MCP with Playwright transforms test creation from a manual, error-prone process into a simple, guided experience.

Modern web applications often involve complex user journeys, asynchronous operations, and dynamic content. Authentication flows are particularly challenging to test comprehensively.

Continuing with our JWT authentication system, you need to test the complete authentication flow including login, token refresh, and secure route access. To do this, you’ll start by giving Copilot a prompt like this: “Test the JWT authentication flow including login, automatic token refresh, and access to protected routes.”

From there, Copilot will analyze your authentication implementation and generate comprehensive test coverage. But it doesn’t stop there. Copilot then runs the tests with Playwright and provides immediate feedback on failures, suggesting fixes for common issues, like timing problems or selector changes.

4. File pull requests faster

Pull requests are the cornerstone of collaborative development. GitHub’s remote MCP server, now in public beta for VS Code or Visual Studio, helps transform the process into an intelligent, automated workflow.

Turning back to our JWT authentication example, you can prompt Copilot: “Create a pull request for my authentication feature changes”

Copilot will then analyze:

• Code changes across multiple files  
• Related issues and project context  
• Team review patterns and expertise areas  
• Previous similar implementations

Copilot returns Markdown with an overview, changes made, a testing strategy, and even related issues.

It will then suggest appropriate reviewers for each aspect of the change based on code ownership, expertise mapping, and current workload.

Once your application is deployed, you can move on to monitoring it.

5. Monitor application performance

With the core authentication logic handled, now it’s time to ensure that our application performs well by monitoring how it behaves in production. Using MCP to connect to Grafana through the open-source Grafana MCP server makes this easier—though setup requires a few configuration steps.

Let’s say you need to analyze the JWT authentication system’s latency metrics and error rates. You tell Copilot: “Show me auth latency and error-rate panels for the auth-service dashboard for the last 6 hours.”

After configuring the Grafana MCP server with your API key and host URL, Copilot can then query your Grafana instance to:

• Examine authentication latency metrics and p95 response times
• Analyze error rates for login endpoints over time
• Review existing alert rules for authentication services
• Identify patterns in failed authentication attempts

Copilot returns panel data as base64-encoded images and can extract raw time-series data when needed. If you need a longer time range, you can specify: “Show me the same metrics for the last 24 hours” and Copilot will adjust the query parameters accordingly.

For more advanced monitoring workflows, you can enable write operations by launching the server with the --enable-write flag and an Editor-role API key. This allows Copilot to create new alert rules or modify dashboard configurations based on your authentication metrics analysis.

What’s next?

Before diving into these powerful integrations, you’ll need to configure your development environment. Here’s how:

1. Install MCP extensions: Enable MCP support in your IDE through official extensions
2. Configure API access: Set up authentication for each service (GitHub, Obsidian, Figma, etc.)
3. Define context boundaries: Establish what information should be accessible to AI
4. Security considerations: Implement proper access controls and data privacy measures

A few best practices:

• Start small: Begin with one integration and gradually expand your usage
• Maintain documentation: Keep your knowledge bases and documentation current for optimal AI assistance
• Regularly review Copilot’s outputs: Periodically audit AI-generated suggestions to ensure quality and security
• Build team alignment: Ensure your team understands and adopts consistent MCP usage patterns

The five integration patterns we’ve explored represent just the beginning of what’s possible. As MCP’s ecosystem grows, new tools and integrations will continue to expand what’s possible.

Written by

Klint Finley

@klintron